@girardelli/architect 2.2.0 → 4.0.0

package/tests/agent-generator.test.ts

@@ -0,0 +1,411 @@
+import { AgentGenerator } from '../src/agent-generator/index.js';
+import { AnalysisReport, RefactoringPlan } from '../src/types.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({
+        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({
+        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

@@ -0,0 +1,174 @@
+/**
+ * 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/analyzers/git-history.js';
+import { TemporalScorer } from '../src/analyzers/temporal-scorer.js';
+import { ForecastEngine } from '../src/analyzers/forecast.js';
+import { saveToCache, loadFromCache } from '../src/analyzers/git-cache.js';
+import type { GitHistoryReport } from '../src/analyzers/git-history.js';
+import type { TemporalReport } from '../src/analyzers/temporal-scorer.js';
+import type { WeatherForecast } from '../src/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(() => {
+    setupRealRepo();
+
+    // Stage 1: Git History
+    const gitAnalyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
+    gitReport = 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/architect-adapter-enrichment.test.ts

@@ -0,0 +1,9 @@
+/**
+ * This test has been moved to the nexus package where it can resolve @nexus/* imports.
+ * See: nexus/packages/bridge/src/__tests__/architect-adapter-enrichment.test.ts
+ */
+describe('ArchitectAdapter enrichment', () => {
+  it('tests moved to nexus/packages/bridge — run from nexus root', () => {
+    expect(true).toBe(true);
+  });
+});