dry-consolidation（干固结）

DRY Consolidation

Systematic extraction of duplicated code into shared, tested abstractions.

When to Use This Skill

Context

• Target path:!echo "$1"
• Project type:!find. -maxdepth 1 \(-name "package.json" -o -name "Cargo.toml" -o -name "pyproject.toml" -o -name "go.mod" \)
• Source directories:!find. -maxdepth 1 -type d \(-name "src" -o -name "lib" -o -name "app" -o -name "components" -o -name "packages" \)
• Test framework:!find. -maxdepth 2 \(-name "vitest.config.*" -o -name "jest.config.*" -o -name "pytest.ini" -o -name "conftest.py" \)
• Existing shared utilities:!find. \(-path "*/lib/*" -o -path "*/utils/*" -o -path "*/shared/*" -o -path "*/common/*" -o -path "*/hooks/*" \) -type f -print -quit

Parameters

• $1: Path or directory to scan (defaults to src/)
• --scope: Focus on a specific extraction type: utilities, components, hooks, or all (default: all)
• --dry-run: Analyze and report duplications without making changes

Execution

Execute this 7-step consolidation workflow. Use TodoWrite to track each extraction as a separate task.

Step 1: Scan for duplicated patterns

Scan the target path for duplicated patterns. Search for these duplication signals:

Identical function bodies:

Grep for function/method signatures that appear in multiple files.
Look for identical multi-line blocks (3+ lines) across files.

Repeated inline patterns:

• Utility functions defined identically in multiple files (string truncation, date formatting, validation)
• Identical error handling blocks (try/catch patterns, error state JSX)
• Copy-pasted UI fragments (pagination controls, confirmation dialogs, loading states)
• Repeated hook/state management patterns (delete confirmation + mutation + handler)
• Duplicated import blocks that signal repeated inline implementations

Search strategy:

1. Use Grep to find repeated function names, variable patterns, and import clusters
2. Use Glob to identify files with similar structure (e.g., all *List.tsx, all *Detail.tsx)
3. Read candidate files to confirm duplication and measure scope

Step 2: Classify duplications

Group discovered duplications into extraction categories:

Follow the project's existing conventions for shared code location. If no convention exists, propose one based on the framework.

Step 3: Plan extractions

For each duplication cluster, plan the extraction:

1. Name the abstraction — Use a clear, descriptive name that reflects the shared behavior
2. Define the interface — Determine parameters needed to cover all usage variations
3. Choose the location — Follow project conventions for shared code placement
4. List all consumers — Identify every file that will be updated
5. Assess risk — Note any subtle differences between duplicated instances that need parameterization

Present the plan to the user before proceeding (unless --dry-run was not specified and the scope is clear).

Plan format:

## Extraction Plan

### 1. [Abstraction Name] → [target file path]
- Type: utility | component | hook
- Replaces: [N] identical blocks across [M] files
- Consumers: [list of files]
- Parameters: [any variations that need to be parameterized]
- Estimated lines saved: [N]

Step 4: Extract shared abstractions

Execute each planned extraction:

1. Create the shared abstraction with proper typing and documentation
2. Replace each instance in consumer files with an import + usage of the new abstraction
3. Handle variations — parameterize differences between instances rather than creating multiple abstractions
4. Update imports — add the new import, remove imports that were only needed for the inline version

Extraction order: Start with utilities (no dependencies), then components, then hooks (may depend on utilities/components).

Mark each extraction as completed in the todo list before moving to the next.

Step 5: Write tests

Write tests for each extracted abstraction:

Place test files adjacent to the abstraction or in the project's test directory, following existing conventions.

Step 6: Clean up dead code

After all extractions are complete:

1. Remove unused imports from all updated consumer files
2. Remove dead code — inline helper functions that are now replaced
3. Verify no orphaned references — search for any remaining references to removed code

Step 7: Verify all checks pass

Run the full verification suite:

TypeScript/JavaScript projects:

npx tsc --noEmit          # Type checking
npm run lint              # Linting (or biome/eslint directly)
npm run test              # Full test suite

Python projects:

ty check .                # Type checking
ruff check .              # Linting
pytest                    # Test suite

Rust projects:

cargo check               # Type checking
cargo clippy              # Linting
cargo test                # Test suite

All three must pass. If any fail, fix the issues before reporting completion.

Output Summary

After all phases complete, report:

## DRY Consolidation Summary

### Extractions
- [Abstraction Name] (type) — replaced N blocks in M files
- ...

### New Files Created
- path/to/new/file.ts — [description]
- ...

### Tests Added
- N tests across M test files

### Net Effect
- ~N lines of duplicated code consolidated
- N reusable abstractions created
- All verified: typecheck + lint + N passing tests

Agentic Optimizations

See Also

• /code:refactor — Functional refactoring of a file or directory (pure functions, immutability, composition)
• /code:antipatterns — Detection-only analysis for code smells
• ast-grep-search — Structural code search for finding patterns

Related Skills

• If dead code detected during consolidation → /code:dead-code
• If complexity is high after consolidation → /code:complexity