@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/instruction-writer.test.js

@@ -0,0 +1,179 @@
+import { existsSync, mkdirSync, readFileSync, rmSync, writeFileSync, } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { removeInstructionSection, writeInstructionFile, } from "../config/instruction-writer.js";
+describe("instruction-writer", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = join(tmpdir(), `unerr-instr-test-${Date.now()}`);
+        mkdirSync(tmpDir, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tmpDir, { recursive: true, force: true });
+    });
+    describe("writeInstructionFile — markdown (claude-code)", () => {
+        it("creates CLAUDE.md with sentinel markers when file does not exist", () => {
+            const result = writeInstructionFile(tmpDir, "claude-code");
+            expect(result.action).toBe("created");
+            expect(result.path).toBe(join(tmpDir, "CLAUDE.md"));
+            const content = readFileSync(result.path, "utf-8");
+            expect(content).toContain("<!-- unerr:start -->");
+            expect(content).toContain("<!-- unerr:end -->");
+            expect(content).toContain("get_references");
+            expect(content).toContain("search_code");
+        });
+        it("appends to existing CLAUDE.md without sentinel", () => {
+            const existingContent = "# My Project\n\nExisting instructions.\n";
+            writeFileSync(join(tmpDir, "CLAUDE.md"), existingContent);
+            const result = writeInstructionFile(tmpDir, "claude-code");
+            expect(result.action).toBe("updated");
+            const content = readFileSync(result.path, "utf-8");
+            expect(content).toContain("# My Project");
+            expect(content).toContain("Existing instructions.");
+            expect(content).toContain("<!-- unerr:start -->");
+            expect(content).toContain("get_references");
+        });
+        it("skips when sentinel content is identical", () => {
+            writeInstructionFile(tmpDir, "claude-code");
+            const result = writeInstructionFile(tmpDir, "claude-code");
+            expect(result.action).toBe("skipped");
+        });
+        it("updates when sentinel content differs", () => {
+            // Write with old content
+            const oldContent = "<!-- unerr:start -->\nOld content\n<!-- unerr:end -->\n";
+            writeFileSync(join(tmpDir, "CLAUDE.md"), oldContent);
+            const result = writeInstructionFile(tmpDir, "claude-code");
+            expect(result.action).toBe("updated");
+            const content = readFileSync(result.path, "utf-8");
+            expect(content).not.toContain("Old content");
+            expect(content).toContain("get_references");
+        });
+        it("preserves content before and after sentinel block", () => {
+            const existing = "# Header\n\n<!-- unerr:start -->\nOld\n<!-- unerr:end -->\n\n# Footer\n";
+            writeFileSync(join(tmpDir, "CLAUDE.md"), existing);
+            writeInstructionFile(tmpDir, "claude-code");
+            const content = readFileSync(join(tmpDir, "CLAUDE.md"), "utf-8");
+            expect(content).toContain("# Header");
+            expect(content).toContain("# Footer");
+            expect(content).toContain("get_references");
+        });
+    });
+    describe("writeInstructionFile — mdc (cursor)", () => {
+        it("creates .cursor/rules/unerr-instructions.mdc", () => {
+            const result = writeInstructionFile(tmpDir, "cursor");
+            expect(result.action).toBe("created");
+            const content = readFileSync(result.path, "utf-8");
+            expect(content).toContain("alwaysApply: true");
+            expect(content).toContain("get_references");
+        });
+        it("skips when content is identical", () => {
+            writeInstructionFile(tmpDir, "cursor");
+            const result = writeInstructionFile(tmpDir, "cursor");
+            expect(result.action).toBe("skipped");
+        });
+        it("updates when content differs", () => {
+            const filePath = join(tmpDir, ".cursor", "rules", "unerr-instructions.mdc");
+            mkdirSync(join(tmpDir, ".cursor", "rules"), { recursive: true });
+            writeFileSync(filePath, "old mdc content");
+            const result = writeInstructionFile(tmpDir, "cursor");
+            expect(result.action).toBe("updated");
+            const content = readFileSync(filePath, "utf-8");
+            expect(content).toContain("alwaysApply: true");
+        });
+    });
+    describe("writeInstructionFile — windsurf-rule (windsurf)", () => {
+        it("creates .windsurf/rules/unerr-instructions.md with trigger frontmatter", () => {
+            const result = writeInstructionFile(tmpDir, "windsurf");
+            expect(result.action).toBe("created");
+            const content = readFileSync(result.path, "utf-8");
+            expect(content).toContain("trigger: always_on");
+            expect(content).toContain("get_references");
+        });
+        it("skips when content is identical", () => {
+            writeInstructionFile(tmpDir, "windsurf");
+            const result = writeInstructionFile(tmpDir, "windsurf");
+            expect(result.action).toBe("skipped");
+        });
+        it("updates when content differs", () => {
+            const filePath = join(tmpDir, ".windsurf", "rules", "unerr-instructions.md");
+            mkdirSync(join(tmpDir, ".windsurf", "rules"), { recursive: true });
+            writeFileSync(filePath, "old windsurf content");
+            const result = writeInstructionFile(tmpDir, "windsurf");
+            expect(result.action).toBe("updated");
+            const content = readFileSync(filePath, "utf-8");
+            expect(content).toContain("trigger: always_on");
+        });
+    });
+    describe("writeInstructionFile — agents without instruction files", () => {
+        it("returns skipped for zed", () => {
+            const result = writeInstructionFile(tmpDir, "zed");
+            expect(result.action).toBe("skipped");
+        });
+    });
+    describe("writeInstructionFile — other agents", () => {
+        it("creates AGENTS.md for codex", () => {
+            const result = writeInstructionFile(tmpDir, "codex");
+            expect(result.action).toBe("created");
+            expect(result.path).toContain("AGENTS.md");
+        });
+        it("creates GEMINI.md for gemini-cli", () => {
+            const result = writeInstructionFile(tmpDir, "gemini-cli");
+            expect(result.action).toBe("created");
+            expect(result.path).toContain("GEMINI.md");
+        });
+        it("creates .github/copilot-instructions.md for vscode", () => {
+            const result = writeInstructionFile(tmpDir, "vscode");
+            expect(result.action).toBe("created");
+            expect(result.path).toContain("copilot-instructions.md");
+        });
+        it("creates .clinerules for cline", () => {
+            const result = writeInstructionFile(tmpDir, "cline");
+            expect(result.action).toBe("created");
+            expect(result.path).toContain(".clinerules");
+        });
+    });
+    describe("removeInstructionSection", () => {
+        it("removes sentinel block from markdown file", () => {
+            const existing = "# Header\n\nSome content.\n";
+            writeFileSync(join(tmpDir, "CLAUDE.md"), existing);
+            writeInstructionFile(tmpDir, "claude-code");
+            const removed = removeInstructionSection(tmpDir, "claude-code");
+            expect(removed).toBe(true);
+            const content = readFileSync(join(tmpDir, "CLAUDE.md"), "utf-8");
+            expect(content).toContain("# Header");
+            expect(content).not.toContain("<!-- unerr:start -->");
+            expect(content).not.toContain("get_references");
+        });
+        it("deletes .mdc file for cursor", () => {
+            writeInstructionFile(tmpDir, "cursor");
+            const filePath = join(tmpDir, ".cursor", "rules", "unerr-instructions.mdc");
+            expect(existsSync(filePath)).toBe(true);
+            const removed = removeInstructionSection(tmpDir, "cursor");
+            expect(removed).toBe(true);
+            expect(existsSync(filePath)).toBe(false);
+        });
+        it("returns false when no instruction file exists", () => {
+            const removed = removeInstructionSection(tmpDir, "claude-code");
+            expect(removed).toBe(false);
+        });
+        it("removes windsurf-rule file", () => {
+            writeInstructionFile(tmpDir, "windsurf");
+            const filePath = join(tmpDir, ".windsurf", "rules", "unerr-instructions.md");
+            expect(existsSync(filePath)).toBe(true);
+            const removed = removeInstructionSection(tmpDir, "windsurf");
+            expect(removed).toBe(true);
+            expect(existsSync(filePath)).toBe(false);
+        });
+        it("returns false for agents without instruction files", () => {
+            const removed = removeInstructionSection(tmpDir, "zed");
+            expect(removed).toBe(false);
+        });
+        it("deletes file if only sentinel content remains", () => {
+            writeInstructionFile(tmpDir, "claude-code");
+            const removed = removeInstructionSection(tmpDir, "claude-code");
+            expect(removed).toBe(true);
+            expect(existsSync(join(tmpDir, "CLAUDE.md"))).toBe(false);
+        });
+    });
+});

package/dist/__tests__/intelligence-integration.test.js

@@ -0,0 +1,217 @@
+/**
+ * Sprint P: Intelligence integration + performance tests.
+ *
+ * Tests the full pipeline: confidence propagation, response enrichment,
+ * computation scheduling, and performance benchmarks.
+ */
+import { describe, expect, it } from "vitest";
+import { buildReverseAdjacency, computeBlastRadius, } from "../intelligence/blast-radius.js";
+import { clearPending, getPendingCount, scheduleComputation, } from "../intelligence/computation-scheduler.js";
+import { confidenceToScore, propagateConfidence, } from "../intelligence/confidence-propagation.js";
+import { entityKey } from "../intelligence/indexer/entity-key.js";
+import { enrichResponse } from "../proxy/response-enrichment.js";
+describe("Confidence Propagation (P.10)", () => {
+    it("MIN across path: one heuristic → whole path is heuristic", () => {
+        const result = propagateConfidence([
+            "compiler-verified",
+            "structural",
+            "heuristic",
+            "structural",
+        ]);
+        expect(result.level).toBe("heuristic");
+        expect(result.edgeSources.heuristic).toBe(1);
+        expect(result.edgeSources.structural).toBe(2);
+        expect(result.pathLength).toBe(4);
+    });
+    it("all compiler-verified → compiler-verified result", () => {
+        const result = propagateConfidence([
+            "compiler-verified",
+            "compiler-verified",
+        ]);
+        expect(result.level).toBe("compiler-verified");
+    });
+    it("empty path → structural default", () => {
+        const result = propagateConfidence([]);
+        expect(result.level).toBe("structural");
+        expect(result.pathLength).toBe(0);
+    });
+    it("confidenceToScore maps correctly", () => {
+        expect(confidenceToScore("compiler-verified")).toBe(1.0);
+        expect(confidenceToScore("structural")).toBe(0.85);
+        expect(confidenceToScore("heuristic")).toBe(0.5);
+    });
+});
+describe("Response Enrichment (P.9)", () => {
+    it("enriches response with _meta block", () => {
+        const result = enrichResponse({ entities: ["a", "b"] }, {
+            confidence: "structural",
+            riskLevel: "high",
+            resolutionMs: 2.3,
+            edgeSources: { structural: 5 },
+        });
+        expect(result._meta.confidence).toBe("structural");
+        expect(result._meta.confidence_score).toBe(0.85);
+        expect(result._meta.risk_level).toBe("high");
+        expect(result._meta.resolution_ms).toBe(2.3);
+        expect(result._meta.edge_sources.structural).toBe(5);
+    });
+    it("includes _context when provided", () => {
+        const result = enrichResponse({}, {
+            confidence: "structural",
+            riskLevel: "normal",
+            resolutionMs: 1,
+            edgeSources: {},
+        }, { "dev.unerr/conventions": [{ name: "test" }] });
+        expect(result._context?.["dev.unerr/conventions"]).toBeDefined();
+    });
+    it("omits _context when empty", () => {
+        const result = enrichResponse({}, {
+            confidence: "structural",
+            riskLevel: "normal",
+            resolutionMs: 1,
+            edgeSources: {},
+        });
+        expect(result._context).toBeUndefined();
+    });
+});
+describe("Computation Scheduler (P.11)", () => {
+    it("executes critical computations immediately", async () => {
+        let executed = false;
+        const ran = await scheduleComputation("test-critical", "critical", async () => {
+            executed = true;
+        });
+        expect(ran).toBe(true);
+        expect(executed).toBe(true);
+    });
+    it("executes normal computations when resources available", async () => {
+        let executed = false;
+        const ran = await scheduleComputation("test-normal", "normal", async () => {
+            executed = true;
+        });
+        expect(ran).toBe(true);
+        expect(executed).toBe(true);
+    });
+    it("getPendingCount reflects queue", () => {
+        clearPending();
+        expect(getPendingCount()).toBe(0);
+    });
+});
+describe("Performance: Blast Radius <5ms (P.12)", () => {
+    it("200-entity graph blast radius completes in <5ms", () => {
+        const target = {
+            key: entityKey("center.ts", "function", "center", ""),
+            kind: "function",
+            name: "center",
+            file_path: "center.ts",
+            start_line: 1,
+            end_line: 5,
+            signature: "center()",
+            body_hash: "h",
+            exported: true,
+            parent_key: null,
+            language: "typescript",
+            is_async: false,
+            parameter_count: 0,
+            doc: null,
+            community: 0,
+            risk_level: "high",
+        };
+        const allEntities = [target];
+        const allEdges = [];
+        for (let i = 0; i < 200; i++) {
+            const caller = {
+                ...target,
+                key: entityKey(`f${i}.ts`, "function", `fn${i}`, ""),
+                name: `fn${i}`,
+                file_path: `f${i}.ts`,
+            };
+            allEntities.push(caller);
+            allEdges.push({
+                from_key: caller.key,
+                to_key: target.key,
+                type: "calls",
+                file_path: caller.file_path,
+                line: 1,
+            });
+        }
+        const entities = new Map(allEntities.map((e) => [e.key, e]));
+        const adj = buildReverseAdjacency(allEdges);
+        const start = performance.now();
+        const result = computeBlastRadius(target.key, entities, adj, {
+            maxHops: 2,
+        });
+        const elapsed = performance.now() - start;
+        expect(result.totalAffected).toBe(200);
+        expect(elapsed).toBeLessThan(5);
+    });
+});
+describe("End-to-End Pipeline (P.13)", () => {
+    it("index → query → enriched response with confidence", () => {
+        const entities = new Map([
+            [
+                "target",
+                {
+                    key: "target",
+                    kind: "function",
+                    name: "processOrder",
+                    file_path: "src/orders.ts",
+                    start_line: 1,
+                    end_line: 10,
+                    signature: "processOrder()",
+                    body_hash: "h",
+                    exported: true,
+                    parent_key: null,
+                    language: "typescript",
+                    is_async: true,
+                    parameter_count: 1,
+                    doc: null,
+                    community: 0,
+                    risk_level: "high",
+                },
+            ],
+            [
+                "caller",
+                {
+                    key: "caller",
+                    kind: "function",
+                    name: "checkout",
+                    file_path: "src/checkout.ts",
+                    start_line: 1,
+                    end_line: 5,
+                    signature: "checkout()",
+                    body_hash: "h2",
+                    exported: true,
+                    parent_key: null,
+                    language: "typescript",
+                    is_async: true,
+                    parameter_count: 0,
+                    doc: null,
+                    community: 1,
+                    risk_level: "normal",
+                },
+            ],
+        ]);
+        const edges = [
+            {
+                from_key: "caller",
+                to_key: "target",
+                type: "calls",
+                file_path: "src/checkout.ts",
+                line: 3,
+            },
+        ];
+        const adj = buildReverseAdjacency(edges);
+        const blastResult = computeBlastRadius("target", entities, adj);
+        const confidence = propagateConfidence(["structural"]);
+        const enriched = enrichResponse(blastResult, {
+            confidence: confidence.level,
+            riskLevel: "high",
+            resolutionMs: blastResult.resolvedInMs,
+            edgeSources: confidence.edgeSources,
+        });
+        expect(enriched._meta.confidence).toBe("structural");
+        expect(enriched._meta.risk_level).toBe("high");
+        expect(enriched._meta.resolution_ms).toBeGreaterThanOrEqual(0);
+        expect(enriched.content.totalAffected).toBe(1);
+    });
+});

package/dist/__tests__/intent-correlator.test.js

@@ -0,0 +1,175 @@
+/**
+ * P10-TEST-04: Intent Correlator tests — chain building, pending correlations.
+ */
+import { existsSync, mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { IntentCorrelator } from "../tracking/intent-correlator.js";
+import { ShadowLedger } from "../tracking/shadow-ledger.js";
+let tempDir;
+let unerrDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-correlator-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    unerrDir = join(tempDir, ".unerr");
+    mkdirSync(unerrDir, { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+});
+describe("IntentCorrelator", () => {
+    it("creates pending correlation on sync_local_diff", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        // Record a root intent and a sync
+        ledger.record("get_function", { key: "abc" }, { found: true }, "main", "aaa");
+        ledger.record("sync_local_diff", {
+            prompt: "Fix the auth bug",
+            files: [{ path: "src/auth.ts", content: "..." }],
+            entitiesAffected: ["auth::login"],
+        }, {}, "main", "aaa");
+        const result = correlator.onSyncLocalDiff(ledger, {
+            prompt: "Fix the auth bug",
+            files: [{ path: "src/auth.ts", content: "..." }],
+            entitiesAffected: ["auth::login"],
+        });
+        expect(result).not.toBeNull();
+        expect(result?.prompt).toBe("Fix the auth bug");
+        expect(result?.files).toEqual(["src/auth.ts"]);
+        expect(result?.entities).toEqual(["auth::login"]);
+        expect(result?.toolChain.length).toBeGreaterThan(0);
+    });
+    it("extracts files from structured format", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        const result = correlator.onSyncLocalDiff(ledger, {
+            files: [
+                { path: "src/a.ts", content: "code" },
+                { path: "src/b.ts", content: "code" },
+            ],
+        });
+        expect(result).not.toBeNull();
+        expect(result?.files).toEqual(["src/a.ts", "src/b.ts"]);
+    });
+    it("extracts files from diff format", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        const diff = `--- a/src/auth.ts
++++ b/src/auth.ts
+@@ -1,3 +1,4 @@
++import { foo } from "bar"
+ export function login() {}`;
+        const result = correlator.onSyncLocalDiff(ledger, { diff });
+        expect(result).not.toBeNull();
+        expect(result?.files).toContain("src/auth.ts");
+    });
+    it("getPending returns only uncommitted correlations", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "a.ts", content: "" }],
+        });
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "b.ts", content: "" }],
+        });
+        expect(correlator.getPending()).toHaveLength(2);
+        expect(correlator.getPendingCount()).toBe(2);
+    });
+    it("associateCommit links correlations by overlapping files", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "src/a.ts", content: "" }],
+        });
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "src/b.ts", content: "" }],
+        });
+        // Commit only includes a.ts
+        const associated = correlator.associateCommit("commit123", ["src/a.ts"]);
+        expect(associated).toBe(1);
+        // One pending, one committed
+        expect(correlator.getPending()).toHaveLength(1);
+        expect(correlator.getCommittedUnflushed()).toHaveLength(1);
+        expect(correlator.getCommittedUnflushed()[0]?.commitSha).toBe("commit123");
+    });
+    it("removeFlushed clears committed correlations", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        const c1 = correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "a.ts", content: "" }],
+        });
+        correlator.associateCommit("commit123", ["a.ts"]);
+        correlator.removeFlushed([c1.rootIntentId]);
+        expect(correlator.getAll()).toHaveLength(0);
+    });
+    it("clear removes all correlations", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "a.ts", content: "" }],
+        });
+        correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "b.ts", content: "" }],
+        });
+        correlator.clear();
+        expect(correlator.getAll()).toHaveLength(0);
+        expect(correlator.getPendingCount()).toBe(0);
+    });
+    it("persists to disk and loads on new instance", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator1 = new IntentCorrelator(unerrDir);
+        ledger.record("get_function", {}, {}, "main", "aaa");
+        correlator1.onSyncLocalDiff(ledger, {
+            prompt: "Fix bug",
+            files: [{ path: "src/fix.ts", content: "" }],
+        });
+        // Verify file exists
+        const pendingPath = join(unerrDir, "ledger", "pending_correlations.json");
+        expect(existsSync(pendingPath)).toBe(true);
+        // New instance should load persisted data
+        const correlator2 = new IntentCorrelator(unerrDir);
+        expect(correlator2.getPendingCount()).toBe(1);
+        expect(correlator2.getPending()[0]?.prompt).toBe("Fix bug");
+    });
+    it("returns null when no root intent exists", () => {
+        // Create a ledger but don't record anything — getCurrentRootId() returns null
+        // We need a fresh ledger with no entries so root ID is null
+        const ledgerDir = join(unerrDir, "ledger");
+        mkdirSync(ledgerDir, { recursive: true });
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        // Don't record any entries — root ID should be null
+        // Actually we need to check: a fresh ShadowLedger has currentRootId = null
+        // But onSyncLocalDiff checks getCurrentRootId() which would be null
+        const result = correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "a.ts", content: "" }],
+        });
+        expect(result).toBeNull();
+    });
+    it("builds tool chain from correlated entries", () => {
+        const ledger = new ShadowLedger(unerrDir);
+        const correlator = new IntentCorrelator(unerrDir);
+        // Build a chain: root → child1 → child2 → sync
+        ledger.record("get_function", { key: "abc" }, { found: true }, "main", "aaa");
+        ledger.record("get_callers", { key: "abc" }, { count: 3 }, "main", "aaa");
+        ledger.record("get_file", { key: "file1" }, { found: true }, "main", "aaa");
+        const result = correlator.onSyncLocalDiff(ledger, {
+            files: [{ path: "src/a.ts", content: "" }],
+        });
+        expect(result).not.toBeNull();
+        // Chain should include root + correlated entries
+        expect(result?.toolChain.length).toBeGreaterThanOrEqual(1);
+        expect(result?.toolChain).toContain("get_function");
+    });
+});