@unerr-ai/unerr 0.1.6 → 0.1.8

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

@@ -1,280 +0,0 @@
-/**
- * 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

@@ -1,228 +0,0 @@
-/**
- * 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);
-    });
-});