@unerr-ai/unerr 0.1.6 → 0.1.7

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

@@ -1,179 +0,0 @@
-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

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

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