semcod/redup
GitHub: semcod/redup
面向 LLM 和开发团队的多语言代码重复检测与重构规划工具，帮助识别和管理代码技术债务。
Stars: 0 | Forks: 0
# reDUP
**面向 LLM 的代码重复分析器和重构规划器。**
[](https://pypi.org/project/redup/)
[](https://opensource.org/licenses/Apache-2.0)
[](https://python.org)
[](https://pypi.org/project/redup/)
## AI 成本追踪
   
  
## 功能
- **精确重复检测** 通过 SHA-256 块哈希实现
- **结构化克隆检测** — 相同的 AST 结构，不同的变量名
- **LSH 近似重复检测** 用于大型代码块（>50 行）
- **多语言支持** — 通过 tree-sitter 支持 35+ 种语言（Python, JavaScript, TypeScript, Go, Rust, Java, C/C++, C#, Ruby, PHP, Bash, SQL, HTML, CSS, Lua, Scala, Kotlin, Swift, Objective-C, JSON, YAML, TOML, XML, Markdown, GraphQL, Dockerfile, Makefile, Nginx, Vim, Svelte, Vue 等）
- **并行扫描** 用于大型项目（性能提升 2 倍以上）
- **增量扫描缓存** (`--incremental`) 用于加快重复运行速度
- **仅扫描变更模式** (`--changed-only`) 用于聚焦 git-diff 的分析
- **模糊近似重复匹配** 通过 SequenceMatcher / rapidfuzz 实现
- **语义重复匹配** 通过可选的代码 embeddings 实现，包括跨语言对
- **可解释的意图配置** 源自目的名称、调用、数据术语和控制流效果
- **来源分类** 将可操作的债务与生成/部署副本区分开
- **声明的意图匹配** 通过可选的 Intract 合约实现
- **函数级分析** 使用 Python AST 和 tree-sitter 提取
- **影响评分** — 通过 `saved_lines × similarity` 对重复项进行优先级排序
- **重构规划器** — 生成具体的提取/内联建议
- **多种输出格式**：JSON, YAML, TOON, Markdown
- **配置系统** — TOML 文件和环境变量
- **CLI 命令**：`scan`, `compare`, `diff`, `check`, `config`, `info`
- **跨项目比较** — 检测项目间的共享代码并提供合并/提取建议
- **CI 集成** 带有可配置的质量门禁
- **整洁的输出** — 不会出现来自外部库的语法警告
## 新特性 (v0.4.20)
### 🤖 MCP Server
用于 AI 助手集成的完整 MCP (Model Context Protocol) 服务器：
```
# 启动 MCP server
redup-mcp
# 或 HTTP 模式
#### redup-mcp --transport http --port 8000
**Available Tools:**
- `analyze_project` — Full duplication analysis
- `find_duplicates` — Quick duplicate detection
- `check_project` — Quality gate check
- `compare_projects` — Cross-project comparison
- `suggest_refactoring` — AI-powered refactoring suggestions
- `project_info` — Project metadata
### 🌐 跨语言 Semantic Similarity 检测
Embedding-based matching finds related functions even when their syntax and implementation differ:
```bash
# 安装可选的 model runtime，然后扫描选定的语言
pip install 'redup[semantic,ast]'
#### redup scan . --semantic --semantic-threshold 0.80 --ext .py,.js,.ts,.php
`--fuzzy` remains a faster source-text similarity pass for near-identical implementations.
Use `--intent` with Intract contracts when intent must be explicit and auditable rather than inferred.
Normal reports classify each group as `refactor`, `review`, or `generated`. Generated
source-to-build and deployment-mirror groups stay visible but are excluded from automatic
refactoring suggestions.
**Supported Patterns:**
- Functions, classes, API endpoints
- Database queries, web components
- Auth/validation, error handling, logging
- Configuration, infrastructure code
### 🌳 模块化 Tree-Sitter Extractor
#### 重构了 tree-sitter 提取，采用干净、模块化的架构：
ts_extractor/
├── extractors/ # Modular per-language extractors
│ ├── c_family.py # C, C++, C#, Objective-C
│ ├── go.py # Go
│ ├── java.py # Java, Scala, Kotlin
│ ├── markup.py # HTML, XML, Svelte, Vue
│ ├── web.py # JavaScript, TypeScript
│ └── ...
├── dispatcher.py # Smart language routing
├── config.py # Language registry
#### └── main.py # 统一 API
**Benefits:**
- Easier to add new languages
- Better testability
- Cleaner separation of concerns
## - 支持 35+ 种语言
## 新特性 (v0.5.0+)
### 🌐 Semantic Similarity 检测
Cross-language matching for functions whose implementation syntax differs:
```bash
# 检测不同语言间的相似行为
redup scan . --semantic --semantic-threshold 0.80 --ext .py,.js,.ts
# 跨项目 semantic 比较
#### redup compare ./project-a ./project-b --semantic --threshold 0.75
**Features:**
- Adds `SEMANTIC` groups to normal scan reports
- Supports a configurable Sentence Transformers code model
- Keeps source-text fuzzy matching separate for predictable thresholds
- Leaves auditable intent equivalence to explicit Intract contracts
### 🧩 模块化 ts_extractor 架构
#### tree-sitter 多语言提取器已从一个 782 行的 god module 重构为一个干净的 package：
redup/core/ts_extractor/
├── extractors/
│ ├── web.py # JavaScript/TypeScript
│ ├── c_family.py # C/C++
│ ├── dotnet.py # C#
│ ├── ruby.py # Ruby
│ ├── php.py # PHP
#### │ └── ... # 10+ 个特定语言模块
**Benefits:**
- Better maintainability (avg 100 lines per module vs 782)
- Easier to add new language extractors
- Shared base utilities for common operations
- Full backward compatibility maintained
### 🎯 增强的 TOON Reporter
The TOON format now includes actionable sections for practical refactoring:
- **HOTSPOTS** — Top 7 files with most duplicated lines (where to focus effort)
- **QUICK_WINS** — Low-risk, high-savings suggestions (do first)
- **DEPENDENCY_RISK** — Duplicates spanning multiple packages (cross-module risk)
- **EFFORT_ESTIMATE** — Time estimates per task with difficulty (easy/medium/hard)
### 🤖 LLM 驱动的 Refactoring Plans
Generate AI-assisted refactoring TODO lists from cross-project comparisons:
```bash
#### redup compare ./project-a ./project-b --refactor-plan --env .env --output report.json
- Uses `litellm` for flexible LLM provider support
- Compact metadata-only prompts for efficiency
- Structured JSON output with prioritized tasks
- Token usage tracking
### 📊 简化的 Compare Reports
Cross-project comparison reports are now more compact and human-readable:
- Relative file paths instead of absolute
- Matches deduplicated by function pair
- Communities with compact member dicts
- Filtered trivial entries to reduce noise
- ~60% smaller JSON size
## 安装
```bash
#### pip install redup
With optional dependencies:
```bash
pip install redup[all] # Everything
pip install redup[fuzzy] # rapidfuzz for better similarity matching
pip install redup[ast] # tree-sitter for multi-language AST
pip install redup[lsh] # datasketch for LSH near-duplicate detection
pip install redup[semantic] # sentence-transformers for semantic scan matches
pip install redup[intent] # Intract for declared-intent duplicate detection
pip install redup[compare] # networkx for cross-project community detection
#### pip install redup[llm] # 用于 LLM 驱动 refactoring plans 的 litellm
## 快速开始
### CLI
```bash
# 扫描当前目录，输出 TOON 到 stdout
redup scan .
# 扫描并保存 JSON 输出到文件
redup scan ./src --format json --output ./reports/
# 针对大型项目的并行扫描
redup scan . --parallel --max-workers 4
# 在多次运行间复用 cache 以实现更快的重新扫描
redup scan . --incremental
# 仅扫描相较于 branch tip 变更的文件（基于 git diff）
redup scan . --changed-only --base-ref origin/main --incremental
# 支持 35+ 种语言的多语言扫描
redup scan . --ext ".py,.js,.ts,.go,.rs,.java,.rb,.php,.html,.css,.sql,.lua,.scala,.kt,.swift,.m,.json,.yaml,.toml,.xml,.md,.graphql,.dockerfile,.svelte,.vue"
# 跨语言 / 不同实现的匹配（可选 model 依赖）
redup scan . --semantic --semantic-threshold 0.80 --ext ".py,.js,.ts,.php,.go,.rs,.java"
# 来自 Intract contracts 的可审计 same-intent 匹配
redup scan . --intent --intent-manifest intent.yaml
# 带阈值的 CI gate
redup check . --max-groups 10 --max-lines 100
# 比较两次扫描
redup diff before.json after.json
# 跨项目比较（merge 与 extract 决策）
redup compare ./project-a ./project-b --threshold 0.75
# 带有 LLM 驱动的 refactoring plan（需要 litellm + 包含 API keys 的 .env）
redup compare ./project-a ./project-b --refactor-plan --env .env --output comparison.json
# 指定自定义 LLM model
redup compare ./project-a ./project-b --refactor-plan --llm-model openrouter/anthropic/claude-3.5-sonnet
# 初始化配置
#### redup config --init
```bash
# 扫描并输出所有格式
redup scan . --format all --output ./redup_output/
# 仅函数级别重复（更快）
redup scan . --functions-only
# 自定义阈值
redup scan . --min-lines 5 --min-sim 0.9
# 显示已安装的可选依赖
redup info
# 将重复项作为任务导出到 TODO.md（需要：pip install redup[tasks]）
redup tasks ./my-project
# 通过 GitHub sync 导出
redup tasks ./my-project --backend github --milestone "Sprint 1"
# 通过 GitLab sync 和自定义输出导出
redup tasks ./my-project -b gitlab -o refactoring-tasks.md
# 预览任务而不创建文件
#### redup tasks ./my-project --dry-run
### 使用 Planfile 进行任务管理（可选）
When you install `redup[tasks]`, you can export duplication findings as
actionable tasks in TODO.md format with synchronization to GitHub, GitLab,
or Jira:
```bash
# 安装 planfile 支持
pip install redup[tasks]
# 根据重复项生成 TODO.md
redup tasks ./my-project --output TODO.md
# 生成的 TODO.md 包含：
# - 基于优先级的任务组织（critical/major/minor）
# - 难度估计（easy/medium/hard）
# - 节省行数潜力
# - 详细的 refactoring 建议
# - Planfile 导出配置
```
TODO.md 输出示例：
```
# TODO - 重复 Refactoring 任务
## CRITICAL（3 个任务）
- [ ] **Refactor: process_file (4x duplication)** 🔴
Priority: critical | Savings: 124L
Extract function to shared utility module.
Files: src/core/scanner.py, src/core/planner.py, ...
## MAJOR（5 个任务）
- [ ] **Refactor: validate_input (3x duplication)** 🟡
Priority: major | Savings: 45L
#### ...
### 配置
Create a `redup.toml` file:
```toml
[scan]
extensions = ".py,.js,.ts,.go,.rs,.java,.rb,.php,.html,.css,.sql,.lua,.scala,.kt,.swift,.m,.json,.yaml,.toml,.xml,.md,.graphql,.dockerfile,.svelte,.vue"
min_lines = 3
min_similarity = 0.85
include_tests = false
[lsh]
enabled = true
min_lines = 50
threshold = 0.8
[check]
max_groups = 10
max_lines = 100
[output]
format = "toon"
output = "redup_output"
[reporting]
include_snippets = true
#### generate_suggestions = true
Or use `[tool.redup]` in `pyproject.toml`. Environment variables with `REDUP_` prefix override file settings.
### Python API
```python
from pathlib import Path
from redup import ScanConfig, analyze
from redup.reporters.toon_reporter import to_toon
from redup.reporters.json_reporter import to_json
config = ScanConfig(
root=Path("./my_project"),
extensions=[".py", ".js", ".ts", ".go", ".rs", ".java", ".rb", ".php", ".html", ".css"],
min_block_lines=3,
min_similarity=0.85,
)
result = analyze(config=config, function_level_only=True)
print(f"Found {result.total_groups} duplicate groups")
print(f"Lines recoverable: {result.total_saved_lines}")
# 供 LLM 使用
print(to_toon(result))
# 供工具 / CI 使用
#### Path("duplication.json").write_text(to_json(result))
## 输出格式
### TOON（针对 LLM 优化）
```
# redup/duplication | 15 groups | 86f 10453L | 2026-04-16
SUMMARY:
files_scanned: 86
total_lines: 10453
dup_groups: 15
dup_fragments: 36
saved_lines: 217
scan_ms: 3620
HOTSPOTS[7] (files with most duplication):
src/redup/core/ts_extractor.py dup=74L groups=4 frags=11 (0.7%)
src/redup/core/scanner_utils.py dup=70L groups=3 frags=3 (0.7%)
src/redup/core/scanner_loader.py dup=52L groups=1 frags=1 (0.5%)
DUPLICATES[15] (ranked by impact):
[E0001] ! EXAC _preload_files L=52 N=2 saved=52 sim=1.00
src/redup/core/scanner_loader.py:9-60 (_preload_files)
src/redup/core/scanner_utils.py:53-104 (_preload_files)
REFACTOR[15] (ranked by priority):
[1] ◐ extract_module → src/redup/core/utils/_preload_files.py
WHY: 2 occurrences of 52-line block across 2 files — saves 52 lines
FILES: src/redup/core/scanner_loader.py, src/redup/core/scanner_utils.py
QUICK_WINS[8] (low risk, high savings — do first):
[3] extract_function saved=26L → src/redup/core/utils/find_exact_duplicates_lazy.py
FILES: lazy_grouper.py
[4] extract_function saved=21L → src/redup/core/utils/_extract_functions_go.py
FILES: ts_extractor.py
DEPENDENCY_RISK[3] (duplicates spanning multiple packages):
validate_input packages=2 files=2
api/routes/users.py
services/auth/validate.py
EFFORT_ESTIMATE (total ≈ 8.7h):
hard _preload_files saved=52L ~156min
hard __init__ saved=36L ~108min
medium find_exact_duplicates_lazy saved=26L ~52min
easy _is_test_file saved=12L ~24min
METRICS-TARGET:
dup_groups: 15 → 0
#### saved_lines: 可恢复 217 行
### JSON（机器可读）
```
{
"summary": {
"total_groups": 3,
"total_saved_lines": 84
},
"groups": [
{
"id": "E0001",
"type": "exact",
"normalized_name": "calculate_tax",
"fragments": [
{"file": "billing.py", "line_start": 1, "line_end": 8},
{"file": "shipping.py", "line_start": 1, "line_end": 8}
],
"saved_lines_potential": 16
}
],
"refactor_suggestions": [
{
"priority": 1,
"action": "extract_function",
"new_module": "utils/calculate_tax.py",
"risk_level": "low"
}
]
#### }
## 跨项目比较
The `redup compare` command analyzes two separate projects to detect shared code and recommends a refactoring strategy:
- **Merge projects** — if >60% code overlap
- **Extract shared library** — if 5-60% overlap with well-defined clusters
- **Keep separate** — if <5% overlap
### CLI 用法
```bash
# 基础比较
redup compare ./project-a ./project-b --threshold 0.75
# 使用 semantic similarity（较慢，更准确）
redup compare ./project-a ./project-b --semantic --threshold 0.70
# 多语言项目
redup compare ./backend ./frontend --ext ".py,.js,.ts" --threshold 0.80
# 跳过 community detection（更快，无需 networkx）
redup compare ./a ./b --no-community
# 生成 LLM 驱动的 refactoring plan（需要 redup[llm]）
#### redup compare ./a ./b --refactor-plan --env .env --output plan.json
### 示例输出
```
Comparing project-a ↔ project-b (threshold=0.75)
┏━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┓
┃ Cross-Project Comparison ┃
┡━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━┩
│ Metric │ Value │
├─────────────────────────┼────────────────────────────┤
│ Project A files │ 42 │
│ Project B files │ 38 │
│ Project A lines │ 8500 │
│ Project B lines │ 7200 │
│ Cross matches │ 15 │
│ Shared LOC (potential) │ 1200 │
└─────────────────────────┴────────────────────────────┘
Recommendation: extract_shared_lib
15% overlap (1200 shared lines, 5 clusters). Extract to shared library.
Confidence: 80%
Top Communities (shared code candidates):
┏━━━━┳━━━━━━━━━━━━━━━━━━━━━━┳━━━━━━━━━━━━┳━━━━━┳━━━━━━━━━━┓
┃ ID ┃ Name ┃ Similarity ┃ LOC ┃ Members ┃
┡━━━━╇━━━━━━━━━━━━━━━━━━━━━━╇━━━━━━━━━━━━╇━━━━━╇━━━━━━━━━━┩
│ 0 │ validate_input │ 0.89 │ 180 │ 5 │
│ 1 │ parse_config │ 0.82 │ 140 │ 4 │
│ 2 │ format_response │ 0.76 │ 100 │ 3 │
#### └────┴──────────────────────┴────────────┴─────┴──────────┘
### Report JSON 结构
```
{
"project_a": "./project-a",
"project_b": "./project-b",
"stats": {
"a": {"files": 42, "lines": 8500},
"b": {"files": 38, "lines": 7200}
},
"total_matches": 15,
"shared_loc_potential": 1200,
"recommendation": {
"decision": "extract_shared_lib",
"rationale": "15% overlap (1200 shared lines, 5 clusters). Extract to shared library.",
"overlap_pct": 0.1523,
"shared_loc": 1200,
"confidence": 0.8
},
"communities": [
{
"name": "validate_input",
"similarity": 0.89,
"loc": 180,
"members": [
{"project": "A", "file": "api/validators.py", "function": "validate_input"},
{"project": "B", "file": "utils/validation.py", "function": "validate_input"}
]
}
],
"matches": [...]
#### }
### 算法概述
The comparison uses a **3-tier similarity detection**:
1. **Structural hash** — exact AST matches (fast, O(n+m))
2. **LSH (Locality Sensitive Hashing)** — near-duplicates via MinHash
3. **Semantic similarity** — CodeBERT embeddings (optional, slowest)
Matches are deduplicated by `(function_a, function_b, file_a, file_b)` with the highest similarity score retained.
### Community Detection
Requires `networkx` (`pip install redup[compare]`).
Uses **greedy modularity communities** on a similarity graph where:
- Nodes = functions from both projects
- Edges = similarity score (filtered by `--threshold`)
- Communities = clusters of mutually similar functions
Each community gets a generated name based on longest common prefix of its member functions (e.g., `validate_*` → `validate_input`).
## 架构
```
src/redup/
├── __init__.py # Public API
├── __main__.py # python -m redup
├── mcp_server.py # MCP server entry point (re-exports from mcp package)
├── mcp/ # MCP server package
│ ├── __init__.py # Public MCP API
│ ├── handlers.py # Tool handlers
│ ├── schemas.py # JSON-RPC schemas
│ ├── server.py # JSON-RPC server core
│ └── utils.py # Shared utilities
├── core/
│ ├── models.py # Pydantic data models
│ ├── scanner.py # File discovery + block extraction
│ ├── scanner/ # Scanner package
│ │ ├── __init__.py # Public scanner API
│ │ ├── cache.py # Memory cache
│ │ ├── filters.py # File filtering
│ │ ├── loader.py # File preloading
│ │ └── types.py # Scanner types
│ ├── hasher.py # SHA-256 / structural fingerprinting
│ ├── matcher.py # Fuzzy similarity comparison
│ ├── planner.py # Refactoring suggestion generator
│ ├── pipeline.py # Legacy: re-exports from pipeline package
│ └── pipeline/ # Pipeline package (new)
│ ├── __init__.py # analyze(), analyze_optimized(), analyze_parallel()
│ ├── phases.py # scan_phase(), process_blocks()
│ ├── duplicate_finder.py # Duplicate finding phases
│ └── groups.py # Group creation, deduplication
│ └── ts_extractor/ # Tree-sitter extraction (35+ languages)
│ ├── __init__.py # Public API
│ ├── main.py # Core extraction API
│ ├── dispatcher.py # Language routing
│ ├── config.py # Language registry
│ └── extractors/ # Per-language extractors
├── reporters/
│ ├── json_reporter.py # JSON output
│ ├── yaml_reporter.py # YAML output
│ └── toon_reporter.py # TOON output (LLM-optimized)
└── cli_app/
#### └── main.py # Typer CLI
## 分析流水线
```
1. SCAN Walk project, read files, extract function-level + sliding-window blocks
2. HASH Generate exact (SHA-256) and structural (normalized AST) fingerprints
3. GROUP Bucket by hash, keep only groups with 2+ blocks from different locations
4. MATCH Verify candidates with fuzzy similarity (SequenceMatcher / rapidfuzz)
5. DEDUP Remove overlapping groups (keep highest-impact)
6. PLAN Generate prioritized refactoring suggestions with risk assessment
#### 7. REPORT 导出为 JSON / YAML / TOON
## 近期改进 (v0.5.0)
### 🏗️ **模块化架构重构**
Major internal restructuring for better maintainability and extensibility:
#### MCP Server Package
#### MCP server 已从一个 675 行的 monolith 拆分为一个干净的 package：
redup/mcp/
├── __init__.py # Public API
├── handlers.py # 8 tool handlers
├── schemas.py # JSON-RPC schemas
├── server.py # Server core
#### └── utils.py # 实用工具
- **82% code reduction** in main file
- **Backward compatible**: `mcp_server.py` re-exports all APIs
- **Better testability**: Isolated handlers can be tested independently
#### Pipeline Package
#### 分析 pipeline（714 行）现在位于一个模块化 package 中：
redup/core/pipeline/
├── __init__.py # analyze(), analyze_optimized(), analyze_parallel()
├── phases.py # scan_phase(), process_blocks()
├── duplicate_finder.py # find_exact_groups(), find_structural_groups(), etc.
#### └── groups.py # deduplicate_groups(), blocks_to_group() 等
- **66% reduction** in main orchestrator file
- **Phases can be used independently** for custom workflows
- **Cleaner separation** of concerns
#### Scanner 改进
The scanner has been refactored with extracted helpers:
- `_init_strategy()` - Strategy initialization
- `_process_single_file()` - Per-file processing
- `_extract_blocks_for_file()` - Block extraction
- **Reduced CC** and **fan-out** in main `scan_project()` function
### 🎯 **Sprint 1 重构完成**
- **Reduced cyclomatic complexity** from CC̄=4.2 to CC̄=3.5
- **Eliminated all critical functions** (CC > 10): 2 → 0
- **Achieved HEALTHY status** with no structural issues
- **Dispatch pattern implementation** for AST node processing
- **Modular TOON reporter** split into 5 focused functions
- **CLI refactoring** with helper functions for better maintainability
### 🚀 **技术成就**
- **`_process_ast_node`**: CC=14 → CC=6 (dispatch dict pattern)
- **`to_toon`**: CC=12 → CC=8 (5 helper functions)
- **CLI `scan()`**: fan-out=18 → ≤10 (4 helper functions)
- **Code quality**: 0 high-complexity functions
- **Test coverage**: 64/64 tests passing (100%)
### 📊 **质量指标**
- **Health status**: ✅ HEALTHY (no critical issues)
- **Cyclomatic complexity**: CC̄=3.5 (target ≤ 3.0 achieved)
- **Maximum CC**: 9 (target ≤ 10 achieved)
- **Code maintainability**: Significantly improved
- **Duplication**: Minimal (2 groups, 6 lines - acceptable patterns)
### 🔧 **代码架构**
- **Dispatch tables** for extensible AST processing
- **Single responsibility** functions throughout codebase
- **Clean separation** of concerns in CLI pipeline
- **Type safety** improvements with proper annotations
## - 针对边缘情况增强了**错误处理**
## 集成 wronai Toolchain
reDUP is part of the [wronai](https://github.com/wronai) developer toolchain:
- **[code2llm](https://github.com/wronai/code2llm)** — static analysis engine (health diagnostics, complexity)
- **reDUP** — deep duplication analysis and refactoring planning
- **[code2docs](https://github.com/wronai/code2docs)** — automatic documentation generation
- **[vallm](https://github.com/semcod/vallm)** — validation of LLM-generated code proposals
### 📈 **典型工作流：**
1. `code2llm` analyzes the project → `.toon` diagnostics
2. `redup` finds duplicates → `duplication.toon.yaml`
3. Feed both to an LLM for targeted refactoring
4. `vallm` validates the LLM's proposals before merging
### 🎯 **为什么选择 reDUP？**
- **LLM-ready**: TOON format optimized for LLM consumption
- **Actionable**: Generates concrete refactoring suggestions
- **Prioritized**: Ranks duplicates by impact and risk
- **Integrated**: Works seamlessly with wronai toolchain
- **Fast**: Scans 1000+ lines in < 1 second
## - **整洁**：无语法警告，专业输出
## 开发
```bash
git clone https://github.com/semcod/redup.git
cd redup
pip install -e ".[dev]"
#### pytest
## 许可证
Licensed under Apache-2.0.
## 作者
Tom Sapletta
## 状态
_Last updated by [taskill](https://github.com/oqlos/taskill) at 2026-04-25 13:46 UTC_
| Metric | Value |
|---|---|
| HEAD | `7055183` |
| Coverage | 42.9% |
| Failing tests | — |
| Commits in last cycle | 50 |
> Added markdown output and a configuration management system, with numerous docs and code-analysis refactors and some test additions. Several refactors target the code analysis engine and TypeScript extractor components.
```
标签：IPv6支持, 逆向工具