reuse-health-inline
Inline orchestration workflow for code duplication detection and consolidation. Provides step-by-step phases for reuse-hunter detection, priority-based consolidation with reuse-fixer, and verification cycles.
When & Why to Use This Skill
This Claude skill provides an automated, inline orchestration workflow for detecting and consolidating code duplication. It systematically identifies redundant TypeScript types, Zod schemas, and utility functions, refactoring them into a single source of truth while maintaining code integrity through iterative verification and build-validation cycles.
Use Cases
- Eliminating redundant TypeScript interfaces and types across large-scale monorepos to reduce maintenance overhead and improve type safety.
- Consolidating duplicated Zod schemas and validation logic into shared packages to ensure data consistency across different application layers.
- Identifying and merging copy-pasted utility functions and configuration constants into centralized modules to minimize technical debt.
- Performing automated code health audits during refactoring phases to enforce 'Single Source of Truth' architectural patterns.
| name | reuse-health-inline |
|---|---|
| description | Inline orchestration workflow for code duplication detection and consolidation. Provides step-by-step phases for reuse-hunter detection, priority-based consolidation with reuse-fixer, and verification cycles. |
| version | 2.0.0 |
Code Reuse Health Check (Inline Orchestration)
You ARE the orchestrator. Execute this workflow directly without spawning a separate orchestrator agent.
Workflow Overview
Detection → Validate → Consolidate by Priority → Verify → Repeat if needed
Max iterations: 3 Priorities: high → medium → low
Phase 1: Pre-flight
Setup directories:
mkdir -p .tmp/current/{plans,changes,backups}Validate environment:
- Check
package.jsonexists - Check
type-checkandbuildscripts exist
- Check
Initialize TodoWrite:
[ {"content": "Duplication detection", "status": "in_progress", "activeForm": "Detecting duplications"}, {"content": "Consolidate high priority duplications", "status": "pending", "activeForm": "Consolidating high priority"}, {"content": "Consolidate medium priority duplications", "status": "pending", "activeForm": "Consolidating medium priority"}, {"content": "Consolidate low priority duplications", "status": "pending", "activeForm": "Consolidating low priority"}, {"content": "Verification scan", "status": "pending", "activeForm": "Verifying consolidation"} ]
Phase 2: Detection
Invoke reuse-hunter via Task tool:
subagent_type: "reuse-hunter"
description: "Detect all code duplications"
prompt: |
Scan the entire codebase for code duplications:
- Duplicated TypeScript interfaces/types
- Duplicated Zod schemas
- Duplicated constants and configuration objects
- Copy-pasted utility functions
- Similar code patterns that should be abstracted
- Categorize by priority (high/medium/low)
Generate: reuse-hunting-report.md
Return summary with duplication counts per priority.
After reuse-hunter returns:
- Read
reuse-hunting-report.md - Parse duplication counts by priority
- If zero duplications → skip to Final Summary
- Update TodoWrite: mark detection complete
Phase 3: Quality Gate (Detection)
Run inline validation:
pnpm type-check
pnpm build
- If both pass → proceed to consolidation
- If fail → report to user, exit
Phase 4: Consolidation Loop
For each priority (high → medium → low):
Check if duplications exist for this priority
- If zero → skip to next priority
Update TodoWrite: mark current priority in_progress
Invoke reuse-fixer via Task tool:
subagent_type: "reuse-fixer" description: "Consolidate {priority} duplications" prompt: | Read reuse-hunting-report.md and consolidate all {priority} priority duplications. For each duplication: 1. Backup files before editing 2. Determine canonical location (usually shared-types or shared package) 3. Create/update canonical file with the type/schema/constant 4. Replace duplicates with imports/re-exports 5. Log change to .tmp/current/changes/reuse-changes.json Generate/update: reuse-consolidation-implemented.md Return: count of consolidated items, count of failed consolidations.Quality Gate (inline):
pnpm type-check pnpm build- If FAIL → report error, suggest rollback, exit
- If PASS → continue
Update TodoWrite: mark priority complete
Repeat for next priority
Phase 5: Verification
After all priorities consolidated:
Update TodoWrite: mark verification in_progress
Invoke reuse-hunter (verification mode):
subagent_type: "reuse-hunter" description: "Verification scan" prompt: | Re-scan codebase after consolidation. Compare with previous reuse-hunting-report.md. Report: - Duplications resolved (count) - Duplications remaining (count) - New duplications introduced (count)Decision:
- If duplications_remaining == 0 → Final Summary
- If iteration < 3 AND duplications_remaining > 0 → Go to Phase 2
- If iteration >= 3 → Final Summary with remaining items
Phase 6: Final Summary
Generate summary for user:
## Code Reuse Health Check Complete
**Iterations**: {count}/3
**Status**: {SUCCESS/PARTIAL}
### Results
- Found: {total} duplications
- Consolidated: {consolidated} ({percentage}%)
- Remaining: {remaining}
### By Priority
- High: {consolidated}/{total}
- Medium: {consolidated}/{total}
- Low: {consolidated}/{total}
### Validation
- Type Check: {status}
- Build: {status}
### Artifacts
- Detection: `reuse-hunting-report.md`
- Consolidation: `reuse-consolidation-implemented.md`
Error Handling
If quality gate fails:
Rollback available: .tmp/current/changes/reuse-changes.json
To rollback:
1. Read changes log
2. Restore files from .tmp/current/backups/
3. Re-run workflow
If worker fails:
- Report error to user
- Suggest manual intervention
- Exit workflow
Duplication Categories
Types/Interfaces (shared-types):
- Database types
- API types
- Zod schemas
- Common enums
Constants (shared-types):
- Configuration objects
- MIME types, file limits
- Feature flags
Utilities (shared package or re-export):
- Helper functions
- Validation utilities
- Formatters
Single Source of Truth Pattern:
- Canonical location:
packages/shared-types/src/ - Other packages:
export * from '@package/shared-types/{module}' - NEVER copy code between packages
Key Differences from Old Approach
| Old (Orchestrator Agent) | New (Inline Skill) |
|---|---|
| 9+ orchestrator calls | 0 orchestrator calls |
| ~1400 lines (cmd + agent) | ~150 lines |
| Context reload each call | Single session context |
| Plan files for each phase | Direct execution |
| ~10,000+ tokens overhead | ~500 tokens |
Worker Prompts
See references/worker-prompts.md for detailed prompts.