@girardelli/architect 2.2.0 → 5.0.0

package/tests/git-history.test.ts

@@ -0,0 +1,254 @@
+/**
+ * Tests for GitHistoryAnalyzer
+ *
+ * Validates git log parsing, file history building, velocity vectors,
+ * change coupling detection, and timeline construction.
+ */
+
+import { GitHistoryAnalyzer } from '../src/analyzers/git-history.js';
+import type {
+  GitHistoryReport,
+  FileHistory,
+  ModuleHistory,
+  VelocityVector,
+} from '../src/analyzers/git-history.js';
+import { execSync } from 'child_process';
+import * as fs from 'fs';
+import * as path from 'path';
+
+// ═══════════════════════════════════════════════════════════════
+// TEST HELPERS
+// ═══════════════════════════════════════════════════════════════
+
+const TEST_DIR = path.join('/tmp', 'architect-git-history-test');
+
+function setupGitRepo(): 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 "test@test.com"', { cwd: TEST_DIR, stdio: 'pipe' });
+  execSync('git config user.name "TestUser"', { cwd: TEST_DIR, stdio: 'pipe' });
+}
+
+function commitFile(
+  filePath: string,
+  content: string,
+  message: string,
+  author = 'TestUser <test@test.com>',
+): void {
+  const fullPath = path.join(TEST_DIR, filePath);
+  const dir = path.dirname(fullPath);
+  fs.mkdirSync(dir, { recursive: true });
+  fs.writeFileSync(fullPath, content);
+  execSync(`git add "${filePath}"`, { cwd: TEST_DIR, stdio: 'pipe' });
+  execSync(`git commit --author="${author}" -m "${message}"`, {
+    cwd: TEST_DIR,
+    stdio: 'pipe',
+  });
+}
+
+function cleanupRepo(): void {
+  fs.rmSync(TEST_DIR, { recursive: true, force: true });
+}
+
+// ═══════════════════════════════════════════════════════════════
+// UNIT TESTS — parseLogOutput (via analyze)
+// ═══════════════════════════════════════════════════════════════
+
+describe('GitHistoryAnalyzer', () => {
+  beforeAll(() => {
+    setupGitRepo();
+
+    // Create initial files across two modules
+    commitFile('src/core.ts', 'export class Core {}', 'initial core', 'Alice <alice@test.com>');
+    commitFile('src/utils.ts', 'export function util() {}', 'add utils', 'Alice <alice@test.com>');
+    commitFile('lib/helper.ts', 'export function help() {}', 'add helper', 'Bob <bob@test.com>');
+
+    // Add more changes to create churn
+    commitFile('src/core.ts', 'export class Core { run() {} }', 'enhance core', 'Bob <bob@test.com>');
+    commitFile('src/core.ts', 'export class Core { run() { return 1; } }', 'fix core', 'Alice <alice@test.com>');
+
+    // Concurrent changes for coupling detection
+    const coupledContent1 = 'export class Core { run() { return 2; } }';
+    const coupledContent2 = 'export function util() { return true; }';
+    const p1 = path.join(TEST_DIR, 'src/core.ts');
+    const p2 = path.join(TEST_DIR, 'src/utils.ts');
+    fs.writeFileSync(p1, coupledContent1);
+    fs.writeFileSync(p2, coupledContent2);
+    execSync('git add .', { cwd: TEST_DIR, stdio: 'pipe' });
+    execSync('git commit --author="Alice <alice@test.com>" -m "coupled change 1"', {
+      cwd: TEST_DIR,
+      stdio: 'pipe',
+    });
+
+    // Another coupled change
+    fs.writeFileSync(p1, coupledContent1 + '\n// v2');
+    fs.writeFileSync(p2, coupledContent2 + '\n// v2');
+    execSync('git add .', { cwd: TEST_DIR, stdio: 'pipe' });
+    execSync('git commit --author="Bob <bob@test.com>" -m "coupled change 2"', {
+      cwd: TEST_DIR,
+      stdio: 'pipe',
+    });
+
+    // Third coupled change to meet the default minCochanges=3
+    fs.writeFileSync(p1, coupledContent1 + '\n// v3');
+    fs.writeFileSync(p2, coupledContent2 + '\n// v3');
+    execSync('git add .', { cwd: TEST_DIR, stdio: 'pipe' });
+    execSync('git commit --author="Alice <alice@test.com>" -m "coupled change 3"', {
+      cwd: TEST_DIR,
+      stdio: 'pipe',
+    });
+  });
+
+  afterAll(() => {
+    cleanupRepo();
+  });
+
+  describe('analyze()', () => {
+    let report: GitHistoryReport;
+
+    beforeAll(() => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
+      report = analyzer.analyze(TEST_DIR);
+    });
+
+    it('should return correct project path', () => {
+      expect(report.projectPath).toBe(TEST_DIR);
+    });
+
+    it('should have analyzedAt timestamp', () => {
+      expect(report.analyzedAt).toBeDefined();
+      expect(new Date(report.analyzedAt).getTime()).not.toBeNaN();
+    });
+
+    it('should count total commits', () => {
+      expect(report.totalCommits).toBeGreaterThanOrEqual(7);
+    });
+
+    it('should count unique authors', () => {
+      expect(report.totalAuthors).toBe(2); // Alice + Bob
+    });
+
+    it('should detect modules by first directory level', () => {
+      const moduleNames = report.modules.map(m => m.modulePath);
+      expect(moduleNames).toContain('src');
+      expect(moduleNames).toContain('lib');
+    });
+
+    it('should build file histories with correct metrics', () => {
+      const srcModule = report.modules.find(m => m.modulePath === 'src');
+      expect(srcModule).toBeDefined();
+
+      const coreFile = srcModule!.files.find(f => f.path === 'src/core.ts');
+      expect(coreFile).toBeDefined();
+      expect(coreFile!.commits).toBeGreaterThanOrEqual(5);
+      expect(coreFile!.busFactor).toBe(2); // Alice + Bob
+      expect(coreFile!.totalAdditions).toBeGreaterThan(0);
+    });
+
+    it('should calculate churn rate correctly', () => {
+      const srcModule = report.modules.find(m => m.modulePath === 'src');
+      const coreFile = srcModule!.files.find(f => f.path === 'src/core.ts');
+      expect(coreFile!.churnRate).toBeGreaterThan(0);
+      expect(coreFile!.churnRate).toBe(
+        (coreFile!.totalAdditions + coreFile!.totalDeletions) / coreFile!.commits
+      );
+    });
+
+    it('should build weekly timeline', () => {
+      expect(report.commitTimeline.length).toBeGreaterThan(0);
+      const total = report.commitTimeline.reduce((s, w) => s + w.commits, 0);
+      expect(total).toBe(report.totalCommits);
+    });
+  });
+
+  describe('change coupling', () => {
+    it('should detect coupled files', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52, couplingMinCochanges: 3 });
+      const report = analyzer.analyze(TEST_DIR);
+
+      const coupling = report.changeCouplings.find(
+        c =>
+          (c.fileA === 'src/core.ts' && c.fileB === 'src/utils.ts') ||
+          (c.fileA === 'src/utils.ts' && c.fileB === 'src/core.ts')
+      );
+
+      expect(coupling).toBeDefined();
+      expect(coupling!.cochangeCount).toBeGreaterThanOrEqual(3);
+      expect(coupling!.confidence).toBeGreaterThan(0);
+      expect(coupling!.confidence).toBeLessThanOrEqual(1);
+    });
+  });
+
+  describe('velocity vectors', () => {
+    it('should calculate velocity for each module', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
+      const report = analyzer.analyze(TEST_DIR);
+
+      const srcModule = report.modules.find(m => m.modulePath === 'src');
+      expect(srcModule).toBeDefined();
+      expect(srcModule!.velocityVector).toBeDefined();
+      expect(srcModule!.velocityVector.direction).toMatch(/^(accelerating|stable|decelerating)$/);
+      expect(typeof srcModule!.velocityVector.commitAcceleration).toBe('number');
+      expect(typeof srcModule!.velocityVector.churnTrend).toBe('number');
+    });
+  });
+
+  describe('module aggregation', () => {
+    it('should aggregate commits across module files', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
+      const report = analyzer.analyze(TEST_DIR);
+
+      const srcModule = report.modules.find(m => m.modulePath === 'src');
+      expect(srcModule!.aggregateCommits).toBe(
+        srcModule!.files.reduce((s, f) => s + f.commits, 0)
+      );
+    });
+
+    it('should calculate bus factor per module', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
+      const report = analyzer.analyze(TEST_DIR);
+
+      const srcModule = report.modules.find(m => m.modulePath === 'src');
+      expect(srcModule!.busFactor).toBe(2); // Alice + Bob both committed to src/
+    });
+
+    it('should sort modules by aggregate churn descending', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52 });
+      const report = analyzer.analyze(TEST_DIR);
+
+      for (let i = 1; i < report.modules.length; i++) {
+        expect(report.modules[i - 1].aggregateChurn).toBeGreaterThanOrEqual(
+          report.modules[i].aggregateChurn
+        );
+      }
+    });
+  });
+
+  describe('error handling', () => {
+    it('should throw for non-git directory', () => {
+      const tmpDir = path.join('/tmp', 'not-a-git-repo');
+      fs.mkdirSync(tmpDir, { recursive: true });
+
+      const analyzer = new GitHistoryAnalyzer();
+      expect(() => analyzer.analyze(tmpDir)).toThrow('Not a git repository');
+
+      fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+  });
+
+  describe('configuration', () => {
+    it('should respect custom period weeks', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 1 });
+      const report = analyzer.analyze(TEST_DIR);
+      expect(report.periodWeeks).toBe(1);
+    });
+
+    it('should respect custom coupling threshold', () => {
+      const analyzer = new GitHistoryAnalyzer({ periodWeeks: 52, couplingMinCochanges: 100 });
+      const report = analyzer.analyze(TEST_DIR);
+      expect(report.changeCouplings.length).toBe(0);
+    });
+  });
+});

package/tests/monorepo-scan.test.ts

@@ -0,0 +1,170 @@
+/**
+ * E2E Tests — Monorepo Scanning
+ * 
+ * Ensures that the Architect scanner correctly handles monorepo projects
+ * with nested node_modules, workspace detection, and framework inference.
+ * 
+ * This test suite was created to prevent regression of the critical bug where
+ * node_modules in sub-packages leaked through the glob ignore filter,
+ * contaminating all analysis results (29,181 files instead of 245).
+ */
+
+import path from 'path';
+import { ProjectScanner } from '../src/scanner.js';
+import { ArchitectureAnalyzer } from '../src/analyzer.js';
+import { AntiPatternDetector } from '../src/anti-patterns.js';
+import { ConfigLoader, normalizeIgnorePatterns } from '../src/config.js';
+
+// Use path.resolve for Jest compatibility (import.meta.url not supported by ts-jest)
+const FIXTURE_PATH = path.resolve(process.cwd(), 'tests/fixtures/monorepo');
+
+describe('Monorepo Scanner — node_modules exclusion', () => {
+  let config: ReturnType<typeof ConfigLoader.loadConfig>;
+
+  beforeAll(() => {
+    config = ConfigLoader.loadConfig(FIXTURE_PATH);
+  });
+
+  test('default config uses glob patterns for ignore', () => {
+    expect(config.ignore).toBeDefined();
+    // Must use glob-style patterns that cover nested directories
+    const hasGlobNodeModules = config.ignore!.some(p => p.includes('**/node_modules'));
+    expect(hasGlobNodeModules).toBe(true);
+  });
+
+  test('scans only project source files, not node_modules', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    // Only 2 source .ts files exist: core/src/index.ts and app/src/index.ts
+    // Plus 3 package.json files (root + core + app)
+    const tsFiles = result.totalFiles;
+
+    // node_modules has 4 files (fake-dep/index.js, fake-dep/package.json, 
+    // another-dep/index.js, root-dep/index.js) — NONE should appear
+    expect(tsFiles).toBeLessThanOrEqual(10); // generous upper bound
+    expect(tsFiles).toBeGreaterThanOrEqual(2); // at least the 2 .ts files
+
+    // Verify no node_modules paths in the file tree
+    const allPaths = getAllFilePaths(result.fileTree!);
+    const nmPaths = allPaths.filter(p => p.includes('node_modules'));
+    expect(nmPaths).toHaveLength(0);
+  });
+
+  test('detects workspaces from root package.json', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    expect(result.workspaces).toBeDefined();
+    expect(result.workspaces!.length).toBe(2);
+
+    const names = result.workspaces!.map(ws => ws.name);
+    expect(names).toContain('@test/core');
+    expect(names).toContain('@test/app');
+  });
+
+  test('detects Express.js from workspace package.json (not from node_modules)', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    expect(result.frameworks).toContain('Express.js');
+  });
+
+  test('does NOT detect Vue.js or Mongoose from nested node_modules', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    // fake-dep/package.json has vue and mongoose as deps
+    // These must NOT appear as project frameworks
+    expect(result.frameworks).not.toContain('Vue.js');
+    expect(result.frameworks).not.toContain('Mongoose');
+  });
+
+  test('does NOT detect Spring Boot or Spring (no Java in project)', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    expect(result.frameworks).not.toContain('Spring Boot');
+    expect(result.frameworks).not.toContain('Spring');
+  });
+
+  test('dependency graph contains no node_modules paths', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    const analyzer = new ArchitectureAnalyzer(FIXTURE_PATH);
+    const edges = analyzer.analyzeDependencies(result.fileTree!);
+
+    for (const edge of edges) {
+      expect(edge.from).not.toContain('node_modules');
+      expect(edge.to).not.toContain('node_modules');
+    }
+  });
+
+  test('anti-patterns are only from project files', () => {
+    const scanner = new ProjectScanner(FIXTURE_PATH, config);
+    const result = scanner.scan();
+
+    const analyzer = new ArchitectureAnalyzer(FIXTURE_PATH);
+    const edges = analyzer.analyzeDependencies(result.fileTree!);
+    const deps = new Map<string, Set<string>>();
+    for (const edge of edges) {
+      if (!deps.has(edge.from)) deps.set(edge.from, new Set());
+      deps.get(edge.from)!.add(edge.to);
+    }
+
+    const detector = new AntiPatternDetector(config);
+    const patterns = detector.detect(result.fileTree!, deps);
+
+    for (const pattern of patterns) {
+      expect(pattern.location).not.toContain('node_modules');
+      if (pattern.affectedFiles) {
+        for (const file of pattern.affectedFiles) {
+          expect(file).not.toContain('node_modules');
+        }
+      }
+    }
+  });
+});
+
+describe('normalizeIgnorePatterns', () => {
+  test('converts simple names to glob patterns', () => {
+    const result = normalizeIgnorePatterns(['node_modules']);
+    expect(result).toContain('**/node_modules/**');
+    expect(result).toContain('**/node_modules');
+    expect(result).toContain('node_modules/**');
+  });
+
+  test('preserves existing glob patterns', () => {
+    const result = normalizeIgnorePatterns(['**/dist/**']);
+    expect(result).toContain('**/dist/**');
+    // Should not double-wrap
+    expect(result).not.toContain('**/**/dist/**/**');
+  });
+
+  test('handles mixed patterns', () => {
+    const result = normalizeIgnorePatterns(['node_modules', '**/custom/**', 'dist']);
+    expect(result).toContain('**/node_modules/**');
+    expect(result).toContain('**/custom/**');
+    expect(result).toContain('**/dist/**');
+  });
+
+  test('handles path-like patterns with slashes', () => {
+    const result = normalizeIgnorePatterns(['some/specific/path']);
+    expect(result).toContain('some/specific/path');
+    // Should not expand patterns with slashes
+    expect(result).not.toContain('**/some/specific/path/**');
+  });
+});
+
+// Helper
+function getAllFilePaths(node: { path: string; type: string; children?: any[] }): string[] {
+  const paths: string[] = [];
+  if (node.type === 'file') paths.push(node.path);
+  if (node.children) {
+    for (const child of node.children) {
+      paths.push(...getAllFilePaths(child));
+    }
+  }
+  return paths;
+}

package/tests/scanner.test.ts

@@ -1,10 +1,9 @@
-import { fileURLToPath } from 'url';
 import path from 'path';
 import { ProjectScanner } from '../src/scanner.js';
 import { ArchitectConfig } from '../src/types.js';
 
-const __filename = fileURLToPath(import.meta.url);
-const __dirname = path.dirname(__filename);
+// Use path.resolve for Jest compatibility (import.meta.url not supported by ts-jest)
+const testDir = path.resolve(process.cwd(), 'tests');
 
 describe('ProjectScanner', () => {
   const mockConfig: ArchitectConfig = {
@@ -14,11 +13,11 @@ describe('ProjectScanner', () => {
 
   describe('scan', () => {
     it('should scan a project directory and return project info', () => {
-      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const scanner = new ProjectScanner(testDir, mockConfig);
       const info = scanner.scan();
 
       expect(info).toBeDefined();
-      expect(info.path).toBe(__dirname);
+      expect(info.path).toBe(testDir);
       expect(info.totalFiles).toBeGreaterThanOrEqual(0);
       expect(info.totalLines).toBeGreaterThanOrEqual(0);
       expect(Array.isArray(info.primaryLanguages)).toBe(true);
@@ -26,7 +25,7 @@ describe('ProjectScanner', () => {
     });
 
     it('should detect TypeScript files', () => {
-      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const scanner = new ProjectScanner(testDir, mockConfig);
       const info = scanner.scan();
 
       if (info.totalFiles > 0) {
@@ -35,7 +34,7 @@ describe('ProjectScanner', () => {
     });
 
     it('should build a file tree structure', () => {
-      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const scanner = new ProjectScanner(testDir, mockConfig);
       const info = scanner.scan();
 
       expect(info.fileTree).toBeDefined();
@@ -46,7 +45,7 @@ describe('ProjectScanner', () => {
 
   describe('framework detection', () => {
     it('should detect frameworks from configuration files', () => {
-      const scanner = new ProjectScanner(__dirname, mockConfig);
+      const scanner = new ProjectScanner(testDir, mockConfig);
       const info = scanner.scan();
 
       expect(Array.isArray(info.frameworks)).toBe(true);