@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/__tests__/durability-scorer.test.js

@@ -0,0 +1,152 @@
+import { describe, expect, it } from "vitest";
+import { createDurabilityScorer } from "../intelligence/durability-scorer.js";
+describe("createDurabilityScorer", () => {
+    it("computes durability for entities", () => {
+        const scorer = createDurabilityScorer();
+        const entries = [
+            {
+                id: "e1",
+                ts: "2026-04-28T10:00:00Z",
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/auth.ts"] },
+            },
+            {
+                id: "e2",
+                ts: "2026-04-29T10:00:00Z",
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/auth.ts"] },
+            },
+            {
+                id: "e3",
+                ts: "2026-04-30T10:00:00Z",
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/auth.ts"] },
+            },
+        ];
+        const scores = scorer.computeScores(entries);
+        const score = scores.get("src/auth.ts");
+        expect(score).toBeDefined();
+        expect(score?.modificationCount).toBe(3);
+        expect(score?.score).toBeGreaterThan(0);
+        expect(score?.score).toBeLessThanOrEqual(1);
+    });
+    it("entity modified 3x in 3 sessions with 1 day survival has low durability", () => {
+        const scorer = createDurabilityScorer();
+        const day = 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        const entries = [
+            {
+                id: "e1",
+                ts: new Date(now - 3 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+            {
+                id: "e2",
+                ts: new Date(now - 2 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+            {
+                id: "e3",
+                ts: new Date(now - 1 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+        ];
+        scorer.computeScores(entries);
+        const score = scorer.getScore("src/flaky.ts");
+        expect(score).toBeDefined();
+        expect(score?.score).toBeLessThan(0.7);
+    });
+    it("stable entity has high durability", () => {
+        const scorer = createDurabilityScorer();
+        const day = 24 * 60 * 60 * 1000;
+        const now = Date.now();
+        const entries = [
+            {
+                id: "e1",
+                ts: new Date(now - 30 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/stable.ts"] },
+            },
+            {
+                id: "e2",
+                ts: new Date(now - 1 * day).toISOString(),
+                tool: "get_function",
+                args_summary: { key: "src/other.ts" },
+            },
+        ];
+        scorer.computeScores(entries);
+        const score = scorer.getScore("src/stable.ts");
+        expect(score).toBeDefined();
+        expect(score?.score).toBeGreaterThanOrEqual(0.9);
+    });
+    it("getTopUnstable returns lowest scores", () => {
+        const scorer = createDurabilityScorer();
+        const now = Date.now();
+        const day = 24 * 60 * 60 * 1000;
+        const entries = [
+            {
+                id: "e1",
+                ts: new Date(now - 10 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/stable.ts"] },
+            },
+            {
+                id: "e2",
+                ts: new Date(now - 3 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+            {
+                id: "e3",
+                ts: new Date(now - 2 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+            {
+                id: "e4",
+                ts: new Date(now - 1 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+        ];
+        scorer.computeScores(entries);
+        const unstable = scorer.getTopUnstable(1);
+        expect(unstable[0]?.entityKey).toBe("src/flaky.ts");
+    });
+    it("getTopDurable returns highest scores", () => {
+        const scorer = createDurabilityScorer();
+        const now = Date.now();
+        const day = 24 * 60 * 60 * 1000;
+        const entries = [
+            {
+                id: "e1",
+                ts: new Date(now - 10 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/stable.ts"] },
+            },
+            {
+                id: "e2",
+                ts: new Date(now - 1 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+            {
+                id: "e3",
+                ts: new Date(now - 0.5 * day).toISOString(),
+                tool: "sync_local_diff",
+                args_summary: { files: ["src/flaky.ts"] },
+            },
+        ];
+        scorer.computeScores(entries);
+        const durable = scorer.getTopDurable(1);
+        expect(durable[0]?.entityKey).toBe("src/stable.ts");
+    });
+    it("handles empty entries", () => {
+        const scorer = createDurabilityScorer();
+        const scores = scorer.computeScores([]);
+        expect(scores.size).toBe(0);
+    });
+});

package/dist/__tests__/efficiency-tracker.test.js

@@ -0,0 +1,65 @@
+import { describe, expect, it } from "vitest";
+import { createEfficiencyTracker } from "../proxy/efficiency-tracker.js";
+describe("createEfficiencyTracker", () => {
+    it("starts with zero state", () => {
+        const tracker = createEfficiencyTracker();
+        const snap = tracker.getSnapshot();
+        expect(snap.totalCalls).toBe(0);
+        expect(snap.originalTokens).toBe(0);
+        expect(snap.deliveredTokens).toBe(0);
+        expect(snap.efficiency).toBe(0);
+    });
+    it("records token pairs and computes efficiency", () => {
+        const tracker = createEfficiencyTracker();
+        tracker.record(1000, 600);
+        expect(tracker.getEfficiency()).toBe(40);
+        expect(tracker.getSavedTokens()).toBe(400);
+    });
+    it("accumulates across multiple calls", () => {
+        const tracker = createEfficiencyTracker();
+        tracker.record(1000, 700);
+        tracker.record(2000, 800);
+        tracker.record(500, 500);
+        const snap = tracker.getSnapshot();
+        expect(snap.totalCalls).toBe(3);
+        expect(snap.originalTokens).toBe(3500);
+        expect(snap.deliveredTokens).toBe(2000);
+        expect(snap.savedTokens).toBe(1500);
+        expect(snap.efficiency).toBe(43);
+    });
+    it("computes average savings per call", () => {
+        const tracker = createEfficiencyTracker();
+        tracker.record(1000, 500);
+        tracker.record(2000, 1000);
+        const snap = tracker.getSnapshot();
+        expect(snap.avgSavingsPerCall).toBe(750);
+    });
+    it("handles 10 calls with known values", () => {
+        const tracker = createEfficiencyTracker();
+        for (let i = 0; i < 10; i++) {
+            tracker.record(1000, 300);
+        }
+        expect(tracker.getEfficiency()).toBe(70);
+        expect(tracker.getSavedTokens()).toBe(7000);
+        expect(tracker.getSnapshot().totalCalls).toBe(10);
+    });
+    it("handles zero original tokens gracefully", () => {
+        const tracker = createEfficiencyTracker();
+        tracker.record(0, 0);
+        expect(tracker.getEfficiency()).toBe(0);
+    });
+    it("never returns negative savings", () => {
+        const tracker = createEfficiencyTracker();
+        tracker.record(100, 200);
+        expect(tracker.getSavedTokens()).toBe(0);
+    });
+    it("reset clears all state", () => {
+        const tracker = createEfficiencyTracker();
+        tracker.record(5000, 2000);
+        tracker.reset();
+        const snap = tracker.getSnapshot();
+        expect(snap.totalCalls).toBe(0);
+        expect(snap.originalTokens).toBe(0);
+        expect(snap.efficiency).toBe(0);
+    });
+});

package/dist/__tests__/enrich.test.js

@@ -0,0 +1,144 @@
+/**
+ * Tests for Sprint L8.2 — `unerr enrich` enrichment logic.
+ *
+ * Tests the prompt builder and response parser without requiring
+ * a real LLM or CozoDB instance.
+ */
+import { describe, expect, it } from "vitest";
+// Re-export internal functions for testing by importing the module
+// and testing the prompt/parse logic through the public API patterns.
+// Since buildEnrichmentPrompt and parseEnrichmentResponse are module-private,
+// we test them indirectly through their behavior. We can also test them
+// by extracting them — but for now, test the patterns they implement.
+describe("Enrichment prompt builder (L8.2)", () => {
+    it("builds a structured prompt for entity batch", () => {
+        // Verify the prompt format expected by parseEnrichmentResponse
+        const entities = [
+            {
+                key: "fn:auth:login",
+                kind: "function",
+                name: "login",
+                filePath: "src/auth.ts",
+                signature: "login(user: User): Promise<Token>",
+            },
+            {
+                key: "cls:auth:AuthService",
+                kind: "class",
+                name: "AuthService",
+                filePath: "src/auth.ts",
+                signature: "class AuthService",
+            },
+        ];
+        // The prompt should contain entity info
+        const entityBlock = entities
+            .map((e, i) => `[${i + 1}] ${e.kind} "${e.name}" in ${e.filePath}\n    Signature: ${e.signature || "(none)"}`)
+            .join("\n");
+        expect(entityBlock).toContain('[1] function "login"');
+        expect(entityBlock).toContain('[2] class "AuthService"');
+        expect(entityBlock).toContain("src/auth.ts");
+    });
+});
+describe("Enrichment response parser (L8.2)", () => {
+    // Mirror the parseEnrichmentResponse logic
+    function parseEnrichmentResponse(text, count) {
+        const jsonMatch = text.match(/\[[\s\S]*\]/);
+        if (!jsonMatch) {
+            return Array.from({ length: count }, () => ({
+                purpose: "",
+                taxonomy: "unknown",
+                feature_area: "unknown",
+            }));
+        }
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            const results = [];
+            for (let i = 0; i < count; i++) {
+                const entry = parsed.find((p) => p.index === i + 1) ?? parsed[i] ?? {};
+                results.push({
+                    purpose: entry.purpose ?? "",
+                    taxonomy: entry.taxonomy ?? "unknown",
+                    feature_area: entry.feature_area ?? "unknown",
+                });
+            }
+            return results;
+        }
+        catch {
+            return Array.from({ length: count }, () => ({
+                purpose: "",
+                taxonomy: "unknown",
+                feature_area: "unknown",
+            }));
+        }
+    }
+    it("parses well-formed JSON array response", () => {
+        const text = JSON.stringify([
+            {
+                index: 1,
+                purpose: "Handles user login",
+                taxonomy: "authentication",
+                feature_area: "user-auth",
+            },
+            {
+                index: 2,
+                purpose: "Manages auth state",
+                taxonomy: "authentication",
+                feature_area: "user-auth",
+            },
+        ]);
+        const results = parseEnrichmentResponse(text, 2);
+        expect(results).toHaveLength(2);
+        expect(results[0]?.purpose).toBe("Handles user login");
+        expect(results[0]?.taxonomy).toBe("authentication");
+        expect(results[1]?.feature_area).toBe("user-auth");
+    });
+    it("handles markdown-wrapped JSON", () => {
+        const text = '```json\n[{"index": 1, "purpose": "Test function", "taxonomy": "testing", "feature_area": "unit-tests"}]\n```';
+        const results = parseEnrichmentResponse(text, 1);
+        expect(results).toHaveLength(1);
+        expect(results[0]?.purpose).toBe("Test function");
+        expect(results[0]?.taxonomy).toBe("testing");
+    });
+    it("returns defaults for unparseable response", () => {
+        const results = parseEnrichmentResponse("Sorry, I cannot help with that.", 3);
+        expect(results).toHaveLength(3);
+        expect(results[0]?.purpose).toBe("");
+        expect(results[0]?.taxonomy).toBe("unknown");
+        expect(results[0]?.feature_area).toBe("unknown");
+    });
+    it("handles partial responses with missing fields", () => {
+        const text = JSON.stringify([
+            { index: 1, purpose: "Does something" },
+            { index: 2, taxonomy: "data-access" },
+        ]);
+        const results = parseEnrichmentResponse(text, 2);
+        expect(results[0]?.purpose).toBe("Does something");
+        expect(results[0]?.taxonomy).toBe("unknown"); // missing → default
+        expect(results[1]?.purpose).toBe(""); // missing → default
+        expect(results[1]?.taxonomy).toBe("data-access");
+    });
+    it("handles fewer results than requested", () => {
+        const text = JSON.stringify([
+            {
+                index: 1,
+                purpose: "Only one result",
+                taxonomy: "misc",
+                feature_area: "core",
+            },
+        ]);
+        const results = parseEnrichmentResponse(text, 3);
+        expect(results).toHaveLength(3);
+        expect(results[0]?.purpose).toBe("Only one result");
+        expect(results[1]?.purpose).toBe(""); // fallback
+        expect(results[2]?.purpose).toBe(""); // fallback
+    });
+    it("handles index-based matching", () => {
+        // Response with out-of-order indices
+        const text = JSON.stringify([
+            { index: 2, purpose: "Second", taxonomy: "b", feature_area: "b" },
+            { index: 1, purpose: "First", taxonomy: "a", feature_area: "a" },
+        ]);
+        const results = parseEnrichmentResponse(text, 2);
+        expect(results[0]?.purpose).toBe("First");
+        expect(results[1]?.purpose).toBe("Second");
+    });
+});

package/dist/__tests__/entity-rewind.test.js

@@ -0,0 +1,248 @@
+/**
+ * Sprint 7.4: Entity-level rewind tests.
+ */
+import { mkdirSync, mkdtempSync, readFileSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { revertEntity } from "../tracking/entity-rewind.js";
+/** Minimal mock CozoGraphStore with drift overlay backed by a Map. */
+function createMockGraph(driftEntities = []) {
+    const overlay = new Map();
+    for (const e of driftEntities) {
+        overlay.set(e.key, e);
+    }
+    const removed = [];
+    return {
+        removed,
+        db: {
+            run: async (query, params) => {
+                // Simulate drift_overlay lookup by name (+ optional file_path filter)
+                const name = params?.name;
+                const fp = params?.fp;
+                const matches = [];
+                for (const [, e] of overlay) {
+                    if (name && e.name !== name)
+                        continue;
+                    if (fp && e.file_path !== fp)
+                        continue;
+                    matches.push(e);
+                }
+                return {
+                    rows: matches.map((e) => [
+                        e.key,
+                        e.name,
+                        e.kind,
+                        e.signature,
+                        e.body,
+                        e.file_path,
+                        e.line_start,
+                        e.line_end,
+                        e.content_hash,
+                        e.drift_status,
+                        e.intent_id,
+                        e.modified_at,
+                        e.origin,
+                        e.previous_body,
+                        e.previous_signature,
+                    ]),
+                };
+            },
+        },
+        removeDriftEntity: (key) => {
+            overlay.delete(key);
+            removed.push(key);
+        },
+    };
+}
+function makeDrift(overrides) {
+    return {
+        kind: "function",
+        signature: "()",
+        body: "",
+        file_path: "src/test.ts",
+        line_start: 1,
+        line_end: 3,
+        content_hash: "abc",
+        drift_status: "modified",
+        intent_id: "",
+        modified_at: new Date().toISOString(),
+        origin: "human",
+        previous_body: "",
+        previous_signature: "",
+        ...overrides,
+    };
+}
+describe("Entity-level rewind", () => {
+    it("returns error when entity not found in drift overlay", async () => {
+        const graph = createMockGraph();
+        const result = await revertEntity("nonExistent", graph, "/tmp");
+        expect(result.reverted).toBe(false);
+        expect(result.error).toContain("No drifted entity found");
+    });
+    it("reverts a MODIFIED entity by restoring previous_body", async () => {
+        const projectRoot = mkdtempSync(join(tmpdir(), "rewind-"));
+        const srcDir = join(projectRoot, "src");
+        mkdirSync(srcDir, { recursive: true });
+        // Write the current (modified) file
+        const fileContent = [
+            "// header",
+            "function doStuff() {",
+            "  return 'modified';",
+            "}",
+            "// footer",
+        ].join("\n");
+        writeFileSync(join(srcDir, "test.ts"), fileContent);
+        const graph = createMockGraph([
+            makeDrift({
+                key: "k1",
+                name: "doStuff",
+                file_path: "src/test.ts",
+                body: "function doStuff() {\n  return 'modified';\n}",
+                line_start: 2,
+                line_end: 4,
+                drift_status: "modified",
+                previous_body: "function doStuff() {\n  return 'original';\n}",
+            }),
+        ]);
+        const result = await revertEntity("doStuff", graph, projectRoot);
+        expect(result.reverted).toBe(true);
+        expect(result.file).toBe("src/test.ts");
+        expect(result.drift_status).toBe("modified");
+        expect(graph.removed).toContain("k1");
+        // Verify file content was restored
+        const restored = readFileSync(join(srcDir, "test.ts"), "utf-8");
+        expect(restored).toContain("return 'original'");
+        expect(restored).not.toContain("return 'modified'");
+        expect(restored).toContain("// header");
+        expect(restored).toContain("// footer");
+    });
+    it("reverts an ADDED entity by removing its lines", async () => {
+        const projectRoot = mkdtempSync(join(tmpdir(), "rewind-"));
+        const srcDir = join(projectRoot, "src");
+        mkdirSync(srcDir, { recursive: true });
+        const fileContent = [
+            "// existing code",
+            "function newFn() {",
+            "  return 42;",
+            "}",
+            "// more code",
+        ].join("\n");
+        writeFileSync(join(srcDir, "test.ts"), fileContent);
+        const graph = createMockGraph([
+            makeDrift({
+                key: "k2",
+                name: "newFn",
+                file_path: "src/test.ts",
+                body: "function newFn() {\n  return 42;\n}",
+                line_start: 2,
+                line_end: 4,
+                drift_status: "added",
+                previous_body: "",
+            }),
+        ]);
+        const result = await revertEntity("newFn", graph, projectRoot);
+        expect(result.reverted).toBe(true);
+        expect(result.drift_status).toBe("added");
+        expect(graph.removed).toContain("k2");
+        const restored = readFileSync(join(srcDir, "test.ts"), "utf-8");
+        expect(restored).not.toContain("newFn");
+        expect(restored).toContain("// existing code");
+        expect(restored).toContain("// more code");
+    });
+    it("reverts a DELETED entity by inserting previous_body", async () => {
+        const projectRoot = mkdtempSync(join(tmpdir(), "rewind-"));
+        const srcDir = join(projectRoot, "src");
+        mkdirSync(srcDir, { recursive: true });
+        // File after deletion — the entity is missing
+        const fileContent = ["// header", "// footer"].join("\n");
+        writeFileSync(join(srcDir, "test.ts"), fileContent);
+        const graph = createMockGraph([
+            makeDrift({
+                key: "k3",
+                name: "removedFn",
+                file_path: "src/test.ts",
+                body: "",
+                line_start: 2,
+                line_end: 2,
+                drift_status: "deleted",
+                previous_body: "function removedFn() {\n  return 'was here';\n}",
+            }),
+        ]);
+        const result = await revertEntity("removedFn", graph, projectRoot);
+        expect(result.reverted).toBe(true);
+        expect(result.drift_status).toBe("deleted");
+        expect(graph.removed).toContain("k3");
+        const restored = readFileSync(join(srcDir, "test.ts"), "utf-8");
+        expect(restored).toContain("removedFn");
+        expect(restored).toContain("was here");
+    });
+    it("reverts dependency_changed by just removing overlay entry", async () => {
+        const graph = createMockGraph([
+            makeDrift({
+                key: "k4",
+                name: "callerFn",
+                drift_status: "dependency_changed",
+            }),
+        ]);
+        const result = await revertEntity("callerFn", graph, "/tmp");
+        expect(result.reverted).toBe(true);
+        expect(result.drift_status).toBe("dependency_changed");
+        expect(graph.removed).toContain("k4");
+    });
+    it("filters by file_path when provided", async () => {
+        const graph = createMockGraph([
+            makeDrift({
+                key: "k5a",
+                name: "shared",
+                file_path: "src/a.ts",
+                drift_status: "modified",
+            }),
+            makeDrift({
+                key: "k5b",
+                name: "shared",
+                file_path: "src/b.ts",
+                drift_status: "modified",
+                previous_body: "function shared() { return 'b'; }",
+            }),
+        ]);
+        const projectRoot = mkdtempSync(join(tmpdir(), "rewind-"));
+        mkdirSync(join(projectRoot, "src"), { recursive: true });
+        writeFileSync(join(projectRoot, "src", "b.ts"), "function shared() { return 'modified'; }");
+        const result = await revertEntity("shared", graph, projectRoot, "src/b.ts");
+        expect(result.reverted).toBe(true);
+        expect(result.file).toBe("src/b.ts");
+        expect(graph.removed).toContain("k5b");
+        expect(graph.removed).not.toContain("k5a");
+    });
+    it("returns error when modified entity has no previous_body", async () => {
+        const projectRoot = mkdtempSync(join(tmpdir(), "rewind-"));
+        mkdirSync(join(projectRoot, "src"), { recursive: true });
+        writeFileSync(join(projectRoot, "src", "test.ts"), "some content");
+        const graph = createMockGraph([
+            makeDrift({
+                key: "k6",
+                name: "noHistory",
+                file_path: "src/test.ts",
+                drift_status: "modified",
+                previous_body: "",
+            }),
+        ]);
+        const result = await revertEntity("noHistory", graph, projectRoot);
+        expect(result.reverted).toBe(false);
+        expect(result.error).toContain("No previous body");
+    });
+    it("stores previous_body in drift overlay when entity is modified", () => {
+        // This test verifies the DriftTracker integration —
+        // modified entities should preserve the base body for rewind
+        const drift = makeDrift({
+            key: "k7",
+            name: "fn",
+            drift_status: "modified",
+            previous_body: "function fn() { return 1; }",
+            previous_signature: "()",
+        });
+        expect(drift.previous_body).toBe("function fn() { return 1; }");
+        expect(drift.previous_signature).toBe("()");
+    });
+});