@unerr-ai/unerr 0.1.0 → 0.1.2

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

@@ -0,0 +1,228 @@
+/**
+ * Sprint L2 Tests: Local indexing pipeline, snapshot persistence, edge extraction.
+ */
+import { mkdirSync, mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// ── Fixture project factory ─────────────────────────────────────
+function createFixtureProject() {
+    const dir = mkdtempSync(join(tmpdir(), "unerr-l2-test-"));
+    // Create a minimal multi-file TypeScript project
+    mkdirSync(join(dir, "src"), { recursive: true });
+    mkdirSync(join(dir, "src", "utils"), { recursive: true });
+    writeFileSync(join(dir, "src", "index.ts"), `
+import { greet } from "./utils/greet.js";
+
+export function main(): void {
+  const message = greet("world");
+  console.log(message);
+}
+
+export class App {
+  private name: string;
+
+  constructor(name: string) {
+    this.name = name;
+  }
+
+  run(): void {
+    main();
+  }
+}
+`);
+    writeFileSync(join(dir, "src", "utils", "greet.ts"), `
+export function greet(name: string): string {
+  return formatMessage(\`Hello, \${name}!\`);
+}
+
+export function formatMessage(msg: string): string {
+  return msg.trim();
+}
+
+export interface Greeting {
+  name: string;
+  message: string;
+}
+`);
+    writeFileSync(join(dir, "src", "service.ts"), `
+import { greet } from "./utils/greet.js";
+
+export class UserService {
+  getGreeting(userId: string): string {
+    return greet(userId);
+  }
+}
+
+export interface UserConfig {
+  timeout: number;
+  retries: number;
+}
+`);
+    return dir;
+}
+// ── Tests ───────────────────────────────────────────────────────
+describe("discoverSourceFiles", () => {
+    let projectDir;
+    beforeEach(() => {
+        projectDir = createFixtureProject();
+    });
+    afterEach(() => {
+        rmSync(projectDir, { recursive: true, force: true });
+    });
+    it("discovers .ts files and skips node_modules", async () => {
+        const { discoverSourceFiles } = await import("../intelligence/local-indexer.js");
+        // Add a node_modules dir that should be excluded
+        mkdirSync(join(projectDir, "node_modules", "fake-pkg"), {
+            recursive: true,
+        });
+        writeFileSync(join(projectDir, "node_modules", "fake-pkg", "index.ts"), "export const x = 1;");
+        const files = discoverSourceFiles(projectDir);
+        expect(files.length).toBeGreaterThanOrEqual(3);
+        expect(files.every((f) => !f.includes("node_modules"))).toBe(true);
+        expect(files.some((f) => f.endsWith("index.ts"))).toBe(true);
+        expect(files.some((f) => f.endsWith("greet.ts"))).toBe(true);
+        expect(files.some((f) => f.endsWith("service.ts"))).toBe(true);
+    });
+    it("skips files exceeding 1MB", async () => {
+        const { discoverSourceFiles } = await import("../intelligence/local-indexer.js");
+        // Create a huge file
+        writeFileSync(join(projectDir, "src", "huge.ts"), "x".repeat(2_000_000));
+        const files = discoverSourceFiles(projectDir);
+        expect(files.every((f) => !f.endsWith("huge.ts"))).toBe(true);
+    });
+});
+describe("extractEdgesAsync", () => {
+    it("extracts import edges from TypeScript", async () => {
+        const { extractEdgesAsync, extractEntities } = await import("../intelligence/ast-extractor.js");
+        const content = `
+import { greet } from "./utils/greet.js";
+import { App } from "./app.js";
+
+export function main() {
+  const msg = greet("world");
+  const app = new App("test");
+  app.run();
+}
+`;
+        const entities = extractEntities(content, "src/index.ts");
+        const edges = await extractEdgesAsync(content, "src/index.ts", entities);
+        // Should have import edges
+        const importEdges = edges.filter((e) => e.type === "imports");
+        expect(importEdges.length).toBeGreaterThanOrEqual(1);
+        // Should detect greet import
+        const greetImport = importEdges.find((e) => e.to_name === "greet");
+        expect(greetImport).toBeDefined();
+    });
+    it("extracts call edges from TypeScript", async () => {
+        const { extractEdgesAsync, extractEntities } = await import("../intelligence/ast-extractor.js");
+        const content = `
+export function main() {
+  const result = helper();
+  process(result);
+}
+
+function helper(): number {
+  return 42;
+}
+
+function process(n: number): void {
+  console.log(n);
+}
+`;
+        const entities = extractEntities(content, "src/index.ts");
+        const edges = await extractEdgesAsync(content, "src/index.ts", entities);
+        const callEdges = edges.filter((e) => e.type === "calls");
+        // main calls helper and process
+        expect(callEdges.some((e) => e.to_name === "helper")).toBe(true);
+        expect(callEdges.some((e) => e.to_name === "process")).toBe(true);
+    });
+    it("extracts extends/implements edges from classes", async () => {
+        const { extractEdgesAsync, extractEntities } = await import("../intelligence/ast-extractor.js");
+        const content = `
+interface Runnable {
+  run(): void;
+}
+
+class Base {
+  start(): void {}
+}
+
+export class App extends Base implements Runnable {
+  run(): void {}
+}
+`;
+        const entities = extractEntities(content, "src/app.ts");
+        const edges = await extractEdgesAsync(content, "src/app.ts", entities);
+        const extendsEdges = edges.filter((e) => e.type === "extends");
+        const implementsEdges = edges.filter((e) => e.type === "implements");
+        expect(extendsEdges.some((e) => e.to_name === "Base")).toBe(true);
+        expect(implementsEdges.some((e) => e.to_name === "Runnable")).toBe(true);
+    });
+});
+describe("local-snapshot", () => {
+    it("snapshotPath returns consistent path for same root", async () => {
+        const { snapshotPath } = await import("../intelligence/local-snapshot.js");
+        const path1 = snapshotPath("/tmp/my-project");
+        const path2 = snapshotPath("/tmp/my-project");
+        expect(path1).toBe(path2);
+        expect(path1).toContain(".unerr/snapshots/");
+        expect(path1).toMatch(/\.msgpack\.gz$/);
+    });
+    it("snapshotPath is within the project root", async () => {
+        const { snapshotPath } = await import("../intelligence/local-snapshot.js");
+        const path1 = snapshotPath("/tmp/project-a");
+        const path2 = snapshotPath("/tmp/project-b");
+        expect(path1).toContain("/tmp/project-a/.unerr/");
+        expect(path2).toContain("/tmp/project-b/.unerr/");
+        expect(path1).not.toBe(path2);
+    });
+    it("shouldReindex returns true when no snapshot exists", async () => {
+        const { shouldReindex } = await import("../intelligence/local-snapshot.js");
+        // Non-existent project — no snapshot can exist
+        const result = shouldReindex(`/tmp/nonexistent-project-${Date.now()}`);
+        expect(result).toBe(true);
+    });
+    it("getSnapshotMeta reports non-existent snapshot", async () => {
+        const { getSnapshotMeta } = await import("../intelligence/local-snapshot.js");
+        const meta = getSnapshotMeta(`/tmp/nonexistent-project-${Date.now()}`);
+        expect(meta.exists).toBe(false);
+        expect(meta.path).toContain(".unerr/snapshots/");
+    });
+});
+describe("DriftTracker local reindex hook", () => {
+    it("setLocalReindex is callable and stores the hook", async () => {
+        const { DriftTracker } = await import("../tracking/drift-tracker.js");
+        // Create a minimal mock
+        const mockGraph = {
+            getEntitiesByFile: () => [],
+            getDriftEntitiesForFile: () => [],
+            upsertDriftEntity: vi.fn(),
+            getCallersOf: () => [],
+            findEntityByName: () => null,
+            upsertDriftEdge: vi.fn(),
+            hasRules: () => false,
+            getRules: () => [],
+            getDriftSummary: () => ({ total: 0, added: 0, modified: 0, deleted: 0 }),
+            clearDriftOverlay: vi.fn(),
+        };
+        const mockHashManager = {
+            shouldProcess: () => "process",
+            markProcessed: vi.fn(),
+            save: vi.fn(),
+            clearAll: vi.fn(),
+            getState: () => ({}),
+            restoreState: vi.fn(),
+        };
+        const tracker = new DriftTracker({
+            projectRoot: "/tmp/test",
+            repoId: "test-repo",
+            unerrDir: "/tmp/test/.unerr",
+        }, mockGraph, mockHashManager);
+        const mockReindex = vi.fn().mockResolvedValue({ entities: 5, edges: 3 });
+        tracker.setLocalReindex(mockReindex);
+        // The hook is stored internally — we can't directly verify it,
+        // but the fact that setLocalReindex doesn't throw is the test.
+        expect(mockReindex).not.toHaveBeenCalled();
+    });
+});

package/dist/__tests__/local-intelligence-l3.test.js

@@ -0,0 +1,332 @@
+/**
+ * Sprint L3 Tests: Local Project Stats (L3.3) & entity_embeddings relation (L3.4).
+ *
+ * Uses an in-memory mock CozoDB (real cozo-node's run() is async/Promise-based,
+ * but the CozoDb interface expects synchronous returns).
+ */
+import { describe, expect, it } from "vitest";
+class MockCozoDb {
+    entities = [];
+    edges = [];
+    fileIndex = [];
+    rules = [];
+    driftOverlay = [];
+    communities = [];
+    corrections = [];
+    embeddings = new Map();
+    async run(query, params) {
+        // ── :create — no-op
+        if (query.includes(":create ")) {
+            return { rows: [] };
+        }
+        // ── :put entity_embeddings
+        if (query.includes(":put entity_embeddings")) {
+            const ek = this.extractInlineOrParam(query, params, "entity_key", 0);
+            const vj = this.extractInlineOrParam(query, params, "vector_json", 1);
+            const model = this.extractInlineOrParam(query, params, "model", 2);
+            const dims = this.extractInlineOrParam(query, params, "dimensions", 3);
+            const ca = this.extractInlineOrParam(query, params, "computed_at", 4);
+            this.embeddings.set(ek, {
+                entityKey: ek,
+                vectorJson: vj,
+                model,
+                dimensions: dims,
+                computedAt: ca,
+            });
+            return { rows: [] };
+        }
+        // ── :rm entity_embeddings
+        if (query.includes(":rm entity_embeddings")) {
+            const ek = this.extractInlineOrParam(query, params, "entity_key", 0);
+            this.embeddings.delete(ek);
+            return { rows: [] };
+        }
+        // ── :put (other relations) — no-op, data seeded via addXxx methods
+        if (query.includes(":put ")) {
+            return { rows: [] };
+        }
+        // ── Aggregation queries for getLocalProjectStats
+        // NOTE: More specific patterns (group-by) must come BEFORE simple counts
+        // to avoid false matches (e.g., "kind, count(key)" also contains "count(key)").
+        // kind, count(key) from entities (group by kind)
+        if (query.includes("kind, count(key)") && query.includes("*entities")) {
+            const grouped = new Map();
+            for (const e of this.entities) {
+                grouped.set(e.kind, (grouped.get(e.kind) ?? 0) + 1);
+            }
+            return { rows: Array.from(grouped.entries()) };
+        }
+        // type, count(from_key) from edges (group by type)
+        if (query.includes("type, count(from_key)") && query.includes("*edges")) {
+            const grouped = new Map();
+            for (const e of this.edges) {
+                grouped.set(e.type, (grouped.get(e.type) ?? 0) + 1);
+            }
+            return { rows: Array.from(grouped.entries()) };
+        }
+        // file_path, count(entity_key) from file_index (top files)
+        if (query.includes("file_path, count(entity_key)") &&
+            query.includes("*file_index")) {
+            const grouped = new Map();
+            for (const fi of this.fileIndex) {
+                grouped.set(fi.filePath, (grouped.get(fi.filePath) ?? 0) + 1);
+            }
+            const sorted = Array.from(grouped.entries()).sort((a, b) => b[1] - a[1]);
+            return { rows: sorted.slice(0, 10) };
+        }
+        // count_unique(file_path) from entities
+        if (query.includes("count_unique(file_path)") &&
+            query.includes("*entities")) {
+            const unique = new Set(this.entities.map((e) => e.filePath));
+            return { rows: [[unique.size]] };
+        }
+        // count(key) from entities
+        if (query.includes("count(key)") && query.includes("*entities")) {
+            return { rows: [[this.entities.length]] };
+        }
+        // count(from_key) from edges
+        if (query.includes("count(from_key)") && query.includes("*edges")) {
+            return { rows: [[this.edges.length]] };
+        }
+        // count(key) from rules where enabled = true
+        if (query.includes("count(key)") &&
+            query.includes("*rules") &&
+            query.includes("enabled")) {
+            return { rows: [[this.rules.filter((r) => r.enabled).length]] };
+        }
+        // count(key) from drift_overlay
+        if (query.includes("count(key)") && query.includes("*drift_overlay")) {
+            return { rows: [[this.driftOverlay.length]] };
+        }
+        // count(id) from communities
+        if (query.includes("count(id)") && query.includes("*communities")) {
+            return { rows: [[this.communities.length]] };
+        }
+        // count(entity_key) from corrections
+        if (query.includes("count(entity_key)") && query.includes("*corrections")) {
+            return { rows: [[this.corrections.length]] };
+        }
+        // ── entity_embeddings queries
+        // Read all: entity_key, vector_json, model, dimensions
+        if (query.includes("entity_key, vector_json, model, dimensions") &&
+            query.includes("*entity_embeddings")) {
+            const rows = [];
+            for (const emb of this.embeddings.values()) {
+                rows.push([emb.entityKey, emb.vectorJson, emb.model, emb.dimensions]);
+            }
+            return { rows };
+        }
+        // Count after delete
+        if (query.includes("entity_key") && query.includes("*entity_embeddings")) {
+            const rows = [];
+            for (const key of this.embeddings.keys()) {
+                rows.push([key]);
+            }
+            return { rows };
+        }
+        // Default
+        return { rows: [] };
+    }
+    extractInlineOrParam(query, params, _field, _index) {
+        // For the entity_embeddings CRUD test, values come from the <- [[...]] clause
+        // Parse the values from the inline array
+        const match = query.match(/<-\s*\[\[(.*?)\]\]/);
+        if (match) {
+            const values = this.parseInlineValues(match[1] ?? "");
+            if (_index < values.length)
+                return values[_index];
+        }
+        return params?.[_field] ?? "";
+    }
+    parseInlineValues(str) {
+        const values = [];
+        let i = 0;
+        while (i < str.length) {
+            // Skip whitespace and commas
+            while (i < str.length && (str[i] === " " || str[i] === ","))
+                i++;
+            if (i >= str.length)
+                break;
+            if (str[i] === '"') {
+                // String literal
+                i++;
+                let val = "";
+                while (i < str.length && str[i] !== '"') {
+                    val += str[i];
+                    i++;
+                }
+                i++; // skip closing quote
+                values.push(val);
+            }
+            else if (str[i] === "$") {
+                // Parameter reference — skip for now
+                while (i < str.length && str[i] !== "," && str[i] !== "]")
+                    i++;
+                values.push(null); // placeholder
+            }
+            else {
+                // Number or boolean
+                let val = "";
+                while (i < str.length &&
+                    str[i] !== "," &&
+                    str[i] !== "]" &&
+                    str[i] !== " ") {
+                    val += str[i];
+                    i++;
+                }
+                if (val === "true")
+                    values.push(true);
+                else if (val === "false")
+                    values.push(false);
+                else
+                    values.push(Number(val));
+            }
+        }
+        return values;
+    }
+}
+function createTestDb() {
+    return new MockCozoDb();
+}
+function seedGraph(db) {
+    // Seed entities
+    db.entities.push({
+        key: "fn::auth::login",
+        kind: "function",
+        name: "login",
+        filePath: "src/auth.ts",
+    }, {
+        key: "fn::auth::logout",
+        kind: "function",
+        name: "logout",
+        filePath: "src/auth.ts",
+    }, {
+        key: "cls::auth::AuthService",
+        kind: "class",
+        name: "AuthService",
+        filePath: "src/auth.ts",
+    }, {
+        key: "fn::db::connect",
+        kind: "function",
+        name: "connect",
+        filePath: "src/db.ts",
+    }, {
+        key: "fn::db::query",
+        kind: "function",
+        name: "query",
+        filePath: "src/db.ts",
+    }, {
+        key: "file::src/auth.ts",
+        kind: "file",
+        name: "auth.ts",
+        filePath: "src/auth.ts",
+    }, {
+        key: "file::src/db.ts",
+        kind: "file",
+        name: "db.ts",
+        filePath: "src/db.ts",
+    });
+    // Seed file index
+    for (const e of db.entities) {
+        db.fileIndex.push({ filePath: e.filePath, entityKey: e.key });
+    }
+    // Seed edges
+    db.edges.push({ fromKey: "fn::auth::login", toKey: "fn::db::query", type: "calls" }, {
+        fromKey: "cls::auth::AuthService",
+        toKey: "fn::auth::login",
+        type: "contains",
+    }, {
+        fromKey: "cls::auth::AuthService",
+        toKey: "fn::auth::logout",
+        type: "contains",
+    }, { fromKey: "fn::db::connect", toKey: "fn::db::query", type: "calls" });
+    // Seed a rule
+    db.rules.push({ key: "rule::no-any", name: "no-any", enabled: true });
+    // Seed a community
+    db.communities.push({
+        id: 0,
+        label: "auth-cluster",
+        size: 3,
+        cohesion: 0.85,
+    });
+    // Seed a drift entity
+    db.driftOverlay.push({ key: "fn::auth::login" });
+    // Seed a correction
+    db.corrections.push({
+        entityKey: "fn::auth::login",
+        errorType: "null-check",
+    });
+}
+// ── L3.3: getLocalProjectStats ──────────────────────────────
+describe("CozoGraphStore.getLocalProjectStats", () => {
+    it("returns aggregated stats from graph", async () => {
+        const db = createTestDb();
+        seedGraph(db);
+        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
+        const store = await CozoGraphStore.create(db);
+        const stats = await store.getLocalProjectStats();
+        expect(stats.entityCount).toBe(7);
+        expect(stats.edgeCount).toBe(4);
+        expect(stats.fileCount).toBe(2); // src/auth.ts and src/db.ts
+        expect(stats.ruleCount).toBe(1);
+        expect(stats.driftCount).toBe(1);
+        expect(stats.communityCount).toBe(1);
+        expect(stats.correctionCount).toBe(1);
+        // Entity breakdown by kind
+        expect(stats.entityByKind.function).toBe(4);
+        expect(stats.entityByKind.class).toBe(1);
+        expect(stats.entityByKind.file).toBe(2);
+        // Edge breakdown by type
+        expect(stats.edgeByType.calls).toBe(2);
+        expect(stats.edgeByType.contains).toBe(2);
+        // Top files
+        expect(stats.topFiles.length).toBeGreaterThan(0);
+        // src/auth.ts has 4 entities (3 + 1 file), src/db.ts has 3
+        const authFile = stats.topFiles.find((f) => f.filePath === "src/auth.ts");
+        expect(authFile).toBeDefined();
+        expect(authFile?.entityCount).toBeGreaterThanOrEqual(3);
+    });
+    it("returns zeros for empty graph", async () => {
+        const db = createTestDb();
+        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
+        const store = await CozoGraphStore.create(db);
+        const stats = await store.getLocalProjectStats();
+        expect(stats.entityCount).toBe(0);
+        expect(stats.edgeCount).toBe(0);
+        expect(stats.fileCount).toBe(0);
+        expect(stats.ruleCount).toBe(0);
+        expect(stats.driftCount).toBe(0);
+        expect(stats.entityByKind).toEqual({});
+        expect(stats.edgeByType).toEqual({});
+        expect(stats.topFiles).toEqual([]);
+    });
+    it("completes under 10ms for modest graph", async () => {
+        const db = createTestDb();
+        seedGraph(db);
+        const { CozoGraphStore } = await import("../intelligence/local-graph.js");
+        const store = await CozoGraphStore.create(db);
+        const t0 = performance.now();
+        await store.getLocalProjectStats();
+        const elapsed = performance.now() - t0;
+        expect(elapsed).toBeLessThan(50); // generous for CI; typically <5ms
+    });
+});
+// ── L3.4: entity_embeddings relation ────────────────────────
+describe("entity_embeddings relation", () => {
+    it("exists in schema and supports CRUD", async () => {
+        const db = createTestDb();
+        // Insert via mock's run method (simulates CozoDB :put)
+        await db.run(`?[entity_key, vector_json, model, dimensions, computed_at] <- [["fn::test", "[0.1,0.2,0.3]", "test-model", 3, "2026-04-17"]]
+       :put entity_embeddings {entity_key => vector_json, model, dimensions, computed_at}`);
+        // Read
+        const result = await db.run("?[entity_key, vector_json, model, dimensions] := *entity_embeddings{entity_key, vector_json, model, dimensions}");
+        expect(result.rows).toHaveLength(1);
+        expect(result.rows[0]?.[0]).toBe("fn::test");
+        expect(result.rows[0]?.[2]).toBe("test-model");
+        expect(result.rows[0]?.[3]).toBe(3);
+        // Delete
+        await db.run(`?[entity_key] <- [["fn::test"]] :rm entity_embeddings {entity_key}`);
+        const afterDelete = await db.run("?[entity_key] := *entity_embeddings{entity_key}");
+        expect(afterDelete.rows).toHaveLength(0);
+    });
+});