ai-spec-dev 0.37.0 → 0.41.0

package/tests/project-index.test.ts

@@ -0,0 +1,206 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import * as fs from "fs-extra";
+import * as path from "path";
+import * as os from "os";
+import {
+  INDEX_FILE,
+  loadIndex,
+  saveIndex,
+  runScan,
+} from "../core/project-index";
+
+describe("loadIndex / saveIndex", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `pi-io-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("loadIndex returns null when no file exists", async () => {
+    expect(await loadIndex(tmpDir)).toBeNull();
+  });
+
+  it("saveIndex writes and loadIndex reads back", async () => {
+    const index = {
+      scanRoot: tmpDir,
+      lastScanned: new Date().toISOString(),
+      projects: [],
+    };
+    const filePath = await saveIndex(tmpDir, index);
+    expect(filePath).toBe(path.join(tmpDir, INDEX_FILE));
+
+    const loaded = await loadIndex(tmpDir);
+    expect(loaded).not.toBeNull();
+    expect(loaded!.scanRoot).toBe(tmpDir);
+  });
+});
+
+describe("runScan", () => {
+  let tmpDir: string;
+
+  beforeEach(async () => {
+    tmpDir = path.join(os.tmpdir(), `pi-scan-${Date.now()}`);
+    await fs.ensureDir(tmpDir);
+  });
+
+  afterEach(async () => {
+    await fs.remove(tmpDir);
+  });
+
+  it("discovers a Node.js project", async () => {
+    const projectDir = path.join(tmpDir, "my-app");
+    await fs.ensureDir(projectDir);
+    await fs.writeJson(path.join(projectDir, "package.json"), {
+      dependencies: { express: "4.0.0" },
+    });
+
+    const result = await runScan(tmpDir);
+    expect(result.added).toHaveLength(1);
+    expect(result.added[0].name).toBe("my-app");
+    expect(result.added[0].type).toBe("node-express");
+    expect(result.added[0].role).toBe("backend");
+    expect(result.added[0].techStack).toContain("express");
+  });
+
+  it("discovers a Go project", async () => {
+    const projectDir = path.join(tmpDir, "go-svc");
+    await fs.ensureDir(projectDir);
+    await fs.writeFile(path.join(projectDir, "go.mod"), "module example.com/go-svc");
+
+    const result = await runScan(tmpDir);
+    expect(result.added).toHaveLength(1);
+    expect(result.added[0].type).toBe("go");
+    expect(result.added[0].techStack).toContain("go");
+  });
+
+  it("skips node_modules and hidden directories", async () => {
+    await fs.ensureDir(path.join(tmpDir, "node_modules", "pkg"));
+    await fs.writeJson(path.join(tmpDir, "node_modules", "pkg", "package.json"), {});
+    await fs.ensureDir(path.join(tmpDir, ".hidden"));
+    await fs.writeJson(path.join(tmpDir, ".hidden", "package.json"), {});
+
+    const result = await runScan(tmpDir);
+    expect(result.added).toHaveLength(0);
+  });
+
+  it("detects hasConstitution flag", async () => {
+    const projectDir = path.join(tmpDir, "app");
+    await fs.ensureDir(projectDir);
+    await fs.writeJson(path.join(projectDir, "package.json"), {});
+    await fs.writeFile(path.join(projectDir, ".ai-spec-constitution.md"), "rules");
+
+    const result = await runScan(tmpDir);
+    expect(result.added[0].hasConstitution).toBe(true);
+  });
+
+  it("detects hasWorkspace flag", async () => {
+    const projectDir = path.join(tmpDir, "mono");
+    await fs.ensureDir(projectDir);
+    await fs.writeJson(path.join(projectDir, "package.json"), {});
+    await fs.writeJson(path.join(projectDir, ".ai-spec-workspace.json"), { name: "ws", repos: [] });
+
+    const result = await runScan(tmpDir);
+    expect(result.added[0].hasWorkspace).toBe(true);
+  });
+
+  it("incremental scan: new project → added", async () => {
+    // First scan
+    const p1 = path.join(tmpDir, "app1");
+    await fs.ensureDir(p1);
+    await fs.writeJson(path.join(p1, "package.json"), {});
+    const r1 = await runScan(tmpDir);
+    await saveIndex(tmpDir, r1.index);
+
+    // Add new project
+    const p2 = path.join(tmpDir, "app2");
+    await fs.ensureDir(p2);
+    await fs.writeJson(path.join(p2, "package.json"), {});
+
+    const r2 = await runScan(tmpDir);
+    expect(r2.added).toHaveLength(1);
+    expect(r2.added[0].name).toBe("app2");
+    expect(r2.unchanged).toHaveLength(1);
+  });
+
+  it("incremental scan: removed project → nowMissing", async () => {
+    const p1 = path.join(tmpDir, "app1");
+    await fs.ensureDir(p1);
+    await fs.writeJson(path.join(p1, "package.json"), {});
+    const r1 = await runScan(tmpDir);
+    await saveIndex(tmpDir, r1.index);
+
+    // Remove project
+    await fs.remove(p1);
+    const r2 = await runScan(tmpDir);
+    expect(r2.nowMissing).toHaveLength(1);
+    expect(r2.nowMissing[0].name).toBe("app1");
+    expect(r2.nowMissing[0].missing).toBe(true);
+  });
+
+  it("incremental scan: changed type → updated", async () => {
+    const p1 = path.join(tmpDir, "app");
+    await fs.ensureDir(p1);
+    await fs.writeJson(path.join(p1, "package.json"), {});
+    const r1 = await runScan(tmpDir);
+    await saveIndex(tmpDir, r1.index);
+
+    // Add express → changes type from unknown to node-express
+    await fs.writeJson(path.join(p1, "package.json"), {
+      dependencies: { express: "4.0.0" },
+    });
+    const r2 = await runScan(tmpDir);
+    expect(r2.updated).toHaveLength(1);
+    expect(r2.updated[0].type).toBe("node-express");
+  });
+
+  it("respects maxDepth", async () => {
+    // depth 0
+    const d1 = path.join(tmpDir, "level1");
+    await fs.ensureDir(d1);
+    // depth 1
+    const d2 = path.join(d1, "level2");
+    await fs.ensureDir(d2);
+    // depth 2
+    const d3 = path.join(d2, "level3");
+    await fs.ensureDir(d3);
+    await fs.writeJson(path.join(d3, "package.json"), {});
+
+    // With maxDepth=1, should NOT find level3
+    const r1 = await runScan(tmpDir, 1);
+    expect(r1.added).toHaveLength(0);
+
+    // With maxDepth=3, should find it
+    const r2 = await runScan(tmpDir, 3);
+    expect(r2.added).toHaveLength(1);
+  });
+
+  it("projects are sorted by path", async () => {
+    for (const name of ["charlie", "alpha", "bravo"]) {
+      await fs.ensureDir(path.join(tmpDir, name));
+      await fs.writeJson(path.join(tmpDir, name, "package.json"), {});
+    }
+    const result = await runScan(tmpDir);
+    const names = result.index.projects.map((p) => p.name);
+    expect(names).toEqual(["alpha", "bravo", "charlie"]);
+  });
+
+  it("extracts key dependencies in techStack", async () => {
+    const p = path.join(tmpDir, "app");
+    await fs.ensureDir(p);
+    await fs.writeJson(path.join(p, "package.json"), {
+      dependencies: { express: "4.0.0", prisma: "5.0.0" },
+      devDependencies: { vitest: "2.0.0", typescript: "5.0.0" },
+    });
+    const result = await runScan(tmpDir);
+    const stack = result.added[0].techStack;
+    expect(stack).toContain("express");
+    expect(stack).toContain("prisma");
+    expect(stack).toContain("vitest");
+    expect(stack).toContain("typescript");
+  });
+});

package/tests/prompt-hasher.test.ts

@@ -0,0 +1,19 @@
+import { describe, it, expect } from "vitest";
+import { computePromptHash } from "../core/prompt-hasher";
+
+describe("computePromptHash", () => {
+  it("returns an 8-char hex string", () => {
+    const hash = computePromptHash();
+    expect(hash).toMatch(/^[a-f0-9]{8}$/);
+  });
+
+  it("is deterministic — same prompts produce same hash", () => {
+    const a = computePromptHash();
+    const b = computePromptHash();
+    expect(a).toBe(b);
+  });
+
+  it("is a non-empty string", () => {
+    expect(computePromptHash().length).toBe(8);
+  });
+});

package/tests/requirement-decomposer.test.ts

@@ -0,0 +1,171 @@
+import { describe, it, expect, vi } from "vitest";
+import { RequirementDecomposer } from "../core/requirement-decomposer";
+import type { RepoRequirement } from "../core/requirement-decomposer";
+
+// ─── sortByDependency (pure logic, no AI) ────────────────────────────────────
+
+describe("RequirementDecomposer.sortByDependency", () => {
+  it("puts repos with no dependencies first", () => {
+    const repos: RepoRequirement[] = [
+      { repoName: "web", role: "frontend", specIdea: "UI", isContractProvider: false, dependsOnRepos: ["api"], uxDecisions: null },
+      { repoName: "api", role: "backend", specIdea: "API", isContractProvider: true, dependsOnRepos: [], uxDecisions: null },
+    ];
+    const sorted = RequirementDecomposer.sortByDependency(repos);
+    expect(sorted[0].repoName).toBe("api");
+    expect(sorted[1].repoName).toBe("web");
+  });
+
+  it("handles multiple dependency levels", () => {
+    const repos: RepoRequirement[] = [
+      { repoName: "mobile", role: "mobile", specIdea: "M", isContractProvider: false, dependsOnRepos: ["api"], uxDecisions: null },
+      { repoName: "api", role: "backend", specIdea: "A", isContractProvider: true, dependsOnRepos: ["db"], uxDecisions: null },
+      { repoName: "db", role: "backend", specIdea: "D", isContractProvider: true, dependsOnRepos: [], uxDecisions: null },
+    ];
+    const sorted = RequirementDecomposer.sortByDependency(repos);
+    expect(sorted.map((r) => r.repoName)).toEqual(["db", "api", "mobile"]);
+  });
+
+  it("handles circular dependencies without infinite loop", () => {
+    const repos: RepoRequirement[] = [
+      { repoName: "a", role: "backend", specIdea: "A", isContractProvider: false, dependsOnRepos: ["b"], uxDecisions: null },
+      { repoName: "b", role: "backend", specIdea: "B", isContractProvider: false, dependsOnRepos: ["a"], uxDecisions: null },
+    ];
+    const sorted = RequirementDecomposer.sortByDependency(repos);
+    expect(sorted).toHaveLength(2);
+  });
+
+  it("preserves order for independent repos", () => {
+    const repos: RepoRequirement[] = [
+      { repoName: "x", role: "backend", specIdea: "X", isContractProvider: false, dependsOnRepos: [], uxDecisions: null },
+      { repoName: "y", role: "backend", specIdea: "Y", isContractProvider: false, dependsOnRepos: [], uxDecisions: null },
+    ];
+    const sorted = RequirementDecomposer.sortByDependency(repos);
+    expect(sorted[0].repoName).toBe("x");
+    expect(sorted[1].repoName).toBe("y");
+  });
+
+  it("handles empty array", () => {
+    expect(RequirementDecomposer.sortByDependency([])).toEqual([]);
+  });
+});
+
+// ─── decompose (with AI mock) ────────────────────────────────────────────────
+
+describe("RequirementDecomposer.decompose", () => {
+  const mockProvider = {
+    generate: vi.fn(),
+    providerName: "test",
+    modelName: "test-model",
+  };
+
+  it("parses a valid decomposition response", async () => {
+    mockProvider.generate.mockResolvedValueOnce(JSON.stringify({
+      summary: "Order feature across API and web",
+      coordinationNotes: "Shared types needed",
+      repos: [
+        {
+          repoName: "api",
+          role: "backend",
+          specIdea: "Build order CRUD endpoints",
+          isContractProvider: true,
+          dependsOnRepos: [],
+        },
+        {
+          repoName: "web",
+          role: "frontend",
+          specIdea: "Build order management UI",
+          isContractProvider: false,
+          dependsOnRepos: ["api"],
+          uxDecisions: { optimisticUpdate: true, errorRollback: true, loadingState: true },
+        },
+      ],
+    }));
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    const result = await decomposer.decompose(
+      "Build order system",
+      { name: "ws", repos: [] },
+      new Map()
+    );
+
+    expect(result.summary).toContain("Order");
+    expect(result.repos).toHaveLength(2);
+    expect(result.repos[0].isContractProvider).toBe(true);
+    expect(result.repos[1].uxDecisions?.optimisticUpdate).toBe(true);
+    expect(result.originalRequirement).toBe("Build order system");
+  });
+
+  it("handles fenced JSON in response", async () => {
+    mockProvider.generate.mockResolvedValueOnce(
+      "Here's the decomposition:\n```json\n" +
+      JSON.stringify({
+        summary: "Test",
+        coordinationNotes: "",
+        repos: [{ repoName: "api", role: "backend", specIdea: "Build API", isContractProvider: false, dependsOnRepos: [] }],
+      }) +
+      "\n```"
+    );
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    const result = await decomposer.decompose("test", { name: "ws", repos: [] }, new Map());
+    expect(result.repos).toHaveLength(1);
+  });
+
+  it("throws on invalid JSON response", async () => {
+    mockProvider.generate.mockResolvedValueOnce("not json at all");
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    await expect(
+      decomposer.decompose("test", { name: "ws", repos: [] }, new Map())
+    ).rejects.toThrow("Failed to parse");
+  });
+
+  it("throws on missing summary field", async () => {
+    mockProvider.generate.mockResolvedValueOnce(JSON.stringify({
+      coordinationNotes: "",
+      repos: [{ repoName: "api", specIdea: "x" }],
+    }));
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    await expect(
+      decomposer.decompose("test", { name: "ws", repos: [] }, new Map())
+    ).rejects.toThrow("summary");
+  });
+
+  it("throws on empty repos array", async () => {
+    mockProvider.generate.mockResolvedValueOnce(JSON.stringify({
+      summary: "Test",
+      coordinationNotes: "",
+      repos: [],
+    }));
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    await expect(
+      decomposer.decompose("test", { name: "ws", repos: [] }, new Map())
+    ).rejects.toThrow("non-empty array");
+  });
+
+  it("throws when AI call fails", async () => {
+    mockProvider.generate.mockRejectedValueOnce(new Error("API timeout"));
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    await expect(
+      decomposer.decompose("test", { name: "ws", repos: [] }, new Map())
+    ).rejects.toThrow("AI call for requirement decomposition failed");
+  });
+
+  it("defaults missing fields in repo requirements", async () => {
+    mockProvider.generate.mockResolvedValueOnce(JSON.stringify({
+      summary: "Test",
+      coordinationNotes: "",
+      repos: [{ repoName: "api", specIdea: "Build API" }],
+    }));
+
+    const decomposer = new RequirementDecomposer(mockProvider);
+    const result = await decomposer.decompose("test", { name: "ws", repos: [] }, new Map());
+    expect(result.repos[0].role).toBe("backend"); // default
+    expect(result.repos[0].isContractProvider).toBe(false); // default
+    expect(result.repos[0].dependsOnRepos).toEqual([]); // default
+    expect(result.repos[0].uxDecisions).toBeNull(); // default
+  });
+});

package/tests/reviewer.test.ts

@@ -8,6 +8,7 @@ import type { AIProvider } from "../core/spec-generator";
 import * as fs from "fs-extra";
 import * as path from "path";
 import * as os from "os";
+import { execSync } from "child_process";
 
 // ─── extractComplianceScore ──────────────────────────────────────────────────
 
@@ -103,9 +104,11 @@ describe("CodeReviewer", () => {
     };
   }
 
-  it("returns 'No changes' when git diff is empty (not a git repo)", async () => {
+  it("returns 'No changes' when git diff is empty (isolated git repo)", async () => {
     const provider = makeProvider("review result");
     const consoleSpy = vi.spyOn(console, "log").mockImplementation(() => {});
+    // Create an isolated git repo with no commits/diff
+    execSync("git init", { cwd: tmpDir, stdio: "pipe" });
     const reviewer = new CodeReviewer(provider, tmpDir);
     const result = await reviewer.reviewCode("spec content");
     expect(result).toBe("No changes");