@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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