ai-first-cli 1.2.3 → 1.3.0

package/src/utils/constants.ts

@@ -0,0 +1,78 @@
+import path from "path";
+
+/**
+ * Constantes centralizadas para rutas del sistema ai-first-cli
+ * 
+ * Esta migración de ai/ a ai-context/ fue realizada para estandarizar
+ * la arquitectura y evitar inconsistencias entre comandos.
+ */
+
+// Directorio principal de contexto (arquitectura nueva)
+export const AI_CONTEXT_DIR = "ai-context";
+
+// Directorio legacy (para compatibilidad hacia atrás)
+export const AI_LEGACY_DIR = "ai";
+
+/**
+ * Obtiene la ruta completa al directorio ai-context/
+ */
+export function getAiContextDir(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR);
+}
+
+/**
+ * Obtiene la ruta completa al archivo index.db
+ */
+export function getIndexDbPath(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "index.db");
+}
+
+/**
+ * Obtiene la ruta completa al archivo hierarchy.json
+ */
+export function getHierarchyPath(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "hierarchy.json");
+}
+
+/**
+ * Obtiene la ruta al directorio ccp/
+ */
+export function getCcpDir(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "ccp");
+}
+
+/**
+ * Obtiene la ruta completa a un archivo CCP específico
+ */
+export function getCcpPath(rootDir: string, name: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "ccp", name, "context.json");
+}
+
+/**
+ * Obtiene la ruta al directorio de features
+ */
+export function getFeaturesDir(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "context", "features");
+}
+
+/**
+ * Obtiene la ruta al directorio de flows
+ */
+export function getFlowsDir(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "context", "flows");
+}
+
+/**
+ * Obtiene la ruta al directorio graph/
+ */
+export function getGraphDir(rootDir: string): string {
+  return path.join(rootDir, AI_CONTEXT_DIR, "graph");
+}
+
+/**
+ * Verifica si una ruta corresponde al directorio ai-context/ o ai/ legacy
+ * Util para excluir estos directorios del análisis
+ */
+export function isAiDirectory(dirName: string): boolean {
+  return dirName === AI_CONTEXT_DIR || dirName === AI_LEGACY_DIR;
+}

package/tests/analysis.test.ts

@@ -0,0 +1,283 @@
+import { describe, it, expect } from "vitest";
+import {
+  dependencyAnalyzer,
+  callGraphBuilder,
+  inheritanceAnalyzer,
+} from "../src/core/analysis/index.js";
+
+describe("Dependency Analyzer", () => {
+  it("should analyze imports", () => {
+    const filePath = "src/auth/service.ts";
+    const imports = [
+      { name: "express", module: "express", isDefault: true },
+      { name: "User", module: "./user.model", isDefault: false },
+    ];
+    const exports = ["AuthService"];
+
+    const relations = dependencyAnalyzer.analyzeImports(filePath, imports, exports);
+
+    expect(relations).toHaveLength(3);
+
+    const expressImport = relations.find((r) => r.to === "express");
+    expect(expressImport).toBeDefined();
+    expect(expressImport?.type).toBe("import");
+    expect(expressImport?.isDefault).toBe(true);
+
+    const userImport = relations.find((r) => r.to === "./user.model");
+    expect(userImport?.symbols).toContain("User");
+
+    const authExport = relations.find((r) => r.type === "export");
+    expect(authExport?.symbols).toContain("AuthService");
+  });
+
+  it("should build dependency graph", () => {
+    const files = [
+      {
+        filePath: "src/auth.ts",
+        imports: [{ name: "User", module: "./user", isDefault: false }],
+        exports: ["AuthService"],
+      },
+      {
+        filePath: "src/user.ts",
+        imports: [{ name: "db", module: "./db", isDefault: true }],
+        exports: ["User", "UserRepository"],
+      },
+    ];
+
+    const graph = dependencyAnalyzer.buildDependencyGraph(files);
+
+    expect(graph.nodes).toHaveLength(2);
+    expect(graph.nodes).toContain("src/auth.ts");
+    expect(graph.nodes).toContain("src/user.ts");
+    expect(graph.edges.length).toBeGreaterThanOrEqual(3);
+  });
+
+  it("should detect circular dependencies", () => {
+    const graph = dependencyAnalyzer.buildDependencyGraph([
+      {
+        filePath: "src/a.ts",
+        imports: [{ name: "B", module: "src/b.ts", isDefault: false }],
+        exports: ["A"],
+      },
+      {
+        filePath: "src/b.ts",
+        imports: [{ name: "C", module: "src/c.ts", isDefault: false }],
+        exports: ["B"],
+      },
+      {
+        filePath: "src/c.ts",
+        imports: [{ name: "A", module: "src/a.ts", isDefault: false }],
+        exports: ["C"],
+      },
+    ]);
+
+    const cycles = dependencyAnalyzer.detectCircularDependencies(graph);
+    expect(cycles.length).toBeGreaterThan(0);
+  });
+
+  it("should calculate metrics", () => {
+    const graph = dependencyAnalyzer.buildDependencyGraph([
+      {
+        filePath: "src/a.ts",
+        imports: [
+          { name: "utils", module: "./utils", isDefault: true },
+          { name: "helper", module: "./helper", isDefault: false },
+        ],
+        exports: ["A"],
+      },
+      {
+        filePath: "src/b.ts",
+        imports: [{ name: "utils", module: "./utils", isDefault: true }],
+        exports: ["B"],
+      },
+    ]);
+
+    const metrics = dependencyAnalyzer.calculateMetrics(graph);
+
+    expect(metrics.totalFiles).toBe(2);
+    expect(metrics.totalImports).toBe(3);
+    expect(metrics.avgImportsPerFile).toBe(1.5);
+    expect(metrics.mostImported[0].module).toBe("./utils");
+    expect(metrics.mostImported[0].count).toBe(2);
+  });
+});
+
+describe("Call Graph Builder", () => {
+  it("should build call graph", () => {
+    const symbols = [
+      { id: "src/a.ts#main", name: "main", file: "src/a.ts", type: "function" },
+      { id: "src/a.ts#helper", name: "helper", file: "src/a.ts", type: "function" },
+      { id: "src/b.ts#utils", name: "utils", file: "src/b.ts", type: "function" },
+    ];
+
+    const calls = [
+      {
+        caller: "src/a.ts#main",
+        callee: "src/a.ts#helper",
+        line: 10,
+        character: 5,
+      },
+      {
+        caller: "src/a.ts#helper",
+        callee: "src/b.ts#utils",
+        line: 20,
+        character: 8,
+      },
+    ];
+
+    const graph = callGraphBuilder.buildCallGraph(symbols, calls);
+
+    expect(graph.nodes).toHaveLength(3);
+    expect(graph.edges).toHaveLength(2);
+
+    const mainCalls = graph.callsByFunction.get("src/a.ts#main");
+    expect(mainCalls).toHaveLength(1);
+    expect(mainCalls?.[0].callee).toBe("src/a.ts#helper");
+  });
+
+  it("should find unused functions", () => {
+    const graph = callGraphBuilder.buildCallGraph(
+      [
+        { id: "src/a.ts#main", name: "main", file: "src/a.ts", type: "function" },
+        { id: "src/a.ts#used", name: "used", file: "src/a.ts", type: "function" },
+        { id: "src/a.ts#unused", name: "unused", file: "src/a.ts", type: "function" },
+      ],
+      [
+        {
+          caller: "src/a.ts#main",
+          callee: "src/a.ts#used",
+          line: 10,
+          character: 5,
+        },
+      ]
+    );
+
+    const unused = callGraphBuilder.findUnusedFunctions(graph);
+    expect(unused).toContain("src/a.ts#unused");
+    expect(unused).not.toContain("src/a.ts#main");
+    expect(unused).not.toContain("src/a.ts#used");
+  });
+
+  it("should get call chain", () => {
+    const graph = callGraphBuilder.buildCallGraph(
+      [
+        { id: "main", name: "main", file: "main.ts", type: "function" },
+        { id: "a", name: "a", file: "a.ts", type: "function" },
+        { id: "b", name: "b", file: "b.ts", type: "function" },
+        { id: "c", name: "c", file: "c.ts", type: "function" },
+      ],
+      [
+        { caller: "main", callee: "a", line: 1, character: 1 },
+        { caller: "a", callee: "b", line: 2, character: 2 },
+        { caller: "b", callee: "c", line: 3, character: 3 },
+      ]
+    );
+
+    const chain = callGraphBuilder.getCallChain(graph, "main", 5);
+    expect(chain).toContain("main");
+    expect(chain).toContain("a");
+    expect(chain).toContain("b");
+    expect(chain).toContain("c");
+  });
+});
+
+describe("Inheritance Analyzer", () => {
+  it("should build inheritance hierarchy", () => {
+    const symbols = [
+      {
+        id: "Animal",
+        name: "Animal",
+        type: "class",
+        heritage: {},
+      },
+      {
+        id: "Dog",
+        name: "Dog",
+        type: "class",
+        heritage: { extends: ["Animal"] },
+      },
+      {
+        id: "Cat",
+        name: "Cat",
+        type: "class",
+        heritage: { extends: ["Animal"] },
+      },
+      {
+        id: "IAnimal",
+        name: "IAnimal",
+        type: "interface",
+        heritage: {},
+      },
+      {
+        id: "DogWithInterface",
+        name: "DogWithInterface",
+        type: "class",
+        heritage: { extends: ["Animal"], implements: ["IAnimal"] },
+      },
+    ];
+
+    const graph = inheritanceAnalyzer.buildHierarchy(symbols);
+
+    expect(graph.nodes).toHaveLength(5);
+    expect(graph.edges).toHaveLength(4);
+
+    const dogExtends = graph.edges.filter((e) => e.child === "Dog" && e.type === "extends");
+    expect(dogExtends).toHaveLength(1);
+    expect(dogExtends[0].parent).toBe("Animal");
+
+    const implementsEdge = graph.edges.find((e) => e.type === "implements");
+    expect(implementsEdge).toBeDefined();
+  });
+
+  it("should get ancestors", () => {
+    const graph = inheritanceAnalyzer.buildHierarchy([
+      { id: "A", name: "A", type: "class", heritage: {} },
+      { id: "B", name: "B", type: "class", heritage: { extends: ["A"] } },
+      { id: "C", name: "C", type: "class", heritage: { extends: ["B"] } },
+    ]);
+
+    const ancestors = inheritanceAnalyzer.getAncestors(graph, "C");
+    expect(ancestors).toContain("B");
+    expect(ancestors).toContain("A");
+  });
+
+  it("should get descendants", () => {
+    const graph = inheritanceAnalyzer.buildHierarchy([
+      { id: "A", name: "A", type: "class", heritage: {} },
+      { id: "B", name: "B", type: "class", heritage: { extends: ["A"] } },
+      { id: "C", name: "C", type: "class", heritage: { extends: ["B"] } },
+      { id: "D", name: "D", type: "class", heritage: { extends: ["A"] } },
+    ]);
+
+    const descendants = inheritanceAnalyzer.getDescendants(graph, "A");
+    expect(descendants).toContain("B");
+    expect(descendants).toContain("C");
+    expect(descendants).toContain("D");
+  });
+
+  it("should calculate inheritance depth", () => {
+    const graph = inheritanceAnalyzer.buildHierarchy([
+      { id: "A", name: "A", type: "class", heritage: {} },
+      { id: "B", name: "B", type: "class", heritage: { extends: ["A"] } },
+      { id: "C", name: "C", type: "class", heritage: { extends: ["B"] } },
+    ]);
+
+    const depths = inheritanceAnalyzer.detectInheritanceDepth(graph);
+    expect(depths.get("A")).toBe(0);
+    expect(depths.get("B")).toBe(1);
+    expect(depths.get("C")).toBe(2);
+  });
+
+  it("should find base classes", () => {
+    const graph = inheritanceAnalyzer.buildHierarchy([
+      { id: "A", name: "A", type: "class", heritage: {} },
+      { id: "B", name: "B", type: "class", heritage: { extends: ["A"] } },
+      { id: "C", name: "C", type: "class", heritage: {} },
+    ]);
+
+    const baseClasses = inheritanceAnalyzer.findBaseClasses(graph);
+    expect(baseClasses).toContain("A");
+    expect(baseClasses).toContain("C");
+    expect(baseClasses).not.toContain("B");
+  });
+});

package/tests/architectureDetector.test.ts

@@ -0,0 +1,137 @@
+import { describe, it, expect } from "vitest";
+import { architectureDetector } from "../src/core/analysis/architectureDetector.js";
+
+describe("Architecture Detector", () => {
+  it("should detect MVC pattern", () => {
+    const symbols = [
+      { id: "src/controllers/user.ts#UserController", name: "UserController", type: "class", file: "src/controllers/user.ts" },
+      { id: "src/models/user.ts#User", name: "User", type: "class", file: "src/models/user.ts" },
+      { id: "src/views/user.html#UserView", name: "UserView", type: "class", file: "src/views/user.html" },
+    ];
+
+    const graph = {
+      edges: [
+        { from: "src/controllers/user.ts#UserController", to: "src/models/user.ts#User", type: "import" },
+      ],
+    };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    expect(result.primary).not.toBeNull();
+    expect(result.primary?.name).toContain("MVC");
+    expect(result.primary?.confidence).toBeGreaterThan(0.5);
+    expect(result.primary?.evidence.length).toBeGreaterThan(0);
+  });
+
+  it("should detect Layered Architecture", () => {
+    const symbols = [
+      { id: "src/api/controller.ts#ApiController", name: "ApiController", type: "class", file: "src/api/controller.ts" },
+      { id: "src/services/user.ts#UserService", name: "UserService", type: "class", file: "src/services/user.ts" },
+      { id: "src/repositories/user.ts#UserRepository", name: "UserRepository", type: "class", file: "src/repositories/user.ts" },
+    ];
+
+    const graph = {
+      edges: [
+        { from: "src/api/controller.ts#ApiController", to: "src/services/user.ts#UserService", type: "import" },
+        { from: "src/services/user.ts#UserService", to: "src/repositories/user.ts#UserRepository", type: "import" },
+      ],
+    };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    expect(result.layers.length).toBeGreaterThanOrEqual(2);
+    
+    const apiLayer = result.layers.find(l => l.name.includes("API"));
+    expect(apiLayer).toBeDefined();
+    expect(apiLayer?.symbols).toContain("src/api/controller.ts#ApiController");
+
+    const serviceLayer = result.layers.find(l => l.name.includes("Service"));
+    expect(serviceLayer).toBeDefined();
+    expect(serviceLayer?.symbols).toContain("src/services/user.ts#UserService");
+  });
+
+  it("should detect Clean Architecture", () => {
+    const symbols = [
+      { id: "src/domain/entity.ts#User", name: "User", type: "class", file: "src/domain/entity.ts" },
+      { id: "src/usecases/create.ts#CreateUserUseCase", name: "CreateUserUseCase", type: "class", file: "src/usecases/create.ts" },
+      { id: "src/interfaces/controller.ts#UserController", name: "UserController", type: "class", file: "src/interfaces/controller.ts" },
+    ];
+
+    const graph = {
+      edges: [
+        { from: "src/usecases/create.ts#CreateUserUseCase", to: "src/domain/entity.ts#User", type: "import" },
+      ],
+    };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    const cleanArch = result.secondary.find(p => p.name.includes("Clean"));
+    expect(cleanArch || result.primary?.name.includes("Clean")).toBeTruthy();
+  });
+
+  it("should detect entry points", () => {
+    const symbols = [
+      { id: "src/main.ts#main", name: "main", type: "function", file: "src/main.ts" },
+      { id: "src/index.ts#bootstrap", name: "bootstrap", type: "function", file: "src/index.ts" },
+      { id: "src/utils/helper.ts#helper", name: "helper", type: "function", file: "src/utils/helper.ts" },
+    ];
+
+    const graph = { edges: [] };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    expect(result.entryPoints).toContain("src/main.ts#main");
+    expect(result.entryPoints).toContain("src/index.ts#bootstrap");
+    expect(result.entryPoints).not.toContain("src/utils/helper.ts#helper");
+  });
+
+  it("should detect multiple patterns", () => {
+    const symbols = [
+      { id: "src/controllers/home.ts#HomeController", name: "HomeController", type: "class", file: "src/controllers/home.ts" },
+      { id: "src/models/user.ts#User", name: "User", type: "class", file: "src/models/user.ts" },
+      { id: "src/services/auth.ts#AuthService", name: "AuthService", type: "class", file: "src/services/auth.ts" },
+      { id: "src/repositories/user.ts#UserRepository", name: "UserRepository", type: "class", file: "src/repositories/user.ts" },
+    ];
+
+    const graph = {
+      edges: [
+        { from: "src/controllers/home.ts#HomeController", to: "src/services/auth.ts#AuthService", type: "import" },
+        { from: "src/services/auth.ts#AuthService", to: "src/repositories/user.ts#UserRepository", type: "import" },
+      ],
+    };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    expect(result.secondary.length).toBeGreaterThan(0);
+    const totalPatterns = (result.primary ? 1 : 0) + result.secondary.length;
+    expect(totalPatterns).toBeGreaterThanOrEqual(1);
+  });
+
+  it("should return empty analysis for unknown patterns", () => {
+    const symbols = [
+      { id: "src/utils/helper.ts#helper", name: "helper", type: "function", file: "src/utils/helper.ts" },
+    ];
+
+    const graph = { edges: [] };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    expect(result.primary).toBeNull();
+    expect(result.layers.length).toBe(0);
+  });
+
+  it("should detect API layer components", () => {
+    const symbols = [
+      { id: "src/routes/user.ts#userRoutes", name: "userRoutes", type: "const", file: "src/routes/user.ts" },
+      { id: "src/handlers/auth.ts#authHandler", name: "authHandler", type: "function", file: "src/handlers/auth.ts" },
+    ];
+
+    const graph = { edges: [] };
+
+    const result = architectureDetector.detect(symbols, graph);
+
+    const apiLayer = result.layers.find(l => l.name.includes("API"));
+    expect(apiLayer).toBeDefined();
+    expect(apiLayer?.symbols.length).toBeGreaterThanOrEqual(1);
+  });
+});