---
description: Trigger full repository health analysis
---

# Repository Health Analysis

Analyze the code health of a repository using multi-dimensional metrics.

## Instructions

When the user requests a repository health analysis, follow this systematic approach:

1. **List Files**: Use `list_repo_files` to discover all source files
2. **Analyze Complexity**: Use `file_metrics` on key files to assess complexity
3. **Check Git Churn**: Use `git_churn` to identify frequently changing files
4. **Map Test Coverage**: Use `map_tests` to find files missing tests
5. **Generate Report**: Combine all metrics into actionable recommendations

## Analysis Workflow

### Step 1: File Discovery
```
Use list_repo_files with appropriate globs for the language:
- TypeScript/JavaScript: ["**/*.{ts,tsx,js,jsx}"]
- Python: ["**/*.py"]
- Go: ["**/*.go"]
- Multi-language: Combine patterns

Exclude: ["node_modules/**", ".git/**", "dist/**", "build/**"]
```

### Step 2: Complexity Analysis
Focus on:
- Files > 300 lines
- Core business logic files (services, controllers, models)
- Recently changed files

For each file, report:
- Cyclomatic complexity
- Function count
- Health score
- Comment ratio

### Step 3: Git Churn Analysis
Identify hot spots:
- Files with >10 commits (high churn)
- Files changed by multiple authors
- Recent change patterns

### Step 4: Test Coverage Mapping
Find gaps:
- Files in critical directories missing tests
- High-complexity files without tests
- High-churn files without tests

### Step 5: Prioritized Recommendations
Combine metrics to find:
- **Technical Debt Hot Spots**: High complexity + High churn + No tests
- **Refactoring Candidates**: Complexity >10 + Health score <50
- **Testing Priorities**: Critical files missing tests

## Output Format

Present findings in this structure:

###  Repository Overview
- Total files: X
- Average health score: Y
- Test coverage: Z%

###  Critical Issues
1. High complexity + High churn + No tests
2. Health score <30 (critical)

### ️  Warnings
1. Health score 30-70 (needs attention)
2. Test coverage <60%

###  Good Practices
1. Well-tested files (high complexity + has tests)
2. Stable code (low churn + good health)

###  Recommendations
Prioritized list of actions:
1. Add tests for critical files
2. Refactor high-complexity hot spots
3. Monitor high-churn files

## Example Usage

User: "Analyze the health of /home/user/my-project"

Response:
```
I'll analyze the code health of your project using multiple dimensions...

[Use list_repo_files on /home/user/my-project]
Found 245 source files (TypeScript/JavaScript)

[Use file_metrics on top files]
Critical complexity issues:
- src/services/auth.ts: Complexity 45, Health 30 
- src/api/handler.ts: Complexity 28, Health 65 ️

[Use git_churn on /home/user/my-project since "6 months ago"]
High churn files:
- src/api/handler.ts: 32 commits, 4 authors
- src/services/auth.ts: 18 commits, 2 authors

[Use map_tests on /home/user/my-project]
Test coverage: 62% (97 of 156 files tested)
Missing tests: 59 files

Critical files without tests:
- src/services/auth.ts (high complexity + high churn) 
- src/api/legacy.ts (high complexity)

## Recommendations:
1.  URGENT: Add tests for src/services/auth.ts (high complexity, high churn, no tests)
2. ️  Refactor src/api/handler.ts (complexity 28, reduce to <10)
3.  Improve test coverage to 80%+ (currently 62%)
```

## Notes

- Always use absolute paths
- Adjust time period for git_churn based on project age
- For large repos (>500 files), focus on changed files in last 3 months
- Combine metrics for maximum insight