ai-first-cli 1.1.1 → 1.1.2

package/tests/adapters.test.ts

@@ -0,0 +1,159 @@
+import { describe, it, expect } from "vitest";
+import {
+  detectAdapter,
+  detectAllAdapters,
+  getAdapter,
+  listAdapters
+} from "../src/core/adapters/index.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+function createTempProjectDir(files: Record<string, string>): string {
+  const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-adapter-test-"));
+  for (const [filePath, content] of Object.entries(files)) {
+    const fullPath = path.join(tempDir, filePath);
+    const dir = path.dirname(fullPath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+    fs.writeFileSync(fullPath, content);
+  }
+  return tempDir;
+}
+
+describe("Adapter System", () => {
+  describe("detectAdapter", () => {
+    it("should detect JavaScript project with package.json", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "src/index.js": "// code"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("javascript");
+    });
+
+    it("should detect TypeScript project with tsconfig.json", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}',
+        "tsconfig.json": '{}'
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("javascript");
+    });
+
+    it("should detect Django project with manage.py", () => {
+      const projectDir = createTempProjectDir({
+        "manage.py": "# django",
+        "settings.py": "DEBUG=True"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("django");
+    });
+
+    it("should detect Flask project with app.py", () => {
+      const projectDir = createTempProjectDir({
+        "app.py": "from flask import Flask"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("flask");
+    });
+
+    it("should detect Rails project with Gemfile", () => {
+      const projectDir = createTempProjectDir({
+        "Gemfile": "source 'https://rubygems.org'",
+        "app/controllers/application_controller.rb": "class ApplicationController"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("rails");
+    });
+
+    it("should detect Salesforce project with sfdx-project.json", () => {
+      const projectDir = createTempProjectDir({
+        "sfdx-project.json": '{"packageDirectories": []}',
+        "force-app/main/default/classes/Test.cls": "public class Test {}"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("salesforce");
+    });
+
+    it("should detect .NET project with .csproj", () => {
+      const projectDir = createTempProjectDir({
+        "test.csproj": "<Project></Project>"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(["dotnet", "aspnetcore", "blazor"]).toContain(adapter.name);
+    });
+
+    it("should detect ASP.NET Core with Startup.cs and Program.cs", () => {
+      const projectDir = createTempProjectDir({
+        "test.csproj": "<Project></Project>",
+        "Startup.cs": "public class Startup {}",
+        "Program.cs": "CreateHostBuilder(args);"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("aspnetcore");
+    });
+
+    it("should return default adapter for unknown project", () => {
+      const projectDir = createTempProjectDir({
+        "README.md": "# Test"
+      });
+      const adapter = detectAdapter(projectDir);
+      expect(adapter.name).toBe("default");
+    });
+  });
+
+  describe("detectAllAdapters", () => {
+    it("should return adapters with confidence scores", () => {
+      const projectDir = createTempProjectDir({
+        "package.json": '{"name": "test"}'
+      });
+      const results = detectAllAdapters(projectDir);
+      expect(results.length).toBeGreaterThan(0);
+      expect(results[0].confidence).toBeGreaterThan(0);
+    });
+  });
+
+  describe("getAdapter", () => {
+    it("should return adapter by name", () => {
+      const adapter = getAdapter("javascript");
+      expect(adapter?.name).toBe("javascript");
+    });
+
+    it("should return undefined for unknown adapter", () => {
+      const adapter = getAdapter("unknown");
+      expect(adapter).toBeUndefined();
+    });
+  });
+
+  describe("listAdapters", () => {
+    it("should list all available adapters", () => {
+      const adapters = listAdapters();
+      expect(adapters.length).toBeGreaterThan(0);
+      expect(adapters.find(a => a.name === "javascript")).toBeDefined();
+      expect(adapters.find(a => a.name === "python")).toBeDefined();
+      expect(adapters.find(a => a.name === "rails")).toBeDefined();
+      expect(adapters.find(a => a.name === "salesforce")).toBeDefined();
+      expect(adapters.find(a => a.name === "dotnet")).toBeDefined();
+    });
+  });
+
+  describe("Adapter Configuration", () => {
+    it("javascript adapter should have correct feature roots", () => {
+      const adapter = getAdapter("javascript");
+      expect(adapter?.featureRoots).toContain("src");
+      expect(adapter?.featureRoots).toContain("app");
+    });
+
+    it("django adapter should detect views", () => {
+      const adapter = getAdapter("django");
+      expect(adapter?.entrypointPatterns).toContain("view");
+    });
+
+    it("salesforce adapter should detect LWC", () => {
+      const adapter = getAdapter("salesforce");
+      expect(adapter?.entrypointPatterns).toContain("LWC");
+    });
+  });
+});

package/tests/gitAnalyzer.test.ts

@@ -0,0 +1,133 @@
+import { describe, it, expect } from "vitest";
+import {
+  detectGitRepository,
+  getRecentCommits,
+  extractChangedFiles,
+  mapFilesToFeatures,
+  mapFilesToFlows,
+  analyzeGitActivity,
+  generateGitContext
+} from "../src/core/gitAnalyzer.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("Git Analyzer", () => {
+  const testRepoRoot = process.cwd();
+
+  describe("detectGitRepository", () => {
+    it("should detect current repository as git repo", () => {
+      expect(detectGitRepository(testRepoRoot)).toBe(true);
+    });
+
+    it("should detect non-git directory", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-git-test-"));
+      expect(detectGitRepository(tempDir)).toBe(false);
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("getRecentCommits", () => {
+    it("should return commits for git repository", () => {
+      const commits = getRecentCommits(testRepoRoot);
+      expect(commits.length).toBeGreaterThan(0);
+      expect(commits[0]).toHaveProperty("hash");
+      expect(commits[0]).toHaveProperty("date");
+      expect(commits[0]).toHaveProperty("message");
+      expect(commits[0]).toHaveProperty("author");
+      expect(commits[0]).toHaveProperty("files");
+    });
+
+    it("should return empty array for non-git directory", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-git-test-"));
+      const commits = getRecentCommits(tempDir);
+      expect(commits).toEqual([]);
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("extractChangedFiles", () => {
+    it("should extract and count changed files", () => {
+      const commits = getRecentCommits(testRepoRoot);
+      const files = extractChangedFiles(commits);
+      
+      expect(files.length).toBeGreaterThan(0);
+      expect(files[0]).toHaveProperty("path");
+      expect(files[0]).toHaveProperty("commitCount");
+      expect(files[0].commitCount).toBeGreaterThan(0);
+    });
+
+    it("should sort by commit count descending", () => {
+      const commits = getRecentCommits(testRepoRoot);
+      const files = extractChangedFiles(commits);
+      
+      for (let i = 1; i < files.length; i++) {
+        expect(files[i - 1].commitCount).toBeGreaterThanOrEqual(files[i].commitCount);
+      }
+    });
+  });
+
+  describe("mapFilesToFeatures", () => {
+    it("should return empty array when no features exist", () => {
+      const features = mapFilesToFeatures(testRepoRoot, ["src/test.ts"]);
+      expect(Array.isArray(features)).toBe(true);
+    });
+  });
+
+  describe("mapFilesToFlows", () => {
+    it("should return empty array when no flows exist", () => {
+      const flows = mapFilesToFlows(testRepoRoot, ["src/test.ts"]);
+      expect(Array.isArray(flows)).toBe(true);
+    });
+  });
+
+  describe("analyzeGitActivity", () => {
+    it("should analyze git activity", () => {
+      const activity = analyzeGitActivity(testRepoRoot);
+      
+      if (activity) {
+        expect(activity).toHaveProperty("totalCommits");
+        expect(activity).toHaveProperty("dateRange");
+        expect(activity).toHaveProperty("files");
+        expect(activity).toHaveProperty("features");
+        expect(activity).toHaveProperty("flows");
+        expect(activity.totalCommits).toBeGreaterThan(0);
+      }
+    });
+
+    it("should return null for non-git directory", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-git-test-"));
+      const activity = analyzeGitActivity(tempDir);
+      expect(activity).toBeNull();
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("generateGitContext", () => {
+    it("should generate output files even for non-git directory", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-git-test-"));
+      const aiDir = path.join(tempDir, "ai");
+      
+      // Create ai directory structure
+      fs.mkdirSync(path.join(aiDir, "context", "features"), { recursive: true });
+      fs.mkdirSync(path.join(aiDir, "context", "flows"), { recursive: true });
+      
+      const result = generateGitContext(tempDir, aiDir);
+      
+      expect(result).toHaveProperty("recentFiles");
+      expect(result).toHaveProperty("recentFeatures");
+      expect(result).toHaveProperty("recentFlows");
+      expect(result).toHaveProperty("activity");
+      expect(result.recentFiles).toEqual([]);
+      expect(result.activity).toBeNull();
+      
+      // Output files should still be created
+      expect(fs.existsSync(path.join(aiDir, "git", "recent-files.json"))).toBe(true);
+      expect(fs.existsSync(path.join(aiDir, "git", "recent-features.json"))).toBe(true);
+      expect(fs.existsSync(path.join(aiDir, "git", "recent-flows.json"))).toBe(true);
+      
+      // Cleanup
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+});

package/tests/incrementalAnalyzer.test.ts

@@ -0,0 +1,83 @@
+import { describe, it, expect } from "vitest";
+import {
+  detectChangedFiles,
+  updateFeatures,
+  updateFlows,
+  updateKnowledgeGraph,
+  runIncrementalUpdate,
+  ChangedFile
+} from "../src/core/incrementalAnalyzer.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("Incremental Analyzer", () => {
+  const testRoot = process.cwd();
+
+  describe("detectChangedFiles", () => {
+    it("should detect changes in git repository", () => {
+      const changes = detectChangedFiles(testRoot);
+      expect(Array.isArray(changes)).toBe(true);
+    });
+
+    it("should return empty array for non-git with no state", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-incr-test-"));
+      const changes = detectChangedFiles(tempDir, false);
+      expect(changes).toEqual([]);
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("runIncrementalUpdate", () => {
+    it("should return error for non-existent ai directory", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-incr-test-"));
+      const result = runIncrementalUpdate(tempDir);
+      expect(result.errors.length).toBeGreaterThan(0);
+      fs.rmSync(tempDir, { recursive: true });
+    });
+
+    it("should handle changes gracefully", () => {
+      const aiDir = path.join(testRoot, "ai");
+      const result = runIncrementalUpdate(testRoot, aiDir);
+      expect(result).toHaveProperty("changedFiles");
+      expect(result).toHaveProperty("updatedSymbols");
+      expect(result).toHaveProperty("graphUpdated");
+    });
+  });
+
+  describe("updateKnowledgeGraph", () => {
+    it("should update knowledge graph", () => {
+      const aiDir = path.join(testRoot, "ai");
+      const updated = updateKnowledgeGraph(testRoot, aiDir);
+      expect(typeof updated).toBe("boolean");
+    });
+  });
+
+  describe("updateFeatures", () => {
+    it("should return empty array when no features dir", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-incr-test-"));
+      const aiDir = path.join(tempDir, "ai");
+      fs.mkdirSync(path.join(aiDir, "context"), { recursive: true });
+      
+      const changes: ChangedFile[] = [];
+      const result = updateFeatures(tempDir, changes, aiDir);
+      expect(result).toEqual([]);
+      
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("updateFlows", () => {
+    it("should return empty array when no flows dir", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-incr-test-"));
+      const aiDir = path.join(tempDir, "ai");
+      fs.mkdirSync(path.join(aiDir, "context"), { recursive: true });
+      
+      const changes: ChangedFile[] = [];
+      const result = updateFlows(tempDir, changes, aiDir);
+      expect(result).toEqual([]);
+      
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+});

package/tests/knowledgeGraph.test.ts

@@ -0,0 +1,146 @@
+import { describe, it, expect } from "vitest";
+import {
+  createNodes,
+  createEdges,
+  buildKnowledgeGraph,
+  loadKnowledgeGraph,
+  getNodesByType,
+  getEdgesByType,
+  getNeighbors
+} from "../src/core/knowledgeGraphBuilder.js";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+describe("Knowledge Graph Builder", () => {
+  const testRoot = process.cwd();
+  const testAiDir = path.join(testRoot, "ai");
+
+  describe("createNodes", () => {
+    it("should create nodes from ai directory", () => {
+      const nodes = createNodes(testAiDir);
+      expect(nodes.length).toBeGreaterThan(0);
+      expect(nodes[0]).toHaveProperty("id");
+      expect(nodes[0]).toHaveProperty("type");
+    });
+  });
+
+  describe("createEdges", () => {
+    it("should create edges from ai directory", () => {
+      const edges = createEdges(testAiDir);
+      expect(edges.length).toBeGreaterThan(0);
+      expect(edges[0]).toHaveProperty("from");
+      expect(edges[0]).toHaveProperty("to");
+      expect(edges[0]).toHaveProperty("type");
+    });
+
+    it("should create valid edge types", () => {
+      const edges = createEdges(testAiDir);
+      const validTypes = ["contains", "implements", "declares", "references", "modifies"];
+      for (const edge of edges) {
+        expect(validTypes).toContain(edge.type);
+      }
+    });
+  });
+
+  describe("buildKnowledgeGraph", () => {
+    it("should build and save knowledge graph with data", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-graph-test-"));
+      const aiDir = path.join(tempDir, "ai");
+      fs.mkdirSync(path.join(aiDir, "graph"), { recursive: true });
+      fs.mkdirSync(path.join(aiDir, "git"), { recursive: true });
+      
+      fs.writeFileSync(path.join(aiDir, "git", "commit-activity.json"), JSON.stringify({
+        totalCommits: 10,
+        dateRange: { start: "2026-01-01", end: "2026-03-11" },
+        files: { "src/test.ts": 5, "src/index.ts": 3 }
+      }));
+      
+      fs.writeFileSync(path.join(aiDir, "files.json"), JSON.stringify(["src/test.ts", "src/index.ts"]));
+      
+      const graph = buildKnowledgeGraph(tempDir, aiDir);
+      
+      expect(graph.nodes.length).toBeGreaterThan(0);
+      expect(graph.edges.length).toBeGreaterThan(0);
+      expect(graph.metadata).toHaveProperty("generated");
+      expect(graph.metadata).toHaveProperty("sources");
+      expect(graph.metadata).toHaveProperty("nodeCount");
+      expect(graph.metadata).toHaveProperty("edgeCount");
+      
+      expect(fs.existsSync(path.join(aiDir, "graph", "knowledge-graph.json"))).toBe(true);
+      
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("loadKnowledgeGraph", () => {
+    it("should load existing knowledge graph", () => {
+      const graph = loadKnowledgeGraph(testAiDir);
+      if (graph) {
+        expect(graph.nodes).toBeDefined();
+        expect(graph.edges).toBeDefined();
+        expect(graph.metadata).toBeDefined();
+      }
+    });
+
+    it("should return null for non-existent graph", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-graph-test-"));
+      const aiDir = path.join(tempDir, "ai");
+      
+      const graph = loadKnowledgeGraph(aiDir);
+      expect(graph).toBeNull();
+      
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+
+  describe("getNodesByType", () => {
+    it("should filter nodes by type", () => {
+      const graph = loadKnowledgeGraph(testAiDir);
+      if (graph) {
+        const commitNodes = getNodesByType(graph, "commit");
+        for (const node of commitNodes) {
+          expect(node.type).toBe("commit");
+        }
+      }
+    });
+  });
+
+  describe("getEdgesByType", () => {
+    it("should filter edges by type", () => {
+      const graph = loadKnowledgeGraph(testAiDir);
+      if (graph) {
+        const modifiesEdges = getEdgesByType(graph, "modifies");
+        for (const edge of modifiesEdges) {
+          expect(edge.type).toBe("modifies");
+        }
+      }
+    });
+  });
+
+  describe("getNeighbors", () => {
+    it("should find neighboring nodes", () => {
+      const tempDir = fs.mkdtempSync(path.join(os.tmpdir(), "ai-first-graph-test-"));
+      const aiDir = path.join(tempDir, "ai");
+      fs.mkdirSync(path.join(aiDir, "graph"), { recursive: true });
+      fs.mkdirSync(path.join(aiDir, "git"), { recursive: true });
+      
+      fs.writeFileSync(path.join(aiDir, "git", "commit-activity.json"), JSON.stringify({
+        totalCommits: 10,
+        dateRange: { start: "2026-01-01", end: "2026-03-11" },
+        files: { "src/test.ts": 5 }
+      }));
+      fs.writeFileSync(path.join(aiDir, "files.json"), JSON.stringify(["src/test.ts"]));
+      
+      const graph = buildKnowledgeGraph(tempDir, aiDir);
+      
+      if (graph.nodes.length > 0) {
+        const firstNode = graph.nodes[0].id;
+        const neighbors = getNeighbors(graph, firstNode);
+        expect(Array.isArray(neighbors)).toBe(true);
+      }
+      
+      fs.rmSync(tempDir, { recursive: true });
+    });
+  });
+});