duplicate-code-detector

Files (1)

• SKILL.md

SKILL.md (first lines)

# Duplicate Code Detector

Analyze recently changed source files, detect meaningful duplicate code patterns with semantic judgment, and open focused remediation issues (one issue per pattern, up to 3).

## Mission

Detect significant duplicate code patterns in recently changed files using semantic analysis and open focused remediation issues (one per pattern, up to 3).

## Scope

- Prioritize files changed recently (default: last 3 days).
- Analyze source code only.
- Exclude generated files, lock files, vendored dependencies, build outputs, and workflow/config boilerplate unless explicitly requested.
- Exclude tests by default unless the user asks to include them.

## Workflow

### 1. Discover Recently Changed Files

Use git to build a candidate set from recent commits:

```bash
git log --since="3 days ago" --name-only --pretty=format: | sort -u | sed '/^$/d'
```

Then filter to source files likely to contain business logic (for example: `.go`, `.py`, `.rb`, `.java`, `.js`, `.ts`, `.tsx`, `.cjs`, `.cs`, `.php`, `.cpp`, `.c`, `.rs`).

If no recent source files exist, stop and report:

```text
No recently changed source files found for duplicate analysis.
```

### 2. Build Semantic Context

For each candidate file:
- Read file content.
- Identify major functions, methods, classes, and helpers.
- Capture intent-level summaries of each significant symbol.

Use semantic comparison, not just string matching:
- Similar control flow and branching.
- Similar error-handling logic.
- Similar data transformation pipelines.
- Copy-paste with renamed variables.

### 3. Detect and Cluster Duplicate Patterns

Group findings into distinct patterns. A pattern is issue-worthy only when it is significant:
- More than 10 lines of materially duplicated logic, or
- 3 or more similar occurrences.

Classify each pattern:
- Exact duplication.
- Structural duplication.
- Functional duplication.

### 4. Deduplicate Against Existing Local Findings

Before creating each finding draft, check prior local duplicate-code reports and skip noisy repeats.

Create metadata for the finding:
- `pattern_key`: derive from involved file paths by taking `{parent-dir}-{stem}` for each file, sorting, joining with `-`, and truncating to 60 chars.
- `file_paths`: normalized, sorted file paths.

Query existing local reports:

```bash
ls reports/duplicate-code-detector/*.md 2>/dev/null
```

Skip creating a new issue when any rule matches:
- File recency rule (30 days): exact same `file_paths` set found in an issue created in the last 30 days.
- Pattern frequency rule: at least 2 open issues already contain the same `pattern_key`.
- File cooldown rule (7 days): any file in the current finding appears in an issue created in the last 7 days.

### 5. Produce Focused Remediation Drafts (Max 3)

Create at most 3 finding drafts for the highest-impact patterns.

Use this title format:

```text
[duplicate-code] Duplicate Code: <short pattern name>
```

Use this body template:

```markdown
# Duplicate Code Detected: <Pattern Name>

## Summary
<Brief description of the duplicate pattern and why it matters>

## Duplication Details
- Severity: High | Medium | Low
- Occurrences: <N>
- Locations:
  - <path1> (lines X-Y)
  - <path2> (lines A-B)

## Impact
- Maintainability: <impact>
- Bug Risk: <risk>
- Code Bloat: <impact>

## Refactoring Recommendations
1. <recommendation>
2. <recommendation>

## Implementation Checklist
- [ ] Review findings
- [ ] Agree extraction target or shared utility
- [ ] Implement refactor
- [ ] Update tests
- [ ] Verify behavior parity

## Analysis Metadata
- Analyzed Files: <count>

From veverkap/skills, MIT.

More from veverkap/skills