@girardelli/architect 6.0.0 → 8.2.0

package/tests/agent-generator.test.ts

@@ -1,428 +0,0 @@
-import { AgentGenerator } from '../src/core/agent-generator/index.js';
-import { AnalysisReport } from '../src/core/types/core.js';
-import { RefactoringPlan } from '../src/core/types/rules.js';
-import { existsSync, mkdirSync, writeFileSync, rmSync } from 'fs';
-import { join } from 'path';
-
-// ── Test Data Factories ──
-
-function makeReport(overrides: Partial<AnalysisReport> = {}): AnalysisReport {
-  return {
-    timestamp: new Date().toISOString(),
-    projectInfo: {
-      path: '/test',
-      name: 'test-project',
-      frameworks: ['NestJS'],
-      totalFiles: 50,
-      totalLines: 5000,
-      primaryLanguages: ['TypeScript'],
-    },
-    score: {
-      overall: 72,
-      components: [],
-      breakdown: { modularity: 80, coupling: 65, cohesion: 70, layering: 75 },
-    },
-    antiPatterns: [
-      {
-        name: 'God Class',
-        severity: 'CRITICAL',
-        location: 'src/AppService.ts',
-        description: 'Class with 800 lines',
-        suggestion: 'Split into smaller services',
-        affectedFiles: ['src/AppService.ts'],
-      },
-    ],
-    layers: [
-      { name: 'API', files: ['src/controller.ts'], description: 'API layer' },
-      { name: 'Service', files: ['src/service.ts'], description: 'Service layer' },
-    ],
-    dependencyGraph: {
-      nodes: ['src/app.module.ts', 'src/app.controller.ts', 'src/app.service.ts', 'src/entity/user.entity.ts'],
-      edges: [
-        { from: 'src/app.controller.ts', to: 'src/app.service.ts', type: 'import', weight: 1 },
-        { from: 'src/app.service.ts', to: 'src/entity/user.entity.ts', type: 'import', weight: 1 },
-      ],
-    },
-    suggestions: [],
-    diagram: { mermaid: '', type: 'layer' },
-    ...overrides,
-  };
-}
-
-function makePlan(overrides: Partial<RefactoringPlan> = {}): RefactoringPlan {
-  return {
-    timestamp: new Date().toISOString(),
-    projectPath: '/test',
-    currentScore: {
-      overall: 72,
-      components: [],
-      breakdown: { modularity: 80, coupling: 65, cohesion: 70, layering: 75 },
-    },
-    estimatedScoreAfter: { overall: 82, breakdown: { modularity: 85, coupling: 75, cohesion: 80, layering: 80 } },
-    steps: [
-      {
-        id: 1,
-        tier: 1,
-        rule: 'hub-splitter',
-        priority: 'HIGH',
-        title: 'Split AppService',
-        description: 'Split monolith service',
-        rationale: 'Reduce coupling',
-        operations: [],
-        scoreImpact: [{ metric: 'modularity', before: 80, after: 85 }],
-      },
-    ],
-    totalOperations: 1,
-    tier1Steps: 1,
-    tier2Steps: 0,
-    ...overrides,
-  };
-}
-
-// ── Test Suite ──
-
-describe('AgentGenerator', () => {
-  const generator = new AgentGenerator();
-  const testOutputDir = join(process.cwd(), '__test_agent_output__');
-
-  afterEach(() => {
-    // Clean up generated test directories
-    if (existsSync(testOutputDir)) {
-      rmSync(testOutputDir, { recursive: true, force: true });
-    }
-  });
-
-  describe('suggest()', () => {
-    it('should return a valid AgentSuggestion', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      expect(result).toBeDefined();
-      expect(result.stack).toBeDefined();
-      expect(result.suggestedAgents).toBeDefined();
-      expect(result.suggestedRules).toBeDefined();
-      expect(result.suggestedGuards).toBeDefined();
-      expect(result.suggestedWorkflows).toBeDefined();
-      expect(result.suggestedSkills).toBeDefined();
-      expect(result.command).toBeDefined();
-    });
-
-    it('should detect TypeScript + NestJS stack', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      expect(result.stack.primary).toBe('TypeScript');
-      expect(result.stack.frameworks).toContain('NestJS');
-      expect(result.stack.hasBackend).toBe(true);
-      expect(result.stack.hasDatabase).toBe(true);
-    });
-
-    it('should suggest backend agent for backend stack', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      const backendAgent = result.suggestedAgents.find(a => a.name.includes('BACKEND'));
-      expect(backendAgent).toBeDefined();
-      expect(backendAgent!.status).toBe('CREATE');
-    });
-
-    it('should suggest database agent when database detected', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      const dbAgent = result.suggestedAgents.find(a => a.name.includes('DATABASE'));
-      expect(dbAgent).toBeDefined();
-    });
-
-    it('should always suggest orchestrator, security, QA, and tech debt agents', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-      const names = result.suggestedAgents.map(a => a.name);
-
-      expect(names).toContain('AGENT-ORCHESTRATOR');
-      expect(names.some(n => n.includes('SECURITY'))).toBe(true);
-      expect(names.some(n => n.includes('QA'))).toBe(true);
-      expect(names.some(n => n.includes('TECH-DEBT'))).toBe(true);
-    });
-
-    it('should suggest 3+ rules including architecture and security', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-      const ruleNames = result.suggestedRules.map(r => r.name);
-
-      expect(ruleNames).toContain('00-general');
-      expect(ruleNames).toContain('01-architecture');
-      expect(ruleNames).toContain('02-security');
-    });
-
-    it('should suggest stack-specific rule for NestJS', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-      const ruleNames = result.suggestedRules.map(r => r.name);
-
-      expect(ruleNames.some(n => n.includes('03-nestjs'))).toBe(true);
-    });
-
-    it('should suggest 3 guards', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      expect(result.suggestedGuards.length).toBe(3);
-      const names = result.suggestedGuards.map(g => g.name);
-      expect(names).toContain('PREFLIGHT');
-      expect(names).toContain('QUALITY-GATES');
-      expect(names).toContain('CODE-REVIEW-CHECKLIST');
-    });
-
-    it('should suggest 3 workflows', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      expect(result.suggestedWorkflows.length).toBe(3);
-      const names = result.suggestedWorkflows.map(w => w.name);
-      expect(names).toContain('new-feature');
-      expect(names).toContain('fix-bug');
-      expect(names).toContain('review');
-    });
-
-    it('should suggest skills including stack-specific ones', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/test');
-
-      expect(result.suggestedSkills.length).toBeGreaterThan(5);
-      const skillNames = result.suggestedSkills.map(s => s.name);
-      expect(skillNames).toContain('test-driven-development');
-      expect(skillNames).toContain('security-best-practices');
-      // TypeScript-specific
-      expect(skillNames).toContain('api-design-principles');
-    });
-
-    it('should mark hasExistingAgents false for non-existing directory', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.suggest(report, plan, '/non-existing-path');
-
-      expect(result.hasExistingAgents).toBe(false);
-    });
-  });
-
-  describe('generate() — full generation', () => {
-    it('should create .agent/ directory structure', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated.length).toBeGreaterThan(15);
-      expect(result.audit).toHaveLength(0); // No audit for fresh generation
-
-      // Verify directory structure
-      expect(existsSync(join(testOutputDir, 'agents'))).toBe(true);
-      expect(existsSync(join(testOutputDir, 'rules'))).toBe(true);
-      expect(existsSync(join(testOutputDir, 'guards'))).toBe(true);
-      expect(existsSync(join(testOutputDir, 'workflows'))).toBe(true);
-      expect(existsSync(join(testOutputDir, 'templates'))).toBe(true);
-      expect(existsSync(join(testOutputDir, 'skills'))).toBe(true);
-    });
-
-    it('should generate core files', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated).toContain('INDEX.md');
-      expect(result.generated).toContain('agents/AGENT-ORCHESTRATOR.md');
-      expect(result.generated).toContain('guards/PREFLIGHT.md');
-      expect(result.generated).toContain('guards/QUALITY-GATES.md');
-      expect(result.generated).toContain('rules/00-general.md');
-      expect(result.generated).toContain('rules/01-architecture.md');
-      expect(result.generated).toContain('rules/02-security.md');
-      expect(result.generated).toContain('workflows/new-feature.md');
-      expect(result.generated).toContain('workflows/fix-bug.md');
-      expect(result.generated).toContain('workflows/review.md');
-    });
-
-    it('should generate stack-specific agents for NestJS', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated.some(f => f.includes('TYPESCRIPT-BACKEND-DEVELOPER'))).toBe(true);
-      expect(result.generated.some(f => f.includes('DATABASE-ENGINEER'))).toBe(true);
-    });
-
-    it('should generate stack-specific rules for NestJS', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated.some(f => f.includes('03-nestjs'))).toBe(true);
-    });
-
-    it('should generate domain templates', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated).toContain('templates/C4.md');
-      expect(result.generated).toContain('templates/BDD.md');
-      expect(result.generated).toContain('templates/TDD.md');
-      expect(result.generated).toContain('templates/ADR.md');
-      expect(result.generated).toContain('templates/THREAT-MODEL.md');
-    });
-
-    it('should generate frontend agent when frontend detected', () => {
-      const report = makeReport({
-        projectInfo: {
-          path: '/test',
-          name: 'test-project',
-          frameworks: ['Angular'],
-          totalFiles: 50,
-          totalLines: 5000,
-          primaryLanguages: ['TypeScript'],
-        },
-        dependencyGraph: {
-          nodes: ['src/app.component.ts', 'src/app.module.ts', 'src/angular.json'],
-          edges: [],
-        },
-      });
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated.some(f => f.includes('FRONTEND-DEVELOPER'))).toBe(true);
-    });
-
-    it('should generate mobile agent when Dart detected', () => {
-      const report = makeReport({
-        dependencyGraph: {
-          nodes: ['lib/main.dart', 'lib/app.dart'],
-          edges: [],
-        },
-      });
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      expect(result.generated.some(f => f.includes('FLUTTER-UI-DEVELOPER'))).toBe(true);
-    });
-
-    it('should generate 18+ files total for a full NestJS project', () => {
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      // Core: INDEX + ORCHESTRATOR + PREFLIGHT + QUALITY-GATES + CODE-REVIEW +
-      //        00-general + 01-architecture + 02-security + 03-nestjs +
-      //        new-feature + fix-bug + review = 12
-      // Agents: BACKEND + DATABASE + SECURITY + QA + TECH-DEBT = 5
-      // Templates: C4 + BDD + TDD + ADR + THREAT-MODEL = 5
-      // Total: 22+
-      expect(result.generated.length).toBeGreaterThanOrEqual(18);
-    });
-  });
-
-  describe('generate() — audit existing', () => {
-    it('should audit and generate missing files', () => {
-      // Create a partial .agent/ directory
-      mkdirSync(join(testOutputDir, 'agents'), { recursive: true });
-      mkdirSync(join(testOutputDir, 'rules'), { recursive: true });
-      writeFileSync(join(testOutputDir, 'INDEX.md'), '# Existing Index');
-      writeFileSync(join(testOutputDir, 'agents/AGENT-ORCHESTRATOR.md'), '# Existing Orchestrator');
-
-      const report = makeReport();
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      // Should have audit findings
-      expect(result.audit.length).toBeGreaterThan(0);
-
-      // Should have found some files OK
-      const okFindings = result.audit.filter(f => f.type === 'OK');
-      expect(okFindings.length).toBeGreaterThanOrEqual(2); // INDEX.md + ORCHESTRATOR
-
-      // Should have found some missing
-      const missingFindings = result.audit.filter(f => f.type === 'MISSING');
-      expect(missingFindings.length).toBeGreaterThan(0);
-
-      // Should have generated the missing files
-      expect(result.generated.length).toBeGreaterThan(0);
-    });
-
-    it('should suggest improvement when score is low', () => {
-      mkdirSync(join(testOutputDir, 'agents'), { recursive: true });
-      mkdirSync(join(testOutputDir, 'guards'), { recursive: true });
-      writeFileSync(join(testOutputDir, 'INDEX.md'), '# Index');
-      writeFileSync(join(testOutputDir, 'guards/QUALITY-GATES.md'), '# Gates');
-
-      const report = makeReport({
-        score: {
-          overall: 50,
-          components: [],
-          breakdown: { modularity: 50, coupling: 45, cohesion: 55, layering: 50 },
-        },
-      });
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      const improvements = result.audit.filter(f => f.type === 'IMPROVEMENT');
-      expect(improvements.length).toBeGreaterThan(0);
-    });
-  });
-
-  describe('Python stack generation', () => {
-    it('should generate Python-specific agents and rules', () => {
-      const report = makeReport({
-        projectInfo: {
-          path: '/test',
-          name: 'test-project',
-          frameworks: ['Django'],
-          totalFiles: 50,
-          totalLines: 5000,
-          primaryLanguages: ['Python'],
-        },
-        dependencyGraph: {
-          nodes: ['manage.py', 'app/views.py', 'app/models.py', 'app/serializers.py'],
-          edges: [
-            { from: 'app/views.py', to: 'app/models.py', type: 'import', weight: 1 },
-          ],
-        },
-      });
-      const plan = makePlan();
-
-      const result = generator.generate(report, plan, '/test', testOutputDir);
-
-      // Should detect Python + Django
-      expect(result.generated.some(f => f.includes('PYTHON-BACKEND-DEVELOPER'))).toBe(true);
-      expect(result.generated.some(f => f.includes('03-django'))).toBe(true);
-    });
-  });
-});

package/tests/analyzers-integration.test.ts

@@ -1,174 +0,0 @@
-/**
- * Integration Tests — Full pipeline: GitHistory → TemporalScorer → ForecastEngine
- *
- * Validates end-to-end flow with a real git repo and type contracts
- * between the three analyzer stages.
- */
-
-import { GitHistoryAnalyzer } from '../src/infrastructure/git-history.js';
-import { TemporalScorer } from '../src/core/analyzers/temporal-scorer.js';
-import { ForecastEngine } from '../src/core/analyzers/forecast.js';
-import { saveToCache, loadFromCache } from '../src/infrastructure/git-cache.js';
-import type { GitHistoryReport } from '../src/infrastructure/git-history.js';
-import type { TemporalReport } from '../src/core/analyzers/temporal-scorer.js';
-import type { WeatherForecast } from '../src/core/analyzers/forecast.js';
-import { execSync } from 'child_process';
-import * as fs from 'fs';
-import * as path from 'path';
-
-// ═══════════════════════════════════════════════════════════════
-// SETUP
-// ═══════════════════════════════════════════════════════════════
-
-const TEST_DIR = path.join('/tmp', 'architect-integration-test');
-
-function setupRealRepo(): void {
-  fs.rmSync(TEST_DIR, { recursive: true, force: true });
-  fs.mkdirSync(TEST_DIR, { recursive: true });
-
-  execSync('git init', { cwd: TEST_DIR, stdio: 'pipe' });
-  execSync('git config user.email "dev@test.com"', { cwd: TEST_DIR, stdio: 'pipe' });
-  execSync('git config user.name "Dev"', { cwd: TEST_DIR, stdio: 'pipe' });
-
-  // Build a realistic repo with multiple modules
-  const files = [
-    { path: 'src/api/routes.ts', content: 'export const routes = [];' },
-    { path: 'src/api/middleware.ts', content: 'export function auth() {}' },
-    { path: 'src/service/user.ts', content: 'export class UserService {}' },
-    { path: 'src/data/repo.ts', content: 'export class UserRepo {}' },
-    { path: 'lib/utils.ts', content: 'export function log() {}' },
-  ];
-
-  for (const f of files) {
-    const dir = path.dirname(path.join(TEST_DIR, f.path));
-    fs.mkdirSync(dir, { recursive: true });
-    fs.writeFileSync(path.join(TEST_DIR, f.path), f.content);
-  }
-  execSync('git add . && git commit -m "initial"', { cwd: TEST_DIR, stdio: 'pipe' });
-
-  // Simulate some activity
-  for (let i = 0; i < 5; i++) {
-    fs.writeFileSync(
-      path.join(TEST_DIR, 'src/api/routes.ts'),
-      `export const routes = [${i}];\n`.repeat(i + 1),
-    );
-    fs.writeFileSync(
-      path.join(TEST_DIR, 'src/service/user.ts'),
-      `export class UserService { v${i}() {} }`,
-    );
-    execSync(`git add . && git commit -m "iteration ${i}"`, { cwd: TEST_DIR, stdio: 'pipe' });
-  }
-}
-
-// ═══════════════════════════════════════════════════════════════
-// TESTS
-// ═══════════════════════════════════════════════════════════════
-
-describe('Analyzer Pipeline Integration', () => {
-  let gitReport: GitHistoryReport;
-  let temporalReport: TemporalReport;
-  let forecast: WeatherForecast;
-
-  beforeAll(async () => {
-    setupRealRepo();
-
-    // Stage 1: Git History
-    const gitAnalyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
-    gitReport = await gitAnalyzer.analyze(TEST_DIR);
-
-    // Stage 2: Temporal Scoring
-    const scorer = new TemporalScorer({ projectionWeeks: 12 });
-    const staticScores = new Map<string, number>();
-    for (const mod of gitReport.modules) {
-      staticScores.set(mod.modulePath, 70); // assume 70 baseline
-    }
-    temporalReport = scorer.score(gitReport, staticScores);
-
-    // Stage 3: Forecast
-    const engine = new ForecastEngine();
-    forecast = engine.forecast(gitReport, temporalReport);
-  });
-
-  afterAll(() => {
-    fs.rmSync(TEST_DIR, { recursive: true, force: true });
-  });
-
-  describe('Stage 1 → Stage 2 contract', () => {
-    it('git report modules should have matching temporal scores', () => {
-      for (const mod of gitReport.modules) {
-        const ts = temporalReport.modules.find(m => m.module === mod.modulePath);
-        expect(ts).toBeDefined();
-        expect(ts!.staticScore).toBeDefined();
-        expect(ts!.temporalScore).toBeDefined();
-      }
-    });
-  });
-
-  describe('Stage 2 → Stage 3 contract', () => {
-    it('temporal modules should have matching forecast modules', () => {
-      for (const ts of temporalReport.modules) {
-        const fm = forecast.modules.find(m => m.module === ts.module);
-        expect(fm).toBeDefined();
-        expect(fm!.currentHealth).toMatch(/^(healthy|at-risk|degrading|critical)$/);
-        expect(fm!.forecast6Months).toMatch(/^(stable|declining|breakdown)$/);
-      }
-    });
-  });
-
-  describe('end-to-end output', () => {
-    it('forecast should have valid outlook', () => {
-      expect(['sunny', 'cloudy', 'stormy']).toContain(forecast.overallOutlook);
-    });
-
-    it('forecast should have a headline', () => {
-      expect(forecast.headline.length).toBeGreaterThan(0);
-    });
-
-    it('all pre-anti-patterns should have valid types', () => {
-      const validTypes = [
-        'emerging-god-class',
-        'emerging-shotgun-surgery',
-        'emerging-feature-envy',
-        'bus-factor-risk',
-        'complexity-spiral',
-        'coupling-magnet',
-      ];
-      for (const p of forecast.preAntiPatterns) {
-        expect(validTypes).toContain(p.type);
-        expect(p.confidence).toBeGreaterThan(0);
-        expect(p.confidence).toBeLessThanOrEqual(1);
-      }
-    });
-
-    it('modules should have bottleneck probability between 0 and 1', () => {
-      for (const m of forecast.modules) {
-        expect(m.bottleneckProbability).toBeGreaterThanOrEqual(0);
-        expect(m.bottleneckProbability).toBeLessThanOrEqual(1);
-      }
-    });
-  });
-
-  describe('git cache', () => {
-    it('should save and load cache correctly', () => {
-      saveToCache(gitReport, TEST_DIR);
-
-      const loaded = loadFromCache(TEST_DIR, '.architect-cache', 3600000);
-      expect(loaded).not.toBeNull();
-      expect(loaded!.projectPath).toBe(gitReport.projectPath);
-      expect(loaded!.totalCommits).toBe(gitReport.totalCommits);
-      expect(loaded!.totalAuthors).toBe(gitReport.totalAuthors);
-    });
-
-    it('should return null for expired cache', () => {
-      saveToCache(gitReport, TEST_DIR);
-
-      const loaded = loadFromCache(TEST_DIR, '.architect-cache', 0); // 0ms = expired
-      expect(loaded).toBeNull();
-    });
-
-    it('should return null when cache does not exist', () => {
-      const loaded = loadFromCache('/tmp/nonexistent-path');
-      expect(loaded).toBeNull();
-    });
-  });
-});

package/tests/anti-patterns.test.ts

@@ -1,95 +0,0 @@
-import { AntiPatternDetector } from '../src/core/anti-patterns.js';
-import { AntiPattern, ArchitectConfig } from '../src/core/types/core.js';
-import { FileNode } from '../src/core/types/infrastructure.js';
-
-describe('AntiPatternDetector', () => {
-  const mockConfig: ArchitectConfig = {
-    antiPatterns: {
-      godClass: {
-        linesThreshold: 500,
-        methodsThreshold: 10,
-      },
-      shotgunSurgery: {
-        changePropagationThreshold: 5,
-      },
-    },
-  };
-
-  const mockFileTree: FileNode = {
-    path: '/project',
-    name: 'project',
-    type: 'directory',
-    children: [
-      {
-        path: '/project/src/services/UserManager.ts',
-        name: 'UserManager.ts',
-        type: 'file',
-        extension: '.ts',
-        lines: 850,
-      },
-      {
-        path: '/project/src/utils/helper.ts',
-        name: 'helper.ts',
-        type: 'file',
-        extension: '.ts',
-        lines: 200,
-      },
-    ],
-  };
-
-  const mockDependencies = new Map<string, Set<string>>([
-    ['/project/src/services/UserManager.ts', new Set(['/project/src/utils/helper.ts'])],
-    ['/project/src/utils/helper.ts', new Set(['/project/src/services/UserManager.ts'])],
-  ]);
-
-  describe('detect', () => {
-    it('should detect anti-patterns in code', () => {
-      const detector = new AntiPatternDetector(mockConfig);
-      const patterns = detector.detect(mockFileTree, mockDependencies);
-
-      expect(Array.isArray(patterns)).toBe(true);
-    });
-
-    it('should identify God Classes', () => {
-      const detector = new AntiPatternDetector(mockConfig);
-      const patterns = detector.detect(mockFileTree, mockDependencies);
-
-      const godClasses = patterns.filter((p) => p.name === 'God Class');
-      expect(godClasses.length).toBeGreaterThanOrEqual(0);
-    });
-
-    it('should sort patterns by severity', () => {
-      const detector = new AntiPatternDetector(mockConfig);
-      const patterns = detector.detect(mockFileTree, mockDependencies);
-
-      if (patterns.length > 1) {
-        const severityOrder: Record<string, number> = {
-          CRITICAL: 0,
-          HIGH: 1,
-          MEDIUM: 2,
-          LOW: 3,
-        };
-
-        for (let i = 0; i < patterns.length - 1; i++) {
-          const current = severityOrder[patterns[i].severity];
-          const next = severityOrder[patterns[i + 1].severity];
-          expect(current).toBeLessThanOrEqual(next);
-        }
-      }
-    });
-  });
-
-  describe('circular dependency detection', () => {
-    it('should detect circular dependencies', () => {
-      const circularDeps = new Map<string, Set<string>>([
-        ['src/auth.ts', new Set(['src/cache.ts'])],
-        ['src/cache.ts', new Set(['src/auth.ts'])],
-      ]);
-
-      const detector = new AntiPatternDetector(mockConfig);
-      const patterns = detector.detect(mockFileTree, circularDeps);
-
-      expect(patterns.length).toBeGreaterThanOrEqual(0);
-    });
-  });
-});