ai-first-cli 1.2.2 → 1.3.0

package/src/core/semanticContexts.ts

@@ -1,6 +1,7 @@
 import fs from "fs";
 import path from "path";
 import { ensureDir, writeFile, readJsonFile } from "../utils/fileUtils.js";
+import { DEFAULT_ADAPTER, type AnalysisAdapter } from "./adapters/baseAdapter.js";
 
 export interface Feature {
   name: string;
@@ -23,77 +24,31 @@ export interface SemanticContexts {
   flows: Flow[];
 }
 
-// ============================================================
-// CONFIGURATION - Feature Detection Rules
-// ============================================================
+// Use DEFAULT_ADAPTER which has universal patterns for ALL languages/frameworks
+const ADAPTER = DEFAULT_ADAPTER;
+
+const CANDIDATE_ROOTS = ADAPTER.featureRoots;
+const IGNORED_FOLDERS = new Set(ADAPTER.ignoredFolders);
+const ENTRYPOINT_PATTERNS = ADAPTER.entrypointPatterns;
+const FLOW_ENTRY_PATTERNS = ADAPTER.flowEntrypointPatterns;
+const FLOW_EXCLUDE = new Set(ADAPTER.flowExcludePatterns);
+
+const LAYER_PATTERNS: Record<string, string[]> = {};
+for (const layer of ADAPTER.layerRules) {
+  LAYER_PATTERNS[layer.name] = layer.patterns;
+}
 
-// 1. Candidate roots - scan inside these directories
-const CANDIDATE_ROOTS = [
-  "src", "app", "packages", "services", "modules", "features",
-  // MVC patterns - for projects without src/ prefix
-  "controllers", "routes", "handlers", "views", "pages"
-];
-
-// 2. Ignore folders - these are technical, not business features
-const IGNORED_FOLDERS = new Set([
-  "utils",
-  "helpers",
-  "types",
-  "interfaces",
-  "constants",
-  "config",
-  "dto",
-  "common",
-  "shared"
-]);
-
-// 3. Entrypoint patterns - files that indicate a business feature
-const ENTRYPOINT_PATTERNS = [
-  "controller",
-  "route",
-  "handler",
-  "command",
-  "service"
-];
-
-// 4. Flow-specific patterns
-const FLOW_ENTRY_PATTERNS = [
-  "controller", "route", "handler", "command",
-  // Frontend patterns
-  "page", "screen", "view", "component"
-];
-
-// 5. Flow exclusion patterns
-const FLOW_EXCLUDE = new Set([
-  "repository", "repo", "utils", "helper", "model", "entity",
-  "dto", "type", "interface", "constant", "config"
-]);
-
-// 6. Layer detection
-const LAYER_PATTERNS: Record<string, string[]> = {
-  api: ["controller", "handler", "route", "router", "api", "endpoint"],
-  service: ["service", "services", "usecase", "interactor"],
-  data: ["repository", "repo", "dal", "dao", "data", "persistence"],
-  domain: ["model", "entity", "schema", "domain"],
-  util: ["util", "helper", "lib", "common"]
-};
-
-const LAYER_PRIORITY: Record<string, number> = {
-  api: 1, controller: 1, handler: 1, route: 1, router: 1,
-  service: 2, usecase: 2, interactor: 2,
-  data: 3, repository: 3, repo: 3, dal: 3, dao: 3, persistence: 3,
-  model: 4, entity: 4, domain: 4,
-};
+const LAYER_PRIORITY: Record<string, number> = {};
+for (const layer of ADAPTER.layerRules) {
+  for (const pattern of layer.patterns) {
+    LAYER_PRIORITY[pattern] = layer.priority;
+  }
+}
 
 const MAX_FLOW_DEPTH = 5;
 const MAX_FLOW_FILES = 30;
 
-// Supported source file extensions
-const SOURCE_EXTENSIONS = new Set([
-  ".ts", ".tsx", ".js", ".jsx", ".py", ".java", ".kt", ".go", ".rs", ".rb", ".php", ".cs", ".vue", ".svelte",
-  // Salesforce/Apex
-  ".cls", ".trigger", ".apex", ".object"
-]);
+const SOURCE_EXTENSIONS = new Set(ADAPTER.supportedExtensions);
 
 // ============================================================
 // HELPER FUNCTIONS
@@ -145,7 +100,7 @@ function getLayer(filePath: string): string {
   );
   
   for (const [layer, patterns] of Object.entries(LAYER_PATTERNS)) {
-    if (parts.some(s => patterns.includes(s))) {
+    if (parts.some(s => patterns.some(p => s.includes(p)))) {
       return layer;
     }
   }
@@ -304,6 +259,9 @@ export function generateFeatures(
     // Extract feature name from path - get the last segment
     const featureName = mod.path.split("/").pop() || moduleName;
     
+    // Skip ignored folders (utils, helpers, types, etc.)
+    if (isIgnoredFolder(featureName)) continue;
+    
     features.push({
       name: featureName,
       path: mod.path,

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);
+  });
+});