ai-first-cli 1.2.2 → 1.3.0

package/tests/generation.test.ts

@@ -0,0 +1,216 @@
+import { describe, it, expect } from "vitest";
+import {
+  aiContextGenerator,
+  flowGenerator,
+  architectureGenerator,
+} from "../src/core/generation/index.js";
+
+describe("AI Context Generator", () => {
+  it("should generate enriched context", () => {
+    const analysis = {
+      architecture: {
+        primary: {
+          name: "Layered Architecture",
+          confidence: 0.85,
+          evidence: ["Found 3 layers", "Clear separation of concerns"],
+        },
+        secondary: [],
+        layers: [
+          {
+            name: "API",
+            symbols: ["src/controller.ts#UserController"],
+            files: ["src/controller.ts"],
+            responsibility: "Handle HTTP requests",
+          },
+          {
+            name: "Service",
+            symbols: ["src/service.ts#UserService"],
+            files: ["src/service.ts"],
+            responsibility: "Business logic",
+          },
+        ],
+        entryPoints: ["src/main.ts#main"],
+      },
+      symbols: [
+        { id: "src/controller.ts#UserController", name: "UserController", type: "class", file: "src/controller.ts" },
+        { id: "src/service.ts#UserService", name: "UserService", type: "class", file: "src/service.ts" },
+        { id: "src/main.ts#main", name: "main", type: "function", file: "src/main.ts" },
+      ],
+      dependencies: {
+        totalDependencies: 10,
+        dependencies: [
+          { source: "src/controller.ts", target: "src/service.ts", type: "import" },
+        ],
+      },
+      projectName: "TestApp",
+    };
+
+    const context = aiContextGenerator.generate(analysis);
+
+    expect(context).toContain("# AI Context: TestApp");
+    expect(context).toContain("Layered Architecture");
+    expect(context).toContain("85%");
+    expect(context).toContain("API");
+    expect(context).toContain("Service");
+    expect(context).toContain("main");
+    expect(context).toContain("Total Files");
+    expect(context).toContain("Total Symbols");
+  });
+
+  it("should detect project type", () => {
+    const analysis = {
+      architecture: {
+        primary: null,
+        secondary: [],
+        layers: [],
+        entryPoints: [],
+      },
+      symbols: [
+        { id: "src/controller.ts#Test", name: "Test", type: "class", file: "src/controller.ts" },
+      ],
+      dependencies: { totalDependencies: 0, dependencies: [] },
+      projectName: "Test",
+    };
+
+    const context = aiContextGenerator.generate(analysis);
+
+    expect(context).toContain("MVC Web Application");
+  });
+});
+
+describe("Flow Generator", () => {
+  it("should generate enriched flows", () => {
+    const entryPoints = ["src/auth.ts#login"];
+    const symbols = [
+      { id: "src/auth.ts#login", name: "login", type: "function", file: "src/auth.ts" },
+      { id: "src/service.ts#validate", name: "validate", type: "function", file: "src/service.ts" },
+    ];
+    const dependencyGraph = {
+      edges: [{ from: "src/auth.ts#login", to: "src/service.ts#validate", type: "import" }],
+    };
+    const callGraph = {
+      edges: [{ caller: "src/auth.ts#login", callee: "src/service.ts#validate" }],
+    };
+    const inheritanceGraph = { edges: [] };
+
+    const flows = flowGenerator.generateFlows(
+      entryPoints,
+      symbols,
+      dependencyGraph,
+      callGraph,
+      inheritanceGraph
+    );
+
+    expect(flows).toHaveLength(1);
+    expect(flows[0].name).toBe("login");
+    expect(flows[0].type).toBe("API Endpoint");
+    expect(flows[0].files).toHaveLength(2);
+    expect(flows[0].dependencies.calls).toContain("src/service.ts#validate");
+  });
+
+  it("should detect layers in flow", () => {
+    const entryPoints = ["src/controller.ts#getUser"];
+    const symbols = [
+      { id: "src/controller.ts#getUser", name: "getUser", type: "function", file: "src/controller.ts" },
+      { id: "src/service.ts#findUser", name: "findUser", type: "function", file: "src/service.ts" },
+    ];
+
+    const callGraph = {
+      edges: [{ caller: "src/controller.ts#getUser", callee: "src/service.ts#findUser" }],
+    };
+
+    const flows = flowGenerator.generateFlows(
+      entryPoints,
+      symbols,
+      { edges: [] },
+      callGraph,
+      { edges: [] }
+    );
+
+    expect(flows[0].layers).toContain("api");
+    expect(flows[0].layers).toContain("service");
+  });
+
+  it("should calculate complexity", () => {
+    const entryPoints = ["src/simple.ts#simple"];
+    const symbols = [{ id: "src/simple.ts#simple", name: "simple", type: "function", file: "src/simple.ts" }];
+
+    const flows = flowGenerator.generateFlows(
+      entryPoints,
+      symbols,
+      { edges: [] },
+      { edges: [] },
+      { edges: [] }
+    );
+
+    expect(flows[0].complexity).toBe("low");
+    expect(flows[0].depth).toBe(1);
+  });
+});
+
+describe("Architecture Generator", () => {
+  it("should generate architecture markdown", () => {
+    const analysis = {
+      primary: {
+        name: "MVC",
+        confidence: 0.9,
+        evidence: ["Found controllers", "Found models"],
+      },
+      secondary: [],
+      layers: [
+        { name: "Controller", symbols: ["ctrl1", "ctrl2"], files: ["ctrl.ts"], responsibility: "Handle requests" },
+        { name: "Model", symbols: ["model1"], files: ["model.ts"], responsibility: "Data" },
+      ],
+      entryPoints: ["main"],
+    };
+
+    const dependencyGraph = {
+      nodes: ["ctrl1", "model1"],
+      edges: [{ from: "ctrl1", to: "model1", type: "import" }],
+    };
+
+    const markdown = architectureGenerator.generate(analysis, dependencyGraph);
+
+    expect(markdown).toContain("# Architecture");
+    expect(markdown).toContain("MVC");
+    expect(markdown).toContain("90%");
+    expect(markdown).toContain("Controller");
+    expect(markdown).toContain("Model");
+    expect(markdown).toContain("Architecture Diagram");
+    expect(markdown).toContain("mermaid");
+  });
+
+  it("should generate mermaid diagram", () => {
+    const analysis = {
+      primary: { name: "Layered", confidence: 0.8, evidence: [] },
+      secondary: [],
+      layers: [{ name: "API", symbols: ["api1"], files: ["api.ts"], responsibility: "" }],
+      entryPoints: [],
+    };
+
+    const dependencyGraph = {
+      nodes: ["api1", "svc1"],
+      edges: [{ from: "api1", to: "svc1", type: "import" }],
+    };
+
+    const markdown = architectureGenerator.generate(analysis, dependencyGraph);
+
+    expect(markdown).toContain("graph TD");
+    expect(markdown).toContain("api1");
+    expect(markdown).toContain("svc1");
+  });
+
+  it("should handle unknown patterns", () => {
+    const analysis = {
+      primary: null,
+      secondary: [],
+      layers: [],
+      entryPoints: [],
+    };
+
+    const markdown = architectureGenerator.generate(analysis, { nodes: [], edges: [] });
+
+    expect(markdown).toContain("Unknown");
+    expect(markdown).toContain("No strong pattern detected");
+  });
+});

package/tests/parserRegistry.test.ts

@@ -0,0 +1,139 @@
+import { describe, it, expect } from "vitest";
+import { parserRegistry, createSymbolFromParsed } from "../src/core/parsers/index.js";
+
+describe("Parser Registry", () => {
+  it("should return TypeScript parser for .ts files", () => {
+    const parser = parserRegistry.getParser(".ts");
+    expect(parser).toBeDefined();
+  });
+
+  it("should return TypeScript parser for .tsx files", () => {
+    const parser = parserRegistry.getParser(".tsx");
+    expect(parser).toBeDefined();
+  });
+
+  it("should return TypeScript parser for .js files", () => {
+    const parser = parserRegistry.getParser(".js");
+    expect(parser).toBeDefined();
+  });
+
+  it("should return Python parser for .py files", () => {
+    const parser = parserRegistry.getParser(".py");
+    expect(parser).toBeDefined();
+  });
+
+  it("should return undefined for unsupported extensions", () => {
+    const parser = parserRegistry.getParser(".unknown");
+    expect(parser).toBeUndefined();
+  });
+
+  it("should be case insensitive", () => {
+    const parserLower = parserRegistry.getParser(".ts");
+    const parserUpper = parserRegistry.getParser(".TS");
+    expect(parserLower).toBe(parserUpper);
+  });
+
+  it("should check if parser exists", () => {
+    expect(parserRegistry.hasParser(".ts")).toBe(true);
+    expect(parserRegistry.hasParser(".py")).toBe(true);
+    expect(parserRegistry.hasParser(".unknown")).toBe(false);
+  });
+
+  it("should return list of supported extensions", () => {
+    const extensions = parserRegistry.getSupportedExtensions();
+    expect(extensions).toContain(".ts");
+    expect(extensions).toContain(".tsx");
+    expect(extensions).toContain(".js");
+    expect(extensions).toContain(".py");
+  });
+
+  it("should parse TypeScript file", () => {
+    const source = `
+      export class UserService {
+        async findById(id: string) {
+          return null;
+        }
+      }
+    `;
+
+    const result = parserRegistry.parse("test.ts", source);
+    expect(result).toBeDefined();
+    expect(result?.symbols).toHaveLength(1);
+    expect(result?.symbols[0].name).toBe("UserService");
+  });
+
+  it("should parse Python file", () => {
+    const source = `
+class UserService:
+    def find_by_id(self, id):
+        return None
+`;
+
+    const result = parserRegistry.parse("test.py", source);
+    expect(result).toBeDefined();
+    expect(result?.symbols).toHaveLength(1);
+    expect(result?.symbols[0].name).toBe("UserService");
+  });
+
+  it("should return null for unsupported files", () => {
+    const result = parserRegistry.parse("test.unknown", "content");
+    expect(result).toBeNull();
+  });
+
+  it("should create symbols from parsed TypeScript", () => {
+    const source = `
+      export class UserService {
+        async findById(id: string): Promise<User | null> {
+          return null;
+        }
+      }
+      
+      export interface User {
+        id: string;
+        name: string;
+      }
+    `;
+
+    const parsed = parserRegistry.parse("test.ts", source);
+    expect(parsed).toBeDefined();
+
+    const symbols = createSymbolFromParsed(parsed!, "test.ts");
+    
+    expect(symbols.length).toBeGreaterThanOrEqual(2);
+    
+    const userService = symbols.find(s => s.name === "UserService");
+    expect(userService).toBeDefined();
+    expect(userService?.type).toBe("class");
+    expect(userService?.export).toBe(true);
+    
+    const userInterface = symbols.find(s => s.name === "User");
+    expect(userInterface).toBeDefined();
+    expect(userInterface?.type).toBe("interface");
+  });
+
+  it("should create symbols from parsed Python", () => {
+    const source = `
+class UserService:
+    def find_by_id(self, id: str):
+        return None
+
+def helper_function():
+    pass
+`;
+
+    const parsed = parserRegistry.parse("test.py", source);
+    expect(parsed).toBeDefined();
+
+    const symbols = createSymbolFromParsed(parsed!, "test.py");
+    
+    expect(symbols.length).toBeGreaterThanOrEqual(2);
+    
+    const userService = symbols.find(s => s.name === "UserService");
+    expect(userService).toBeDefined();
+    expect(userService?.type).toBe("class");
+    
+    const helperFunc = symbols.find(s => s.name === "helper_function");
+    expect(helperFunc).toBeDefined();
+    expect(helperFunc?.type).toBe("function");
+  });
+});

package/tests/pipeline.integration.test.ts

@@ -0,0 +1,245 @@
+import { describe, it, expect, beforeEach } from "vitest";
+import { AnalysisPipeline } from "../src/core/pipeline";
+import type { FileInfo } from "../src/core/repoScanner";
+
+describe("AnalysisPipeline Integration", () => {
+  let pipeline: AnalysisPipeline;
+
+  beforeEach(() => {
+    pipeline = new AnalysisPipeline();
+  });
+
+  it("should analyze TypeScript files with AST parser", async () => {
+    const files: FileInfo[] = [
+      {
+        path: "/project/src/user.ts",
+        relativePath: "src/user.ts",
+        name: "user.ts",
+        extension: "ts",
+      },
+    ];
+
+    const content = `
+      export class User {
+        name: string;
+        constructor(name: string) {
+          this.name = name;
+        }
+      }
+      
+      export function createUser(name: string): User {
+        return new User(name);
+      }
+      
+      export interface IUser {
+        name: string;
+      }
+      
+      export type UserId = string;
+    `;
+
+    const fs = await import("node:fs");
+    const tempFile = "/tmp/test-user.ts";
+    fs.writeFileSync(tempFile, content);
+
+    files[0].path = tempFile;
+
+    const result = await pipeline.run(files, "TestProject");
+
+    expect(result.symbols.symbols.length).toBeGreaterThan(0);
+    expect(result.symbols.symbols.some(s => s.name === "User" && s.type === "class")).toBe(true);
+    expect(result.symbols.symbols.some(s => s.name === "createUser" && s.type === "function")).toBe(true);
+    expect(result.symbols.symbols.some(s => s.name === "IUser" && s.type === "interface")).toBe(true);
+    expect(result.symbols.symbols.some(s => s.name === "UserId" && s.type === "type")).toBe(true);
+    
+    expect(result.metrics.duration).toBeGreaterThan(0);
+    expect(result.metrics.filesProcessed).toBe(1);
+
+    fs.unlinkSync(tempFile);
+  });
+
+  it("should detect architecture pattern", async () => {
+    const files: FileInfo[] = [
+      {
+        path: "/project/src/controllers/userController.ts",
+        relativePath: "src/controllers/userController.ts",
+        name: "userController.ts",
+        extension: "ts",
+      },
+      {
+        path: "/project/src/services/userService.ts",
+        relativePath: "src/services/userService.ts",
+        name: "userService.ts",
+        extension: "ts",
+      },
+      {
+        path: "/project/src/repositories/userRepository.ts",
+        relativePath: "src/repositories/userRepository.ts",
+        name: "userRepository.ts",
+        extension: "ts",
+      },
+    ];
+
+    const controllerContent = `
+      export class UserController {
+        constructor(private userService: UserService) {}
+        async getUser(id: string) {
+          return this.userService.findById(id);
+        }
+      }
+    `;
+
+    const serviceContent = `
+      export class UserService {
+        constructor(private userRepo: UserRepository) {}
+        async findById(id: string) {
+          return this.userRepo.findOne(id);
+        }
+      }
+    `;
+
+    const repoContent = `
+      export class UserRepository {
+        async findOne(id: string) {
+          return { id, name: "Test" };
+        }
+      }
+    `;
+
+    const fs = await import("node:fs");
+    const filesWithContent = [
+      { path: "/tmp/test-controller.ts", content: controllerContent },
+      { path: "/tmp/test-service.ts", content: serviceContent },
+      { path: "/tmp/test-repo.ts", content: repoContent },
+    ];
+
+    filesWithContent.forEach(({ path, content }) => {
+      fs.writeFileSync(path, content);
+    });
+
+    files[0].path = "/tmp/test-controller.ts";
+    files[1].path = "/tmp/test-service.ts";
+    files[2].path = "/tmp/test-repo.ts";
+
+    const result = await pipeline.run(files, "TestProject");
+
+    expect(result.architecture.primary !== null || result.architecture.secondary.length > 0).toBe(true);
+    expect(result.architecture.layers.length).toBeGreaterThan(0);
+    expect(result.metrics.filesProcessed).toBe(3);
+
+    filesWithContent.forEach(({ path }) => {
+      fs.unlinkSync(path);
+    });
+  });
+
+  it("should generate AI context", async () => {
+    const files: FileInfo[] = [
+      {
+        path: "/project/src/auth.ts",
+        relativePath: "src/auth.ts",
+        name: "auth.ts",
+        extension: "ts",
+      },
+    ];
+
+    const content = `
+      export function authenticate(token: string): boolean {
+        return token.length > 0;
+      }
+      
+      export class AuthMiddleware {
+        handle(req: any, res: any, next: any) {
+          next();
+        }
+      }
+    `;
+
+    const fs = await import("node:fs");
+    fs.writeFileSync("/tmp/test-auth.ts", content);
+    files[0].path = "/tmp/test-auth.ts";
+
+    const result = await pipeline.run(files, "AuthService");
+
+    expect(result.aiContext).toContain("AuthService");
+    expect(result.aiContext.length).toBeGreaterThan(100);
+    expect(result.architectureDoc.length).toBeGreaterThan(0);
+
+    fs.unlinkSync("/tmp/test-auth.ts");
+  });
+
+  it("should cache and clear cache correctly", async () => {
+    const pipeline = new AnalysisPipeline();
+    
+    expect(pipeline.getMetrics().cacheSize).toBe(0);
+    
+    pipeline.clearCache();
+    expect(pipeline.getMetrics().cacheSize).toBe(0);
+  });
+
+  it("should handle empty file list", async () => {
+    const result = await pipeline.run([], "EmptyProject");
+
+    expect(result.symbols.symbols).toEqual([]);
+    expect(result.metrics.filesProcessed).toBe(0);
+    expect(result.metrics.duration).toBeGreaterThanOrEqual(0);
+  });
+
+  it("should handle unsupported file types gracefully", async () => {
+    const files: FileInfo[] = [
+      {
+        path: "/project/readme.md",
+        relativePath: "readme.md",
+        name: "readme.md",
+        extension: "md",
+      },
+      {
+        path: "/project/config.yaml",
+        relativePath: "config.yaml",
+        name: "config.yaml",
+        extension: "yaml",
+      },
+    ];
+
+    const result = await pipeline.run(files, "MixedProject");
+
+    expect(result.metrics.filesProcessed).toBe(2);
+    expect(result.symbols.symbols.length).toBe(0);
+  });
+
+  it("should generate dependency graph", async () => {
+    const files: FileInfo[] = [
+      {
+        path: "/project/src/app.ts",
+        relativePath: "src/app.ts",
+        name: "app.ts",
+        extension: "ts",
+      },
+    ];
+
+    const content = `
+      import { UserService } from './services/userService';
+      import { Config } from './config';
+      
+      export class App {
+        constructor(private userService: UserService) {}
+        start() {
+          console.log('Starting...');
+        }
+      }
+      
+      export const app = new App();
+    `;
+
+    const fs = await import("node:fs");
+    fs.writeFileSync("/tmp/test-app.ts", content);
+    files[0].path = "/tmp/test-app.ts";
+
+    const result = await pipeline.run(files, "TestApp");
+
+    expect(result.dependencyGraph).toBeDefined();
+    expect(result.dependencyGraph.edges).toBeDefined();
+    expect(result.dependencyGraph.nodes).toBeDefined();
+
+    fs.unlinkSync("/tmp/test-app.ts");
+  });
+});