ai-first-cli 1.2.2 → 1.3.0

package/src/core/analysis/callGraphBuilder.ts

@@ -0,0 +1,158 @@
+export interface Call {
+  caller: string;
+  callee: string;
+  location: {
+    file: string;
+    line: number;
+    character: number;
+  };
+  arguments?: string[];
+}
+
+export interface CallGraph {
+  nodes: string[];
+  edges: Call[];
+  callsByFunction: Map<string, Call[]>;
+  calledBy: Map<string, Call[]>;
+}
+
+export class CallGraphBuilder {
+  buildCallGraph(
+    symbols: Array<{
+      id: string;
+      name: string;
+      file: string;
+      type: string;
+    }>,
+    callExpressions: Array<{
+      caller: string;
+      callee: string;
+      line: number;
+      character: number;
+      args?: string[];
+    }>
+  ): CallGraph {
+    const graph: CallGraph = {
+      nodes: symbols.map((s) => s.id),
+      edges: [],
+      callsByFunction: new Map(),
+      calledBy: new Map(),
+    };
+
+    for (const expr of callExpressions) {
+      const call: Call = {
+        caller: expr.caller,
+        callee: expr.callee,
+        location: {
+          file: expr.caller.split("#")[0],
+          line: expr.line,
+          character: expr.character,
+        },
+        arguments: expr.args,
+      };
+
+      graph.edges.push(call);
+
+      const callerCalls = graph.callsByFunction.get(expr.caller) || [];
+      callerCalls.push(call);
+      graph.callsByFunction.set(expr.caller, callerCalls);
+
+      const calleeCalled = graph.calledBy.get(expr.callee) || [];
+      calleeCalled.push(call);
+      graph.calledBy.set(expr.callee, calleeCalled);
+    }
+
+    return graph;
+  }
+
+  findUnusedFunctions(graph: CallGraph): string[] {
+    const unused: string[] = [];
+
+    for (const node of graph.nodes) {
+      const calledBy = graph.calledBy.get(node);
+      const isEntryPoint = this.isEntryPoint(node);
+
+      if ((!calledBy || calledBy.length === 0) && !isEntryPoint) {
+        unused.push(node);
+      }
+    }
+
+    return unused;
+  }
+
+  findDeadCode(graph: CallGraph, entryPoints: string[]): string[] {
+    const reachable = new Set<string>();
+
+    const traverse = (node: string) => {
+      if (reachable.has(node)) return;
+      reachable.add(node);
+
+      const calls = graph.callsByFunction.get(node) || [];
+      for (const call of calls) {
+        traverse(call.callee);
+      }
+    };
+
+    for (const entry of entryPoints) {
+      traverse(entry);
+    }
+
+    return graph.nodes.filter((n) => !reachable.has(n));
+  }
+
+  getCallChain(graph: CallGraph, startFunction: string, depth: number = 5): string[] {
+    const chain: string[] = [];
+    const visited = new Set<string>();
+
+    const traverse = (func: string, currentDepth: number) => {
+      if (currentDepth > depth || visited.has(func)) return;
+
+      visited.add(func);
+      chain.push(func);
+
+      const calls = graph.callsByFunction.get(func) || [];
+      for (const call of calls) {
+        traverse(call.callee, currentDepth + 1);
+      }
+    };
+
+    traverse(startFunction, 0);
+    return chain;
+  }
+
+  calculateComplexity(graph: CallGraph, functionId: string): number {
+    const outgoing = graph.callsByFunction.get(functionId) || [];
+    const incoming = graph.calledBy.get(functionId) || [];
+
+    return outgoing.length + incoming.length * 2;
+  }
+
+  private isEntryPoint(symbolId: string): boolean {
+    const name = symbolId.split("#")[1] || "";
+    const file = symbolId.split("#")[0] || "";
+
+    const entryPatterns = [
+      /main$/,
+      /index$/,
+      /init$/,
+      /start$/,
+      /handler$/,
+      /controller$/,
+      /route$/,
+    ];
+
+    if (entryPatterns.some((p) => p.test(name))) return true;
+
+    if (
+      file.includes("main.") ||
+      file.includes("index.") ||
+      file.includes("app.")
+    ) {
+      return true;
+    }
+
+    return false;
+  }
+}
+
+export const callGraphBuilder = new CallGraphBuilder();

package/src/core/analysis/dependencyAnalyzer.ts

@@ -0,0 +1,167 @@
+export interface ImportRelation {
+  from: string;
+  to: string;
+  type: "import" | "export" | "re-export";
+  symbols?: string[];
+  isDefault?: boolean;
+  isNamespace?: boolean;
+}
+
+export interface DependencyGraph {
+  nodes: string[];
+  edges: ImportRelation[];
+  importsByFile: Map<string, ImportRelation[]>;
+  exportsByFile: Map<string, string[]>;
+}
+
+export class DependencyAnalyzer {
+  analyzeImports(
+    filePath: string,
+    imports: Array<{
+      name: string;
+      module: string;
+      isDefault?: boolean;
+      isNamespace?: boolean;
+    }>,
+    exports: string[]
+  ): ImportRelation[] {
+    const relations: ImportRelation[] = [];
+
+    for (const imp of imports) {
+      relations.push({
+        from: filePath,
+        to: imp.module,
+        type: "import",
+        symbols: [imp.name],
+        isDefault: imp.isDefault,
+        isNamespace: imp.isNamespace,
+      });
+    }
+
+    for (const exp of exports) {
+      relations.push({
+        from: filePath,
+        to: "exports",
+        type: "export",
+        symbols: [exp],
+      });
+    }
+
+    return relations;
+  }
+
+  buildDependencyGraph(
+    parsedFiles: Array<{
+      filePath: string;
+      imports: Array<{
+        name: string;
+        module: string;
+        isDefault?: boolean;
+        isNamespace?: boolean;
+      }>;
+      exports: string[];
+    }>
+  ): DependencyGraph {
+    const graph: DependencyGraph = {
+      nodes: [],
+      edges: [],
+      importsByFile: new Map(),
+      exportsByFile: new Map(),
+    };
+
+    for (const file of parsedFiles) {
+      graph.nodes.push(file.filePath);
+
+      const relations = this.analyzeImports(
+        file.filePath,
+        file.imports,
+        file.exports
+      );
+
+      graph.edges.push(...relations);
+
+      const imports = relations.filter((r) => r.type === "import");
+      graph.importsByFile.set(file.filePath, imports);
+
+      const exports = relations
+        .filter((r) => r.type === "export")
+        .flatMap((r) => r.symbols || []);
+      graph.exportsByFile.set(file.filePath, exports);
+    }
+
+    return graph;
+  }
+
+  detectCircularDependencies(graph: DependencyGraph): string[][] {
+    const cycles: string[][] = [];
+    const visited = new Set<string>();
+    const recursionStack = new Set<string>();
+
+    const dfs = (node: string, path: string[]) => {
+      if (recursionStack.has(node)) {
+        const cycleStart = path.indexOf(node);
+        cycles.push(path.slice(cycleStart).concat([node]));
+        return;
+      }
+
+      if (visited.has(node)) return;
+
+      visited.add(node);
+      recursionStack.add(node);
+      path.push(node);
+
+      const outgoingEdges = graph.edges.filter((e) => e.from === node);
+      for (const edge of outgoingEdges) {
+        if (edge.type === "import") {
+          dfs(edge.to, [...path]);
+        }
+      }
+
+      recursionStack.delete(node);
+    };
+
+    for (const node of graph.nodes) {
+      if (!visited.has(node)) {
+        dfs(node, []);
+      }
+    }
+
+    return cycles;
+  }
+
+  calculateMetrics(graph: DependencyGraph): {
+    totalFiles: number;
+    totalImports: number;
+    totalExports: number;
+    avgImportsPerFile: number;
+    mostImported: { module: string; count: number }[];
+  } {
+    const moduleImportCounts = new Map<string, number>();
+
+    for (const edge of graph.edges) {
+      if (edge.type === "import") {
+        const count = moduleImportCounts.get(edge.to) || 0;
+        moduleImportCounts.set(edge.to, count + 1);
+      }
+    }
+
+    const mostImported = Array.from(moduleImportCounts.entries())
+      .map(([module, count]) => ({ module, count }))
+      .sort((a, b) => b.count - a.count)
+      .slice(0, 10);
+
+    const importEdges = graph.edges.filter((e) => e.type === "import");
+    const exportEdges = graph.edges.filter((e) => e.type === "export");
+
+    return {
+      totalFiles: graph.nodes.length,
+      totalImports: importEdges.length,
+      totalExports: exportEdges.length,
+      avgImportsPerFile:
+        graph.nodes.length > 0 ? importEdges.length / graph.nodes.length : 0,
+      mostImported,
+    };
+  }
+}
+
+export const dependencyAnalyzer = new DependencyAnalyzer();

package/src/core/analysis/index.ts

@@ -0,0 +1,28 @@
+export {
+  DependencyAnalyzer,
+  dependencyAnalyzer,
+  type ImportRelation,
+  type DependencyGraph,
+} from "./dependencyAnalyzer.js";
+
+export {
+  CallGraphBuilder,
+  callGraphBuilder,
+  type Call,
+  type CallGraph,
+} from "./callGraphBuilder.js";
+
+export {
+  InheritanceAnalyzer,
+  inheritanceAnalyzer,
+  type InheritanceRelation,
+  type InheritanceGraph,
+} from "./inheritanceAnalyzer.js";
+
+export {
+  ArchitectureDetector,
+  architectureDetector,
+  type ArchitecturePattern,
+  type Layer,
+  type ArchitectureAnalysis,
+} from "./architectureDetector.js";

package/src/core/analysis/inheritanceAnalyzer.ts

@@ -0,0 +1,169 @@
+export interface InheritanceRelation {
+  child: string;
+  parent: string;
+  type: "extends" | "implements";
+}
+
+export interface InheritanceGraph {
+  nodes: string[];
+  edges: InheritanceRelation[];
+  classHierarchy: Map<string, string[]>;
+  implementations: Map<string, string[]>;
+}
+
+export class InheritanceAnalyzer {
+  buildHierarchy(
+    symbols: Array<{
+      id: string;
+      name: string;
+      type: string;
+      heritage?: {
+        extends?: string[];
+        implements?: string[];
+      };
+    }>
+  ): InheritanceGraph {
+    const graph: InheritanceGraph = {
+      nodes: symbols.filter((s) => s.type === "class" || s.type === "interface").map((s) => s.id),
+      edges: [],
+      classHierarchy: new Map(),
+      implementations: new Map(),
+    };
+
+    for (const symbol of symbols) {
+      if (symbol.type !== "class" && symbol.type !== "interface") continue;
+
+      const parents: string[] = [];
+
+      if (symbol.heritage?.extends) {
+        for (const parent of symbol.heritage.extends) {
+          graph.edges.push({
+            child: symbol.id,
+            parent,
+            type: "extends",
+          });
+          parents.push(parent);
+        }
+      }
+
+      if (symbol.heritage?.implements) {
+        for (const iface of symbol.heritage.implements) {
+          graph.edges.push({
+            child: symbol.id,
+            parent: iface,
+            type: "implements",
+          });
+
+          const impls = graph.implementations.get(iface) || [];
+          impls.push(symbol.id);
+          graph.implementations.set(iface, impls);
+        }
+      }
+
+      if (parents.length > 0) {
+        graph.classHierarchy.set(symbol.id, parents);
+      }
+    }
+
+    return graph;
+  }
+
+  getAncestors(graph: InheritanceGraph, classId: string): string[] {
+    const ancestors: string[] = [];
+    const visited = new Set<string>();
+
+    const traverse = (current: string) => {
+      if (visited.has(current)) return;
+      visited.add(current);
+
+      const edges = graph.edges.filter((e) => e.child === current);
+      for (const edge of edges) {
+        ancestors.push(edge.parent);
+        traverse(edge.parent);
+      }
+    };
+
+    traverse(classId);
+    return ancestors;
+  }
+
+  getDescendants(graph: InheritanceGraph, classId: string): string[] {
+    const descendants: string[] = [];
+    const visited = new Set<string>();
+
+    const traverse = (current: string) => {
+      if (visited.has(current)) return;
+      visited.add(current);
+
+      const edges = graph.edges.filter(
+        (e) => e.parent === current && e.type === "extends"
+      );
+      for (const edge of edges) {
+        descendants.push(edge.child);
+        traverse(edge.child);
+      }
+    };
+
+    traverse(classId);
+    return descendants;
+  }
+
+  getImplementations(graph: InheritanceGraph, interfaceName: string): string[] {
+    return graph.implementations.get(interfaceName) || [];
+  }
+
+  detectInheritanceDepth(graph: InheritanceGraph): Map<string, number> {
+    const depths = new Map<string, number>();
+
+    const calculateDepth = (classId: string): number => {
+      if (depths.has(classId)) return depths.get(classId)!;
+
+      const parents = graph.classHierarchy.get(classId) || [];
+      if (parents.length === 0) {
+        depths.set(classId, 0);
+        return 0;
+      }
+
+      const parentDepths = parents.map((p) => calculateDepth(p));
+      const depth = Math.max(...parentDepths) + 1;
+      depths.set(classId, depth);
+      return depth;
+    };
+
+    for (const node of graph.nodes) {
+      calculateDepth(node);
+    }
+
+    return depths;
+  }
+
+  findBaseClasses(graph: InheritanceGraph): string[] {
+    return graph.nodes.filter((node) => {
+      const parents = graph.classHierarchy.get(node);
+      return !parents || parents.length === 0;
+    });
+  }
+
+  calculateInheritanceMetrics(graph: InheritanceGraph): {
+    totalClasses: number;
+    totalInterfaces: number;
+    inheritanceDepth: number;
+    multipleInheritance: number;
+  } {
+    const depths = this.detectInheritanceDepth(graph);
+    const maxDepth = Math.max(...depths.values(), 0);
+
+    const multipleInheritance = Array.from(graph.classHierarchy.values()).filter(
+      (parents) => parents.length > 1
+    ).length;
+
+    return {
+      totalClasses: graph.nodes.length,
+      totalInterfaces: graph.implementations.size,
+      inheritanceDepth: maxDepth,
+      multipleInheritance,
+    };
+  }
+}
+
+export const inheritanceAnalyzer = new InheritanceAnalyzer();

package/src/core/ccp.ts

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { ensureDir, writeFile, readJsonFile } from "../utils/fileUtils.js";
+import { getCcpDir, getCcpPath } from "../utils/constants.js";
 
 export interface ContextModule {
   name: string;
@@ -206,7 +207,7 @@ export function createCCP(
  * List all CCPs
  */
 export function listCCPs(rootDir: string): string[] {
-  const ccpDir = path.join(rootDir, "ai", "ccp");
+  const ccpDir = getCcpDir(rootDir);
   
   if (!fs.existsSync(ccpDir)) {
     return [];
@@ -222,7 +223,7 @@ export function listCCPs(rootDir: string): string[] {
  * Get CCP details
  */
 export function getCCP(rootDir: string, name: string): CCPContext | null {
-  const contextPath = path.join(rootDir, "ai", "ccp", name, "context.json");
+  const contextPath = getCcpPath(rootDir, name);
   
   if (!fs.existsSync(contextPath)) {
     return null;