@girardelli/architect 5.0.0 → 8.1.0

package/src/scanner.ts

@@ -1,344 +0,0 @@
-import { globSync } from 'glob';
-import { readFileSync, lstatSync, existsSync } from 'fs';
-import { join, relative, extname, resolve } from 'path';
-import { FileNode, ProjectInfo, ArchitectConfig, WorkspaceInfo } from './types.js';
-
-export class ProjectScanner {
-  private projectPath: string;
-  private config: ArchitectConfig;
-  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 {
-            // Skip unparseable package.json
-          }
-        }
-      }
-
-      return workspaces;
-    } catch {
-      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 {
-        // skip
-      }
-    }
-    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 {
-        // Skip unparseable files — NO fallback string matching
-      }
-    }
-
-    // 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 {
-        // skip
-      }
-    }
-
-    // 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 {
-        // skip
-      }
-    }
-
-    // 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 {
-        // skip
-      }
-    }
-
-    // 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/src/scorer.ts

@@ -1,254 +0,0 @@
-import { ArchitectureScore, DependencyEdge, AntiPattern, ScoreComponent } from './types.js';
-import { basename } from 'path';
-
-export class ArchitectureScorer {
-  private modularity: number = 0;
-  private coupling: number = 0;
-  private cohesion: number = 0;
-  private layering: number = 0;
-
-  /**
-   * Barrel/index files that naturally have many connections and should be
-   * excluded from coupling max-edge penalty calculations.
-   */
-  private static readonly BARREL_FILES = new Set([
-    '__init__.py', 'index.ts', 'index.js', 'index.tsx', 'index.jsx',
-    'mod.rs', '__init__.pyi',
-  ]);
-
-  score(
-    edges: DependencyEdge[],
-    antiPatterns: AntiPattern[],
-    totalFiles: number
-  ): ArchitectureScore {
-    this.calculateModularity(edges, totalFiles);
-    this.calculateCoupling(edges, totalFiles);
-    this.calculateCohesion(edges);
-    this.calculateLayering(antiPatterns, totalFiles);
-
-    const components = [
-      {
-        name: 'Modularity',
-        score: Math.round(this.modularity),
-        maxScore: 100,
-        weight: 0.4,
-        explanation:
-          'Measures appropriate module boundaries and single responsibility principle adherence',
-      },
-      {
-        name: 'Coupling',
-        score: Math.round(this.coupling),
-        maxScore: 100,
-        weight: 0.25,
-        explanation:
-          'Evaluates interdependencies between modules; lower coupling is better',
-      },
-      {
-        name: 'Cohesion',
-        score: Math.round(this.cohesion),
-        maxScore: 100,
-        weight: 0.2,
-        explanation:
-          'Assesses how closely related functionality is grouped together',
-      },
-      {
-        name: 'Layering',
-        score: Math.round(this.layering),
-        maxScore: 100,
-        weight: 0.15,
-        explanation: 'Checks adherence to architectural layer separation',
-      },
-    ];
-
-    const overall = Math.round(
-      components[0].score * components[0].weight +
-        components[1].score * components[1].weight +
-        components[2].score * components[2].weight +
-        components[3].score * components[3].weight
-    );
-
-    return {
-      overall: Math.min(100, Math.max(0, overall)),
-      components,
-      breakdown: {
-        modularity: Math.round(this.modularity),
-        coupling: Math.round(this.coupling),
-        cohesion: Math.round(this.cohesion),
-        layering: Math.round(this.layering),
-      },
-    };
-  }
-
-  private calculateModularity(edges: DependencyEdge[], totalFiles: number): void {
-    if (totalFiles === 0) {
-      this.modularity = 50;
-      return;
-    }
-
-    const avgEdgesPerFile = edges.length / totalFiles;
-
-    if (avgEdgesPerFile < 2) {
-      this.modularity = 95;
-    } else if (avgEdgesPerFile < 4) {
-      this.modularity = 85;
-    } else if (avgEdgesPerFile < 6) {
-      this.modularity = 70;
-    } else if (avgEdgesPerFile < 10) {
-      this.modularity = 50;
-    } else {
-      this.modularity = 30;
-    }
-  }
-
-  private calculateCoupling(edges: DependencyEdge[], totalFiles: number): void {
-    if (totalFiles === 0 || totalFiles === 1) {
-      this.coupling = 50;
-      return;
-    }
-
-    // Exclude barrel/index files from max-edge calculation —
-    // they naturally have many connections by design.
-    const nonBarrelEdges = edges.filter((e) => {
-      const fromFile = basename(e.from);
-      const toFile = basename(e.to);
-      return !ArchitectureScorer.BARREL_FILES.has(fromFile) &&
-             !ArchitectureScorer.BARREL_FILES.has(toFile);
-    });
-
-    const nodeWithMaxEdges = this.findNodeWithMaxEdges(nonBarrelEdges);
-    const maxEdgeCount = nodeWithMaxEdges ? nodeWithMaxEdges.count : 0;
-
-    // Use non-barrel file count for ratio calculation
-    const effectiveFiles = Math.max(totalFiles - 1, 1);
-    const couplingRatio = maxEdgeCount / effectiveFiles;
-
-    // More granular thresholds
-    if (couplingRatio < 0.15) {
-      this.coupling = 95;
-    } else if (couplingRatio < 0.25) {
-      this.coupling = 85;
-    } else if (couplingRatio < 0.35) {
-      this.coupling = 75;
-    } else if (couplingRatio < 0.5) {
-      this.coupling = 65;
-    } else if (couplingRatio < 0.7) {
-      this.coupling = 50;
-    } else if (couplingRatio < 0.85) {
-      this.coupling = 35;
-    } else {
-      this.coupling = 20;
-    }
-  }
-
-  private findNodeWithMaxEdges(
-    edges: DependencyEdge[]
-  ): { node: string; count: number } | null {
-    const nodeEdgeCount: Record<string, number> = {};
-
-    for (const edge of edges) {
-      nodeEdgeCount[edge.from] = (nodeEdgeCount[edge.from] || 0) + 1;
-      nodeEdgeCount[edge.to] = (nodeEdgeCount[edge.to] || 0) + 1;
-    }
-
-    let maxNode: string | null = null;
-    let maxCount = 0;
-
-    for (const [node, count] of Object.entries(nodeEdgeCount)) {
-      if (count > maxCount) {
-        maxCount = count;
-        maxNode = node;
-      }
-    }
-
-    return maxNode ? { node: maxNode, count: maxCount } : null;
-  }
-
-  private calculateCohesion(edges: DependencyEdge[]): void {
-    if (edges.length === 0) {
-      this.cohesion = 50;
-      return;
-    }
-
-    const internalEdges = edges.filter((e) =>
-      this.isInternalDependency(e.from, e.to)
-    ).length;
-
-    const cohesionRatio = internalEdges / edges.length;
-
-    // More granular thresholds
-    if (cohesionRatio > 0.8) {
-      this.cohesion = 95;
-    } else if (cohesionRatio > 0.6) {
-      this.cohesion = 85;
-    } else if (cohesionRatio > 0.45) {
-      this.cohesion = 75;
-    } else if (cohesionRatio > 0.3) {
-      this.cohesion = 65;
-    } else if (cohesionRatio > 0.15) {
-      this.cohesion = 50;
-    } else {
-      this.cohesion = 30;
-    }
-  }
-
-  /**
-   * Determines if a dependency is "internal" (cohesive).
-   * Two files are considered cohesive if they share the same top-level
-   * package/directory (e.g., deepguard/cli.py → deepguard/analyzer.py).
-   * This is crucial for Python flat packages where all files live in
-   * one directory but ARE cohesive.
-   */
-  private isInternalDependency(from: string, to: string): boolean {
-    const fromParts = from.split('/');
-    const toParts = to.split('/');
-
-    // If both are in root (no directory), they're cohesive
-    if (fromParts.length <= 1 && toParts.length <= 1) return true;
-
-    // Compare top-level directory (package name)
-    // e.g., "deepguard/cli.py" and "deepguard/analyzer.py" → same package
-    const fromTopLevel = fromParts.length > 1 ? fromParts[0] : '';
-    const toTopLevel = toParts.length > 1 ? toParts[0] : '';
-
-    return fromTopLevel === toTopLevel;
-  }
-
-  private calculateLayering(antiPatterns: AntiPattern[], totalFiles?: number): void {
-    const layeringViolations = antiPatterns.filter(
-      (p) =>
-        p.name === 'Leaky Abstraction' ||
-        p.name === 'Shotgun Surgery' ||
-        p.name === 'Circular Dependency'
-    ).length;
-
-    if (layeringViolations === 0) {
-      this.layering = 95;
-      return;
-    }
-
-    // Use ratio-based scoring: violations per 100 files
-    // This makes scoring fair regardless of project size
-    const fileCount = Math.max(totalFiles || 50, 10);
-    const violationRatio = layeringViolations / fileCount;
-
-    if (violationRatio < 0.02) {
-      // < 2% — e.g. 1 violation in 50 files
-      this.layering = 90;
-    } else if (violationRatio < 0.05) {
-      // < 5% — e.g. 2-3 violations in 50 files
-      this.layering = 80;
-    } else if (violationRatio < 0.1) {
-      // < 10% — e.g. 5 violations in 50 files
-      this.layering = 65;
-    } else if (violationRatio < 0.2) {
-      // < 20% — significant issues
-      this.layering = 50;
-    } else if (violationRatio < 0.35) {
-      this.layering = 35;
-    } else {
-      // > 35% — severe layering problems
-      this.layering = 20;
-    }
-  }
-}
-