@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/__tests__/auto-bootstrap.test.js

@@ -0,0 +1,280 @@
+/**
+ * Tests for auto-bootstrap and PARSE mode (Task 8.4).
+ */
+import { describe, expect, it } from "vitest";
+import { ParseModeIndex, extractEntitiesFromSource, } from "../proxy/auto-bootstrap.js";
+describe("extractEntitiesFromSource", () => {
+    it("extracts exported functions", () => {
+        const code = `export function handlePayment(amount: number): boolean {
+  return amount > 0
+}`;
+        const entities = extractEntitiesFromSource("src/billing.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.name).toBe("handlePayment");
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.key).toBe("src/billing.ts::handlePayment");
+        expect(entities[0]?.line_start).toBe(1);
+        expect(entities[0]?.signature).toBe("handlePayment(amount: number)");
+    });
+    it("extracts async functions", () => {
+        const code = `export async function fetchUser(id: string) {
+  return db.get(id)
+}`;
+        const entities = extractEntitiesFromSource("src/api.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.name).toBe("fetchUser");
+    });
+    it("extracts arrow functions", () => {
+        const code = `export const validate = (input: string): boolean => {
+  return input.length > 0
+}`;
+        const entities = extractEntitiesFromSource("src/utils.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("function");
+        expect(entities[0]?.name).toBe("validate");
+    });
+    it("extracts classes", () => {
+        const code = `export class PaymentService {
+  process(amount: number) {
+    return amount
+  }
+}`;
+        const entities = extractEntitiesFromSource("src/service.ts", code);
+        expect(entities.length).toBeGreaterThanOrEqual(1);
+        const cls = entities.find((e) => e.kind === "class");
+        expect(cls).toBeDefined();
+        expect(cls?.name).toBe("PaymentService");
+    });
+    it("extracts interfaces", () => {
+        const code = `export interface UserConfig {
+  name: string
+  email: string
+}`;
+        const entities = extractEntitiesFromSource("src/types.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("interface");
+        expect(entities[0]?.name).toBe("UserConfig");
+    });
+    it("extracts type aliases", () => {
+        const code = `export type Status = "active" | "inactive"`;
+        const entities = extractEntitiesFromSource("src/types.ts", code);
+        expect(entities).toHaveLength(1);
+        expect(entities[0]?.kind).toBe("type");
+        expect(entities[0]?.name).toBe("Status");
+    });
+    it("extracts methods inside classes", () => {
+        const code = `export class Router {
+  async execute(name: string) {
+    return name
+  }
+
+  private validate(input: string) {
+    return true
+  }
+}`;
+        const entities = extractEntitiesFromSource("src/router.ts", code);
+        const methods = entities.filter((e) => e.kind === "method");
+        expect(methods.length).toBeGreaterThanOrEqual(2);
+        expect(methods.find((m) => m.name === "Router.execute")).toBeDefined();
+        expect(methods.find((m) => m.name === "Router.validate")).toBeDefined();
+    });
+    it("handles multiple entity types in one file", () => {
+        const code = `export interface Config {
+  key: string
+}
+
+export type Mode = "a" | "b"
+
+export class Service {
+  run() {
+    return true
+  }
+}
+
+export function helper() {
+  return 1
+}`;
+        const entities = extractEntitiesFromSource("src/mixed.ts", code);
+        const kinds = new Set(entities.map((e) => e.kind));
+        expect(kinds.has("interface")).toBe(true);
+        expect(kinds.has("type")).toBe(true);
+        expect(kinds.has("class")).toBe(true);
+        expect(kinds.has("function")).toBe(true);
+    });
+    it("returns empty for empty file", () => {
+        const entities = extractEntitiesFromSource("src/empty.ts", "");
+        expect(entities).toHaveLength(0);
+    });
+    it("does not extract control flow as methods", () => {
+        const code = `export class Foo {
+  bar() {
+    if (true) {
+      for (const x of []) {
+        while (false) {
+          switch (x) {
+            default: break
+          }
+        }
+      }
+    }
+  }
+}`;
+        const entities = extractEntitiesFromSource("src/foo.ts", code);
+        const methods = entities.filter((e) => e.kind === "method");
+        // Should only have 'bar', not 'if', 'for', 'while', 'switch'
+        expect(methods).toHaveLength(1);
+        expect(methods[0]?.name).toBe("Foo.bar");
+    });
+});
+describe("ParseModeIndex", () => {
+    it("indexes and retrieves entities by key", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+            {
+                key: "src/b.ts::Bar",
+                name: "Bar",
+                kind: "class",
+                file_path: "src/b.ts",
+                line_start: 5,
+                signature: "Bar",
+            },
+        ]);
+        expect(index.getEntity("src/a.ts::foo")).toBeDefined();
+        expect(index.getEntity("src/a.ts::foo")?.name).toBe("foo");
+        expect(index.getEntity("nonexistent")).toBeNull();
+    });
+    it("retrieves entities by file", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+            {
+                key: "src/a.ts::bar",
+                name: "bar",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 10,
+                signature: "bar()",
+            },
+            {
+                key: "src/b.ts::Baz",
+                name: "Baz",
+                kind: "class",
+                file_path: "src/b.ts",
+                line_start: 1,
+                signature: "Baz",
+            },
+        ]);
+        expect(index.getEntitiesByFile("src/a.ts")).toHaveLength(2);
+        expect(index.getEntitiesByFile("src/b.ts")).toHaveLength(1);
+        expect(index.getEntitiesByFile("src/c.ts")).toHaveLength(0);
+    });
+    it("searches by name substring", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::handlePayment",
+                name: "handlePayment",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "handlePayment()",
+            },
+            {
+                key: "src/b.ts::processPayment",
+                name: "processPayment",
+                kind: "function",
+                file_path: "src/b.ts",
+                line_start: 1,
+                signature: "processPayment()",
+            },
+            {
+                key: "src/c.ts::getUserName",
+                name: "getUserName",
+                kind: "function",
+                file_path: "src/c.ts",
+                line_start: 1,
+                signature: "getUserName()",
+            },
+        ]);
+        const results = index.search("payment");
+        expect(results).toHaveLength(2);
+    });
+    it("respects search limit", () => {
+        const index = new ParseModeIndex();
+        const entities = Array.from({ length: 20 }, (_, i) => ({
+            key: `src/a.ts::fn${i}`,
+            name: `fn${i}`,
+            kind: "function",
+            file_path: "src/a.ts",
+            line_start: i + 1,
+            signature: `fn${i}()`,
+        }));
+        index.addEntities(entities);
+        expect(index.search("fn", 5)).toHaveLength(5);
+    });
+    it("reports accurate stats", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+            {
+                key: "src/a.ts::bar",
+                name: "bar",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 5,
+                signature: "bar()",
+            },
+            {
+                key: "src/b.ts::Baz",
+                name: "Baz",
+                kind: "class",
+                file_path: "src/b.ts",
+                line_start: 1,
+                signature: "Baz",
+            },
+        ]);
+        const stats = index.getStats();
+        expect(stats.entityCount).toBe(3);
+        expect(stats.fileCount).toBe(2);
+    });
+    it("clears all entities", () => {
+        const index = new ParseModeIndex();
+        index.addEntities([
+            {
+                key: "src/a.ts::foo",
+                name: "foo",
+                kind: "function",
+                file_path: "src/a.ts",
+                line_start: 1,
+                signature: "foo()",
+            },
+        ]);
+        expect(index.getStats().entityCount).toBe(1);
+        index.clear();
+        expect(index.getStats().entityCount).toBe(0);
+        expect(index.getEntity("src/a.ts::foo")).toBeNull();
+    });
+});

package/dist/__tests__/background-indexer.test.js

@@ -0,0 +1,228 @@
+/**
+ * Sprint L11 Tests: Background indexing, partial graph serving, deferred DriftTracker.
+ */
+import { beforeEach, describe, expect, it, vi } from "vitest";
+// ── BackgroundIndexer Tests ─────────────────────────────────────
+// Mock indexLocalProject so we don't need real CozoDB or tree-sitter
+vi.mock("../intelligence/local-indexer.js", () => ({
+    indexLocalProject: vi.fn(async (_projectRoot, _graphStore, _repoId, opts) => {
+        const phases = [
+            "discovering",
+            "extracting",
+            "resolving",
+            "populating",
+            "communities",
+            "search",
+            "snapshot",
+        ];
+        for (let i = 0; i < phases.length; i++) {
+            opts?.onProgress?.({
+                processed: i + 1,
+                total: phases.length,
+                phase: phases[i],
+                currentFile: i === 1 ? "src/index.ts" : null,
+            });
+            // Yield to event loop between phases
+            await new Promise((r) => setTimeout(r, 5));
+        }
+        return {
+            fileCount: 2,
+            entityCount: 5,
+            edgeCount: 3,
+            elapsedMs: 42,
+            communityCount: 1,
+            patternCount: 3,
+            ruleCount: 2,
+        };
+    }),
+}));
+describe("BackgroundIndexer", () => {
+    beforeEach(() => {
+        vi.clearAllMocks();
+    });
+    it("starts in idle state", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        expect(indexer.getStatus()).toBe("idle");
+        expect(indexer.isIndexing()).toBe(false);
+        expect(indexer.isComplete()).toBe(false);
+        expect(indexer.getResult()).toBeNull();
+        expect(indexer.getError()).toBeNull();
+    });
+    it("transitions to indexing state immediately after start()", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, () => { });
+        expect(indexer.getStatus()).toBe("indexing");
+        expect(indexer.isIndexing()).toBe(true);
+        // Wait for completion
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+    });
+    it("reports progress during indexing", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        const progressSnapshots = [];
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, () => { });
+        // Poll progress a few times
+        const pollInterval = setInterval(() => {
+            const p = indexer.getProgress();
+            progressSnapshots.push({
+                processed: p.processed,
+                total: p.total,
+                phase: p.phase,
+            });
+        }, 2);
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        clearInterval(pollInterval);
+        // Should have captured at least one progress snapshot
+        expect(progressSnapshots.length).toBeGreaterThan(0);
+    });
+    it("calls onComplete with IndexResult on success", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        let completedResult = null;
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", (result) => {
+            completedResult = result;
+        }, () => { });
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        expect(completedResult).not.toBeNull();
+        expect(completedResult.fileCount).toBe(2);
+        expect(completedResult.entityCount).toBe(5);
+        expect(completedResult.elapsedMs).toBe(42);
+        // Result should also be accessible via getter
+        const storedResult = indexer.getResult();
+        expect(storedResult).toEqual(completedResult);
+    });
+    it("does not start twice if already indexing", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        let callCount = 0;
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => {
+            callCount++;
+        }, () => { });
+        // Second start should be a no-op
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => {
+            callCount++;
+        }, () => { });
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        // onComplete should have been called exactly once
+        expect(callCount).toBe(1);
+    });
+    it("getElapsedMs returns positive value after completion", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, () => { });
+        await vi.waitFor(() => {
+            expect(indexer.isComplete()).toBe(true);
+        }, { timeout: 5000 });
+        expect(indexer.getElapsedMs()).toBeGreaterThan(0);
+    });
+    it("getState returns full snapshot", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const state = indexer.getState();
+        expect(state.status).toBe("idle");
+        expect(state.progress.processed).toBe(0);
+        expect(state.progress.total).toBe(0);
+        expect(state.progress.pct).toBe(0);
+        expect(state.result).toBeNull();
+        expect(state.error).toBeNull();
+        expect(state.startedAt).toBeNull();
+        expect(state.completedAt).toBeNull();
+    });
+    it("handles indexing errors gracefully", async () => {
+        // Override mock to throw
+        const { indexLocalProject } = await import("../intelligence/local-indexer.js");
+        vi.mocked(indexLocalProject).mockRejectedValueOnce(new Error("tree-sitter init failed"));
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        const indexer = new BackgroundIndexer();
+        const mockGraphStore = {};
+        let errorCaught = null;
+        indexer.start("/tmp/test-project", mockGraphStore, "test-repo", () => { }, (err) => {
+            errorCaught = err;
+        });
+        await vi.waitFor(() => {
+            expect(indexer.getStatus()).toBe("error");
+        }, { timeout: 5000 });
+        expect(errorCaught).not.toBeNull();
+        expect(errorCaught.message).toBe("tree-sitter init failed");
+        expect(indexer.getError()?.message).toBe("tree-sitter init failed");
+        expect(indexer.isComplete()).toBe(false);
+        expect(indexer.isIndexing()).toBe(false);
+    });
+});
+// ── Partial Graph Query Tests ───────────────────────────────────
+describe("QueryRouter partial graph handling", () => {
+    it("returns indexing metadata when backgroundIndexer is active", async () => {
+        const { BackgroundIndexer } = await import("../intelligence/background-indexer.js");
+        // Create a mock indexer that stays in "indexing" state
+        const mockIndexer = new BackgroundIndexer();
+        // Manually set state to "indexing" via Object.assign on private fields
+        Object.assign(mockIndexer, {
+            _status: "indexing",
+            _processed: 150,
+            _total: 500,
+            _phase: "extracting",
+            _currentFile: "src/service.ts",
+            _startedAt: Date.now(),
+        });
+        expect(mockIndexer.isIndexing()).toBe(true);
+        const progress = mockIndexer.getProgress();
+        expect(progress.processed).toBe(150);
+        expect(progress.total).toBe(500);
+        expect(progress.pct).toBe(30);
+        expect(progress.phase).toBe("extracting");
+        expect(progress.currentFile).toBe("src/service.ts");
+    });
+});
+// ── IndexProgressEvent Tests ────────────────────────────────────
+describe("indexLocalProject onProgress callback", () => {
+    it("calls onProgress with phase transitions via mock", async () => {
+        const { indexLocalProject } = await import("../intelligence/local-indexer.js");
+        const phases = [];
+        await indexLocalProject("/tmp/test", {}, "test-repo", {
+            onProgress: (event) => {
+                if (!phases.includes(event.phase)) {
+                    phases.push(event.phase);
+                }
+            },
+        });
+        // Should have gone through all phases (via our mock)
+        expect(phases).toContain("discovering");
+        expect(phases).toContain("extracting");
+        expect(phases).toContain("resolving");
+        expect(phases).toContain("populating");
+        expect(phases).toContain("communities");
+        expect(phases).toContain("search");
+        expect(phases).toContain("snapshot");
+    });
+    it("reports file count in extracting phase", async () => {
+        const { indexLocalProject } = await import("../intelligence/local-indexer.js");
+        let maxProcessed = 0;
+        let totalReported = 0;
+        await indexLocalProject("/tmp/test", {}, "test-repo", {
+            onProgress: (event) => {
+                if (event.phase === "extracting") {
+                    maxProcessed = Math.max(maxProcessed, event.processed);
+                    totalReported = event.total;
+                }
+            },
+        });
+        // Should have processed and reported totals
+        expect(totalReported).toBeGreaterThan(0);
+        expect(maxProcessed).toBeGreaterThan(0);
+    });
+});