Fitness Check Command

Analyze architecture fitness and optionally generate architecture tests.

Arguments

• [scope]: Path to analyze (default: current directory)
• --generate: Generate test files (without this flag, only analysis is performed)
• --framework: Test framework to use when generating (default: netarchtest)
  • netarchtest: Generate NetArchTest tests
  • archunitnet: Generate ArchUnitNET tests

Execution

Step 1: Parse Arguments

Extract scope, generate flag, and framework preference.

Default scope is current directory. Default framework is netarchtest if --generate is specified.

Step 2: Load Fitness Functions Skill

Invoke the fitness-functions skill to access test patterns, templates, and rule definitions.

Step 3: Analyze Project Structure

Discover the codebase architecture:

1. Find solution/project files

   • Locate .sln and .csproj files
   • Identify project references and dependencies

2. Identify namespace patterns

   • Extract namespace hierarchies
   • Detect architectural layers (Domain, Application, Infrastructure, etc.)

3. Detect architecture style

   • Clean Architecture indicators
   • Hexagonal/Ports-Adapters patterns
   • Modular Monolith structure
   • Vertical Slice architecture
   • Traditional layered architecture

4. Catalog types and conventions

   • Controllers, Services, Handlers, Repositories
   • Entity types, Value Objects
   • Interface patterns

Step 4: Evaluate Fitness

Check for common architectural rules:

Dependency Rules

• Domain doesn't depend on Infrastructure
• Application doesn't depend on Presentation
• Modules don't cross-reference inappropriately

Layer Constraints

• Controllers only in Presentation/API layer
• Entities only in Domain layer
• DbContext only in Infrastructure

Naming Conventions

• Handlers end with "Handler"
• Repositories end with "Repository"
• Controllers end with "Controller"
• Interfaces start with "I"

Step 5: Generate Report

# Architecture Fitness Report

**Project:** [Name]
**Date:** [ISO Date]
**Architecture Style:** [Detected Style]

## Summary

| Category | Checks | Passed | Failed |
|----------|--------|--------|--------|
| Dependencies | 5 | 4 | 1 |
| Layer Constraints | 4 | 4 | 0 |
| Naming Conventions | 6 | 5 | 1 |
| **Total** | **15** | **13** | **2** |

## Passed Checks ✓

- [x] Domain has no dependency on Infrastructure
- [x] Application has no dependency on Presentation
- [x] All handlers end with "Handler"
- [x] All repositories end with "Repository"

## Failed Checks ✗

### 1. Module Cross-Reference
**Rule:** Orders module should not depend on Payments module directly
**Violation:** `Orders.Application.Services.OrderService` references `Payments.Domain.PaymentStatus`
**Recommendation:** Use integration events instead of direct reference

### 2. Naming Convention
**Rule:** All controllers should end with "Controller"
**Violation:** `Api/Endpoints/OrderEndpoints.cs`
**Recommendation:** Rename to `OrderEndpointsController` or mark as intentional (Minimal API)

## Recommendations

1. **High Priority:** Decouple Orders from Payments using domain events
2. **Medium Priority:** Standardize endpoint naming conventions
3. **Low Priority:** Consider adding architecture tests to CI/CD pipeline

Step 6: Generate Tests (if --generate)

If --generate flag is provided:

1. Spawn fitness-function-generator agent

2. Agent creates test project (if not exists):

   tests/ArchitectureTests/
     ├── ArchitectureTests.csproj
     ├── DependencyTests.cs
     ├── NamingConventionTests.cs
     └── StructureTests.cs
   

3. Generate test classes based on analysis:

   • Tests for each dependency rule
   • Tests for each naming convention
   • Tests for layer constraints

4. Output generated files:

   ## Generated Tests
   
   Created 3 test files in `tests/ArchitectureTests/`:
   
   - `DependencyTests.cs` (5 tests)
   - `NamingConventionTests.cs` (4 tests)
   - `StructureTests.cs` (3 tests)
   
   Run with: `dotnet test tests/ArchitectureTests`
   

Step 7: CI/CD Integration Suggestion

After analysis, suggest adding to CI/CD:

# Add to your GitHub Actions workflow:
- name: Run Architecture Tests
  run: dotnet test tests/ArchitectureTests --logger "trx;LogFileName=arch-tests.trx"