@girardelli/architect-core 8.1.0

package/src/infrastructure/scanner.ts

@@ -0,0 +1,349 @@
+import { globSync } from 'glob';
+import { readFileSync, lstatSync, existsSync } from 'fs';
+    // @ts-ignore - Audit cleanup unused variable
+import { join, relative, extname, resolve } from 'path';
+import { FileNode, ProjectInfo, WorkspaceInfo } from '../core/types/infrastructure.js';
+import { ArchitectConfig } from '../core/types/core.js';
+import { logger } from './logger.js';
+
+export class ProjectScanner {
+  private projectPath: string;
+  private config: ArchitectConfig;
+    // @ts-ignore - Audit cleanup unused variable
+  private frameworks: Set<string> = new Set();
+
+  constructor(projectPath: string, config: ArchitectConfig) {
+    this.projectPath = projectPath;
+    this.config = config;
+  }
+
+  scan(): ProjectInfo {
+    const files = this.scanDirectory();
+    const fileTree = this.buildFileTree(files);
+
+    // Detect workspaces from root package.json
+    const workspaces = this.detectWorkspaces();
+
+    // Detect frameworks ONLY from root + workspace package.json files (never from node_modules)
+    const workspacePkgJsonPaths = [
+      join(this.projectPath, 'package.json'),
+      ...workspaces.map(ws => join(ws.path, 'package.json')),
+    ].filter(p => existsSync(p));
+
+    const frameworks = this.detectFrameworks(workspacePkgJsonPaths);
+    const languages = this.detectLanguages(files);
+    const totalLines = this.countTotalLines(files);
+    const projectName = this.resolveProjectName(workspacePkgJsonPaths);
+
+    return {
+      path: this.projectPath,
+      name: projectName,
+      frameworks: Array.from(frameworks),
+      totalFiles: files.length,
+      totalLines,
+      primaryLanguages: languages,
+      fileTree,
+      workspaces: workspaces.length > 0 ? workspaces : undefined,
+    };
+  }
+
+  /**
+   * Detect npm/yarn/pnpm workspaces from root package.json.
+   * Reads the "workspaces" field and resolves each workspace to its package.json.
+   */
+  private detectWorkspaces(): WorkspaceInfo[] {
+    const rootPkgPath = join(this.projectPath, 'package.json');
+    if (!existsSync(rootPkgPath)) return [];
+
+    try {
+      const rootPkg = JSON.parse(readFileSync(rootPkgPath, 'utf-8'));
+      let workspaceGlobs: string[] = [];
+
+      if (Array.isArray(rootPkg.workspaces)) {
+        workspaceGlobs = rootPkg.workspaces;
+      } else if (rootPkg.workspaces?.packages && Array.isArray(rootPkg.workspaces.packages)) {
+        workspaceGlobs = rootPkg.workspaces.packages;
+      }
+
+      if (workspaceGlobs.length === 0) return [];
+
+      const workspaces: WorkspaceInfo[] = [];
+
+      for (const pattern of workspaceGlobs) {
+        // Resolve glob patterns like "packages/*"
+        const dirs = globSync(pattern, {
+          cwd: this.projectPath,
+          absolute: true,
+        });
+
+        for (const dir of dirs) {
+          const pkgPath = join(dir, 'package.json');
+          if (!existsSync(pkgPath)) continue;
+
+          try {
+            const pkg = JSON.parse(readFileSync(pkgPath, 'utf-8'));
+            workspaces.push({
+              name: pkg.name || relative(this.projectPath, dir),
+              path: dir,
+              relativePath: relative(this.projectPath, dir),
+              description: pkg.description || '',
+              version: pkg.version || '0.0.0',
+              dependencies: pkg.dependencies || {},
+              devDependencies: pkg.devDependencies || {},
+              bin: pkg.bin || undefined,
+              main: pkg.main || undefined,
+            });
+          } catch (error) {
+            logger.debug('Skipping unparseable package.json in workspace', { pkgPath, error });
+          }
+        }
+      }
+
+      return workspaces;
+    } catch (error) {
+      logger.debug('Failed to parse root package.json for workspaces', { error });
+      return [];
+    }
+  }
+
+  /**
+   * Resolve project name from nearest package.json or directory name
+   */
+  private resolveProjectName(packageJsonPaths: string[]): string {
+    for (const pkgPath of packageJsonPaths) {
+      try {
+        const content = readFileSync(pkgPath, 'utf-8');
+        const parsed = JSON.parse(content);
+        if (parsed.name) {
+          return parsed.name;
+        }
+      } catch (error) {
+        logger.debug('Skipping unparseable package.json while resolving project name', { pkgPath, error });
+      }
+    }
+    return this.projectPath.split('/').pop() || 'project';
+  }
+
+  private scanDirectory(): string[] {
+    const ignorePatterns = this.config.ignore || [];
+
+    const files = globSync('**/*', {
+      cwd: this.projectPath,
+      ignore: ignorePatterns,
+      absolute: true,
+      nodir: true,
+    });
+
+    return files.filter(
+      (f) =>
+        !lstatSync(f).isDirectory() && this.isSourceFile(f)
+    );
+  }
+
+  private isSourceFile(filePath: string): boolean {
+    const ext = extname(filePath).toLowerCase();
+    const sourceExtensions = [
+      '.js',
+      '.ts',
+      '.tsx',
+      '.jsx',
+      '.py',
+      '.java',
+      '.go',
+      '.rb',
+      '.php',
+      '.cs',
+      '.cpp',
+      '.c',
+      '.h',
+      '.rs',
+      '.kt',
+      '.scala',
+      '.groovy',
+      '.sql',
+      '.graphql',
+      '.json',
+      '.yaml',
+      '.yml',
+      '.xml',
+    ];
+    return sourceExtensions.includes(ext);
+  }
+
+  private buildFileTree(files: string[]): FileNode {
+    const root: FileNode = {
+      path: this.projectPath,
+      name: this.projectPath.split('/').pop() || 'root',
+      type: 'directory',
+    };
+
+    for (const file of files) {
+      const relativePath = relative(this.projectPath, file);
+      const parts = relativePath.split('/');
+      let current = root;
+
+      for (let i = 0; i < parts.length; i++) {
+        const part = parts[i];
+        const isFile = i === parts.length - 1;
+
+        let child = (current.children || []).find((c) => c.name === part);
+        if (!child) {
+          child = {
+            path: join(current.path, part),
+            name: part,
+            type: isFile ? 'file' : 'directory',
+            extension: isFile ? extname(part) : undefined,
+          };
+
+          if (isFile) {
+            child.lines = this.countLines(file);
+            child.language = this.detectLanguage(file);
+          }
+
+          if (!current.children) current.children = [];
+          current.children.push(child);
+        }
+
+        current = child;
+      }
+    }
+
+    return root;
+  }
+
+  /**
+   * Detect frameworks ONLY from specified package.json files.
+   * Never reads package.json from node_modules.
+   * No string-matching fallback — only structured dependency key detection.
+   */
+  private detectFrameworks(packageJsonPaths: string[]): Set<string> {
+    const frameworks = new Set<string>();
+
+    for (const file of packageJsonPaths) {
+      if (!file.endsWith('package.json')) continue;
+
+      // Safety: skip any path that includes node_modules
+      if (file.includes('node_modules')) continue;
+
+      try {
+        const content = readFileSync(file, 'utf-8');
+        const parsed = JSON.parse(content);
+        const allDeps = {
+          ...parsed.dependencies,
+          ...parsed.devDependencies,
+        };
+
+        // Detect from actual dependency keys — no string fallback
+        if (allDeps['@nestjs/core'] || allDeps['@nestjs/common']) frameworks.add('NestJS');
+        if (allDeps['react'] || allDeps['react-dom']) frameworks.add('React');
+        if (allDeps['@angular/core']) frameworks.add('Angular');
+        if (allDeps['vue'] || allDeps['@vue/core']) frameworks.add('Vue.js');
+        if (allDeps['express']) frameworks.add('Express.js');
+        if (allDeps['next']) frameworks.add('Next.js');
+        if (allDeps['fastify']) frameworks.add('Fastify');
+        if (allDeps['typeorm']) frameworks.add('TypeORM');
+        if (allDeps['prisma'] || allDeps['@prisma/client']) frameworks.add('Prisma');
+        if (allDeps['sequelize']) frameworks.add('Sequelize');
+        if (allDeps['mongoose']) frameworks.add('Mongoose');
+        if (allDeps['@modelcontextprotocol/sdk']) frameworks.add('MCP SDK');
+        if (allDeps['probot']) frameworks.add('Probot');
+        if (allDeps['hono']) frameworks.add('Hono');
+      } catch (error) {
+        logger.debug('Skipping unparseable package.json during framework detection', { file, error });
+      }
+    }
+
+    // Check for pom.xml only at project root
+    const pomPath = join(this.projectPath, 'pom.xml');
+    if (existsSync(pomPath)) {
+      try {
+        const content = readFileSync(pomPath, 'utf-8');
+        if (content.includes('spring-boot')) frameworks.add('Spring Boot');
+        if (content.includes('spring') && !content.includes('spring-boot')) frameworks.add('Spring');
+      } catch (error) {
+        logger.debug('Error reading pom.xml', { error });
+      }
+    }
+
+    // Check for requirements.txt only at project root
+    const reqPath = join(this.projectPath, 'requirements.txt');
+    if (existsSync(reqPath)) {
+      try {
+        const content = readFileSync(reqPath, 'utf-8');
+        if (content.includes('django')) frameworks.add('Django');
+        if (content.includes('flask')) frameworks.add('Flask');
+        if (content.includes('fastapi')) frameworks.add('FastAPI');
+      } catch (error) {
+        logger.debug('Error reading requirements.txt', { error });
+      }
+    }
+
+    // Check for Gemfile only at project root
+    const gemPath = join(this.projectPath, 'Gemfile');
+    if (existsSync(gemPath)) {
+      try {
+        const content = readFileSync(gemPath, 'utf-8');
+        if (content.includes('rails')) frameworks.add('Ruby on Rails');
+      } catch (error) {
+        logger.debug('Error reading Gemfile', { error });
+      }
+    }
+
+    // Check for go.mod only at project root
+    if (existsSync(join(this.projectPath, 'go.mod'))) {
+      frameworks.add('Go');
+    }
+
+    return frameworks;
+  }
+
+  private detectLanguages(files: string[]): string[] {
+    const languages = new Set<string>();
+
+    for (const file of files) {
+      const lang = this.detectLanguage(file);
+      if (lang && lang !== 'Unknown') languages.add(lang);
+    }
+
+    return Array.from(languages);
+  }
+
+  private detectLanguage(filePath: string): string {
+    const ext = extname(filePath).toLowerCase();
+
+    const languageMap: Record<string, string> = {
+      '.js': 'JavaScript',
+      '.ts': 'TypeScript',
+      '.tsx': 'TypeScript',
+      '.jsx': 'JavaScript',
+      '.py': 'Python',
+      '.java': 'Java',
+      '.go': 'Go',
+      '.rb': 'Ruby',
+      '.php': 'PHP',
+      '.cs': 'C#',
+      '.cpp': 'C++',
+      '.c': 'C',
+      '.rs': 'Rust',
+      '.kt': 'Kotlin',
+      '.scala': 'Scala',
+      '.sql': 'SQL',
+      '.graphql': 'GraphQL',
+    };
+
+    return languageMap[ext] || 'Unknown';
+  }
+
+  private countLines(filePath: string): number {
+    try {
+      const content = readFileSync(filePath, 'utf-8');
+      return content.split('\n').length;
+    } catch {
+      return 0;
+    }
+  }
+
+  private countTotalLines(files: string[]): number {
+    return files.reduce((total, file) => total + this.countLines(file), 0);
+  }
+}

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/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

@@ -0,0 +1,95 @@
+import { AntiPatternDetector } from '../src/core/anti-patterns.js';
+import { 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', async () => {
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = await detector.detect(mockFileTree, mockDependencies);
+
+      expect(Array.isArray(patterns)).toBe(true);
+    });
+
+    it('should identify God Classes', async () => {
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = await detector.detect(mockFileTree, mockDependencies);
+
+      const godClasses = patterns.filter((p) => p.name === 'God Class');
+      expect(godClasses.length).toBeGreaterThanOrEqual(0);
+    });
+
+    it('should sort patterns by severity', async () => {
+      const detector = new AntiPatternDetector(mockConfig);
+      const patterns = await 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', async () => {
+      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 = await detector.detect(mockFileTree, circularDeps);
+
+      expect(patterns.length).toBeGreaterThanOrEqual(0);
+    });
+  });
+});