@unerr-ai/unerr 0.1.6 → 0.1.7

package/dist/__tests__/layer3-sprint-u.test.js

@@ -1,174 +0,0 @@
-/**
- * Layer 3 Sprint U: Persistent Intelligence (Cross-Session) tests.
- */
-import { describe, expect, it } from "vitest";
-import { evaluateForPromotion, shouldPromote, } from "../intelligence/rule-generator.js";
-import { createContextRotDetector } from "../proxy/context-rot-detector.js";
-import { createDurabilityTracker } from "../tracking/durability-tracker.js";
-describe("Auto-Rule Generation (U.6)", () => {
-    it("promotes corrections with high confidence + occurrences", () => {
-        const corrections = [
-            {
-                entityKey: "src/auth.ts::login",
-                pattern: "rename",
-                description: "Use 'authenticate' instead of 'login'",
-                occurrences: 4,
-                confidence: 0.95,
-            },
-        ];
-        const rules = evaluateForPromotion(corrections);
-        expect(rules).toHaveLength(1);
-        expect(rules[0]?.severity).toBe("warn");
-        expect(rules[0]?.source).toBe("correction-auto");
-    });
-    it("does not promote low-confidence corrections", () => {
-        const corrections = [
-            {
-                entityKey: "src/a.ts::fn",
-                pattern: "rename",
-                description: "test",
-                occurrences: 5,
-                confidence: 0.6,
-            },
-        ];
-        expect(evaluateForPromotion(corrections)).toHaveLength(0);
-    });
-    it("does not promote low-occurrence corrections", () => {
-        const corrections = [
-            {
-                entityKey: "src/b.ts::fn",
-                pattern: "rename",
-                description: "test",
-                occurrences: 1,
-                confidence: 0.95,
-            },
-        ];
-        expect(evaluateForPromotion(corrections)).toHaveLength(0);
-    });
-    it("shouldPromote checks thresholds", () => {
-        expect(shouldPromote({
-            entityKey: "x",
-            pattern: "p",
-            description: "d",
-            occurrences: 3,
-            confidence: 0.9,
-        })).toBe(true);
-        expect(shouldPromote({
-            entityKey: "x",
-            pattern: "p",
-            description: "d",
-            occurrences: 2,
-            confidence: 0.9,
-        })).toBe(false);
-    });
-});
-describe("Durability Tracker (U.7-U.8)", () => {
-    it("records modifications and computes score", () => {
-        const tracker = createDurabilityTracker();
-        tracker.recordModification("entity-a", "session-1", "hash1");
-        tracker.recordModification("entity-a", "session-2", "hash2");
-        const result = tracker.getScore("entity-a");
-        expect(result).not.toBeNull();
-        expect(result?.totalModifications).toBe(2);
-        expect(result?.pending).toBe(2);
-    });
-    it("evaluates survival correctly", () => {
-        const tracker = createDurabilityTracker();
-        tracker.recordModification("entity-b", "s1", "hashOriginal");
-        const mods = tracker.records ?? new Map();
-        tracker.evaluateSurvival("entity-b", "hashOriginal");
-    });
-    it("returns null for unknown entities", () => {
-        const tracker = createDurabilityTracker();
-        expect(tracker.getScore("nonexistent")).toBeNull();
-    });
-    it("getLowDurabilityEntities filters below threshold", () => {
-        const tracker = createDurabilityTracker();
-        tracker.recordModification("fragile", "s1", "h1");
-        tracker.recordModification("fragile", "s2", "h2");
-        const low = tracker.getLowDurabilityEntities(0.5);
-        expect(low.length).toBeGreaterThanOrEqual(0);
-    });
-    it("getAllScores returns map", () => {
-        const tracker = createDurabilityTracker();
-        tracker.recordModification("e1", "s1", "h1");
-        tracker.recordModification("e2", "s1", "h2");
-        const scores = tracker.getAllScores();
-        expect(scores.size).toBe(2);
-    });
-});
-describe("Context Rot Detector (U.14-U.15)", () => {
-    it("starts with zero rot", () => {
-        const detector = createContextRotDetector();
-        const signal = detector.evaluate();
-        expect(signal.rotConfidence).toBe(0);
-        expect(signal.action).toBe("none");
-    });
-    it("detects depth threshold warning", () => {
-        const detector = createContextRotDetector();
-        detector.recordToolCallTokens(250_000);
-        const signal = detector.evaluate();
-        expect(signal.rotConfidence).toBeGreaterThan(0);
-        expect(signal.signals.some((s) => s.type === "depth_threshold")).toBe(true);
-    });
-    it("detects critical depth", () => {
-        const detector = createContextRotDetector();
-        detector.recordToolCallTokens(350_000);
-        const signal = detector.evaluate();
-        expect(signal.rotConfidence).toBeGreaterThanOrEqual(0.4);
-    });
-    it("detects repeated exploration", () => {
-        const detector = createContextRotDetector();
-        for (let i = 0; i < 5; i++) {
-            detector.recordRepeatedQuery("entity-x");
-        }
-        const signal = detector.evaluate();
-        expect(signal.signals.some((s) => s.type === "repeated_exploration")).toBe(true);
-    });
-    it("triggers inject_refresh at moderate rot", () => {
-        const detector = createContextRotDetector();
-        detector.recordToolCallTokens(250_000);
-        for (let i = 0; i < 4; i++)
-            detector.recordRepeatedQuery("entity-y");
-        detector.recordError();
-        detector.recordError();
-        detector.recordError();
-        detector.recordError();
-        detector.recordError();
-        const signal = detector.evaluate();
-        expect(["inject_refresh", "suggest_new_session"]).toContain(signal.action);
-    });
-    it("triggers suggest_new_session at severe rot", () => {
-        const detector = createContextRotDetector();
-        detector.recordToolCallTokens(350_000);
-        for (let i = 0; i < 5; i++)
-            detector.recordRepeatedQuery(`ent-${i}`);
-        for (let i = 0; i < 6; i++)
-            detector.recordError();
-        detector.recordForgottenContext("blast_radius", Date.now() - 60000);
-        detector.recordConventionViolationAfterDelivery("camelCase");
-        const signal = detector.evaluate();
-        expect(signal.rotConfidence).toBeGreaterThan(0.7);
-        expect(signal.action).toBe("suggest_new_session");
-    });
-    it("provides refresh context when triggered", () => {
-        const detector = createContextRotDetector();
-        detector.recordToolCallTokens(250_000);
-        for (let i = 0; i < 4; i++)
-            detector.recordRepeatedQuery("stale-entity");
-        detector.evaluate();
-        const ctx = detector.getRefreshContext();
-        if (ctx) {
-            expect(ctx.reason).toBeTruthy();
-            expect(ctx.estimated_depth).toBeGreaterThan(0);
-        }
-    });
-    it("resets cleanly", () => {
-        const detector = createContextRotDetector();
-        detector.recordToolCallTokens(500_000);
-        detector.reset();
-        const signal = detector.evaluate();
-        expect(signal.estimatedDepth).toBe(0);
-        expect(signal.rotConfidence).toBe(0);
-    });
-});

package/dist/__tests__/layer4-sprint-ba2.test.js

@@ -1,354 +0,0 @@
-/**
- * Sprint BA-2: Quality Compound tests.
- *
- * Tests for:
- *   BA-2.1 — Incomplete Work Detection
- *   BA-2.2 — Convention Drift Prevention
- *   BA-2.3 — Auto-Documentation Generation
- */
-import { mkdirSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { beforeEach, describe, expect, it } from "vitest";
-import { AutoDocBehavior } from "../behaviors/auto-doc.js";
-import { ConventionDriftPrevention } from "../behaviors/convention-drift.js";
-import { IncompleteWorkDetector } from "../behaviors/incomplete-work.js";
-import { ShadowLedger } from "../tracking/shadow-ledger.js";
-function makeTmpDir() {
-    const dir = join(tmpdir(), `unerr-test-ba2-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(dir, { recursive: true });
-    return dir;
-}
-function makeCtx(overrides = {}) {
-    return {
-        toolName: "edit_file",
-        args: {},
-        sessionId: "test-session",
-        ...overrides,
-    };
-}
-// ── BA-2.1: Incomplete Work Detection ───────────────────────────
-describe("Incomplete Work Detection (BA-2.1)", () => {
-    let tmpDir;
-    beforeEach(() => {
-        tmpDir = makeTmpDir();
-    });
-    describe("Behavior Identity", () => {
-        it("has correct id and hooks", () => {
-            const detector = new IncompleteWorkDetector();
-            expect(detector.id).toBe("incomplete_work");
-            expect(detector.hooks).toContain("session_end");
-            expect(detector.defaultLevel).toBe("suggestion");
-        });
-    });
-    describe("Orphaned Import Detection", () => {
-        it("detects imports from deleted files", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            ledger.record("delete_file", { path: "src/utils/removed-module.ts" }, { success: true }, "main", "abc123");
-            const detector = new IncompleteWorkDetector();
-            detector.attachLedger(ledger);
-            detector.setUnerrDir(tmpDir);
-            const output = await detector.onSessionEnd(makeCtx());
-            if (output) {
-                const items = output._context?.incomplete_items;
-                if (items) {
-                    const orphans = items.filter((i) => i.type === "orphaned_import");
-                    for (const orphan of orphans) {
-                        expect(orphan.severity).toBe("medium");
-                    }
-                }
-            }
-        });
-    });
-    describe("Persistence", () => {
-        it("persists incomplete items to disk for next session", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            ledger.record("delete_file", { path: "src/deleted.ts" }, { success: true }, "main", "abc123");
-            const detector = new IncompleteWorkDetector();
-            detector.attachLedger(ledger);
-            detector.setUnerrDir(tmpDir);
-            await detector.onSessionEnd(makeCtx());
-            const persisted = IncompleteWorkDetector.readPersistedItems(tmpDir);
-            expect(Array.isArray(persisted)).toBe(true);
-        });
-        it("readPersistedItems returns empty array when no file exists", () => {
-            const items = IncompleteWorkDetector.readPersistedItems(join(tmpDir, "nonexistent"));
-            expect(items).toEqual([]);
-        });
-    });
-    describe("Empty Session", () => {
-        it("returns null when no issues found", async () => {
-            const ledger = new ShadowLedger(tmpDir);
-            ledger.record("get_entity", { key: "src/safe.ts::func" }, { found: true }, "main", "abc123");
-            const detector = new IncompleteWorkDetector();
-            detector.attachLedger(ledger);
-            detector.setUnerrDir(tmpDir);
-            const output = await detector.onSessionEnd(makeCtx());
-            expect(output).toBeNull();
-        });
-    });
-    describe("Severity Ordering", () => {
-        it("sorts items by severity: high first, low last", async () => {
-            const detector = new IncompleteWorkDetector();
-            const output = await detector.onSessionEnd(makeCtx());
-            if (output) {
-                const items = output._context?.incomplete_items;
-                if (items && items.length > 1) {
-                    const severityOrder = items.map((i) => i.severity);
-                    const highIdx = severityOrder.indexOf("high");
-                    const lowIdx = severityOrder.indexOf("low");
-                    if (highIdx >= 0 && lowIdx >= 0) {
-                        expect(highIdx).toBeLessThan(lowIdx);
-                    }
-                }
-            }
-        });
-    });
-});
-// ── BA-2.2: Convention Drift Prevention ─────────────────────────
-describe("Convention Drift Prevention (BA-2.2)", () => {
-    describe("Behavior Identity", () => {
-        it("has correct id and hooks", () => {
-            const behavior = new ConventionDriftPrevention();
-            expect(behavior.id).toBe("convention_drift");
-            expect(behavior.hooks).toContain("post_tool_use");
-            expect(behavior.defaultLevel).toBe("suggestion");
-        });
-    });
-    describe("Naming Convention Detection", () => {
-        it("detects snake_case in a camelCase codebase", async () => {
-            const behavior = new ConventionDriftPrevention();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/payment.ts",
-                args: {
-                    path: "src/payment.ts",
-                    new_str: "export function process_payment(amount: number) { return amount; }",
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            // Without a graph attached, it can't detect conventions — this is expected
-            // The behavior degrades gracefully
-            expect(output).toBeNull();
-        });
-        it("returns null for non-edit tools", async () => {
-            const behavior = new ConventionDriftPrevention();
-            const ctx = makeCtx({
-                toolName: "get_entity",
-                filePath: "src/payment.ts",
-                args: { key: "src/payment.ts::processPayment" },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).toBeNull();
-        });
-        it("returns null for non-code files", async () => {
-            const behavior = new ConventionDriftPrevention();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "docs/README.md",
-                args: {
-                    path: "docs/README.md",
-                    new_str: "# Updated readme",
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).toBeNull();
-        });
-        it("returns null when no new content is provided", async () => {
-            const behavior = new ConventionDriftPrevention();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/payment.ts",
-                args: { path: "src/payment.ts" },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).toBeNull();
-        });
-    });
-    describe("Auto-Fix Threshold", () => {
-        it("auto-fix threshold is 0.9 by default", () => {
-            const behavior = new ConventionDriftPrevention();
-            expect(behavior.getSessionStats().autoFixes).toBe(0);
-        });
-        it("accepts custom confidence threshold", () => {
-            const behavior = new ConventionDriftPrevention({
-                confidenceThreshold: 0.95,
-            });
-            expect(behavior.enabled).toBe(true);
-        });
-    });
-    describe("Session Stats", () => {
-        it("starts with zero violations", () => {
-            const behavior = new ConventionDriftPrevention();
-            const stats = behavior.getSessionStats();
-            expect(stats.violationsDetected).toBe(0);
-            expect(stats.autoFixes).toBe(0);
-        });
-    });
-    describe("Learning Loop", () => {
-        it("tracks feedback correctly", () => {
-            const behavior = new ConventionDriftPrevention();
-            behavior.recordFeedback("accepted");
-            behavior.recordFeedback("accepted");
-            behavior.recordFeedback("dismissed");
-            const stats = behavior.getLearningStats();
-            expect(stats.accepted).toBe(2);
-            expect(stats.dismissed).toBe(1);
-            expect(stats.confidence).toBeCloseTo(2 / 3, 2);
-        });
-    });
-});
-// ── BA-2.3: Auto-Documentation Generation ───────────────────────
-describe("Auto-Documentation Generation (BA-2.3)", () => {
-    describe("Behavior Identity", () => {
-        it("has correct id and hooks", () => {
-            const behavior = new AutoDocBehavior();
-            expect(behavior.id).toBe("auto_doc");
-            expect(behavior.hooks).toContain("post_tool_use");
-            expect(behavior.defaultLevel).toBe("invisible");
-        });
-    });
-    describe("JSDoc Generation", () => {
-        it("detects exported function without docs", async () => {
-            const behavior = new AutoDocBehavior();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/payment.ts",
-                args: {
-                    path: "src/payment.ts",
-                    new_str: `export function processPayment(amount: number, currency: string): Promise<Receipt> {
-  return gateway.charge(amount, currency);
-}`,
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).not.toBeNull();
-            expect(output?._meta?.behavior).toBe("auto_doc");
-            expect(output?._meta?.docs_updated).toBeGreaterThanOrEqual(1);
-            const actions = output?._context?.doc_actions;
-            expect(actions).toBeDefined();
-            expect(actions.some((a) => a.entity === "processPayment")).toBe(true);
-        });
-        it("does not flag functions with existing JSDoc", async () => {
-            const behavior = new AutoDocBehavior();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/payment.ts",
-                args: {
-                    path: "src/payment.ts",
-                    new_str: `/**
- * Process a payment transaction.
- * @param amount The payment amount
- */
-export function processPayment(amount: number) {
-  return amount;
-}`,
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            // Should be null since JSDoc already exists and no graph to compare signatures
-            expect(output).toBeNull();
-        });
-        it("returns null for non-edit tools", async () => {
-            const behavior = new AutoDocBehavior();
-            const ctx = makeCtx({
-                toolName: "get_entity",
-                filePath: "src/payment.ts",
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).toBeNull();
-        });
-        it("returns null for non-code files", async () => {
-            const behavior = new AutoDocBehavior();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "README.md",
-                args: { path: "README.md", content: "# README" },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).toBeNull();
-        });
-    });
-    describe("Agent-as-LLM Prompt", () => {
-        it("includes agent prompt when useAgentAsLlm is enabled", async () => {
-            const behavior = new AutoDocBehavior({ useAgentAsLlm: true });
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/api.ts",
-                args: {
-                    path: "src/api.ts",
-                    new_str: `export function fetchUsers(limit: number, offset: number): Promise<User[]> {
-  return db.query('SELECT * FROM users LIMIT ? OFFSET ?', [limit, offset]);
-}`,
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).not.toBeNull();
-            const agentPrompt = output?._context?.agent_prompt;
-            expect(agentPrompt).toBeDefined();
-            expect(typeof agentPrompt).toBe("string");
-            expect(agentPrompt.length).toBeGreaterThan(0);
-        });
-        it("does NOT include agent prompt when useAgentAsLlm is disabled", async () => {
-            const behavior = new AutoDocBehavior({ useAgentAsLlm: false });
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/api.ts",
-                args: {
-                    path: "src/api.ts",
-                    new_str: `export function fetchUsers(limit: number, offset: number): Promise<User[]> {
-  return db.query('SELECT * FROM users LIMIT ? OFFSET ?', [limit, offset]);
-}`,
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).not.toBeNull();
-            const agentPrompt = output?._context?.agent_prompt;
-            expect(agentPrompt).toBeUndefined();
-        });
-    });
-    describe("Session Stats", () => {
-        it("tracks docs generated across calls", async () => {
-            const behavior = new AutoDocBehavior();
-            const ctx = makeCtx({
-                toolName: "edit_file",
-                filePath: "src/utils.ts",
-                args: {
-                    path: "src/utils.ts",
-                    new_str: `export function formatDate(date: Date, locale: string): string {
-  return date.toLocaleDateString(locale);
-}`,
-                },
-            });
-            await behavior.onPostToolUse(ctx);
-            const stats = behavior.getSessionStats();
-            expect(stats.docsGenerated).toBeGreaterThanOrEqual(1);
-        });
-    });
-    describe("Multiple Functions", () => {
-        it("detects multiple undocumented functions", async () => {
-            const behavior = new AutoDocBehavior();
-            const ctx = makeCtx({
-                toolName: "write_file",
-                filePath: "src/math.ts",
-                args: {
-                    path: "src/math.ts",
-                    content: `export function add(a: number, b: number): number {
-  return a + b;
-}
-
-export function multiply(x: number, y: number): number {
-  return x * y;
-}`,
-                },
-            });
-            const output = await behavior.onPostToolUse(ctx);
-            expect(output).not.toBeNull();
-            const actions = output?._context?.doc_actions;
-            expect(actions.length).toBeGreaterThanOrEqual(2);
-            const names = actions.map((a) => a.entity);
-            expect(names).toContain("add");
-            expect(names).toContain("multiply");
-        });
-    });
-});

package/dist/__tests__/layer4-sprint-ba4.test.js

@@ -1,84 +0,0 @@
-/**
- * Sprint BA-4 — Output Token Efficiency tests.
- * BA-4.1: token-efficient skill enhancements
- * BA-4.2: context_complete flag
- * BA-4.3: output format legend
- */
-import { describe, expect, it } from "vitest";
-import { formatToolOutput, } from "../proxy/format-encoder.js";
-import { OUTPUT_FORMAT_LEGEND, createSessionLegendTracker, } from "../proxy/session-legend.js";
-import { TOKEN_EFFICIENT_SKILL } from "../skills/local-pack.js";
-describe("BA-4.1: token-efficient skill", () => {
-    it("version is 1.1.0", () => {
-        expect(TOKEN_EFFICIENT_SKILL.version).toBe("1.1.0");
-    });
-    it("includes unified diff rule", () => {
-        expect(TOKEN_EFFICIENT_SKILL.instructions).toContain("unified diff format");
-        expect(TOKEN_EFFICIENT_SKILL.instructions).toContain("---/+++");
-    });
-    it("includes ur|ctx rule", () => {
-        expect(TOKEN_EFFICIENT_SKILL.instructions).toContain("ur|ctx");
-        expect(TOKEN_EFFICIENT_SKILL.instructions).toContain("proceed directly to the action");
-    });
-    it("has 9 instruction rules", () => {
-        const rules = TOKEN_EFFICIENT_SKILL.instructions.split("\n");
-        expect(rules).toHaveLength(9);
-    });
-});
-describe("BA-4.3: output format legend", () => {
-    it("consumeOutputFormatLegend fires once per session", () => {
-        const L = createSessionLegendTracker();
-        expect(L.consumeOutputFormatLegend()).toBe(true);
-        expect(L.consumeOutputFormatLegend()).toBe(false);
-    });
-    it("invalidateAll resets output format legend", () => {
-        const L = createSessionLegendTracker();
-        expect(L.consumeOutputFormatLegend()).toBe(true);
-        L.invalidateAll();
-        expect(L.consumeOutputFormatLegend()).toBe(true);
-    });
-    it("columnar and output format legends are independent", () => {
-        const L = createSessionLegendTracker();
-        expect(L.consumeColumnarLegend()).toBe(true);
-        expect(L.consumeOutputFormatLegend()).toBe(true);
-        // Both consumed — neither fires again
-        expect(L.consumeColumnarLegend()).toBe(false);
-        expect(L.consumeOutputFormatLegend()).toBe(false);
-    });
-    it("OUTPUT_FORMAT_LEGEND mentions ur|ctx and diff", () => {
-        expect(OUTPUT_FORMAT_LEGEND).toContain("ur|ctx");
-        expect(OUTPUT_FORMAT_LEGEND).toContain("unified diff");
-    });
-    it("formatToolOutput attaches output_format_legend on first call", () => {
-        const legend = createSessionLegendTracker();
-        const meta = {};
-        formatToolOutput("get_callers", [{ k: "a", v: 1 }], meta, {
-            legend,
-            tier: "columnar",
-        });
-        expect(meta.output_format_legend).toBe(OUTPUT_FORMAT_LEGEND);
-        // Second call — no legend
-        const meta2 = {};
-        formatToolOutput("get_callers", [{ k: "b", v: 2 }], meta2, {
-            legend,
-            tier: "columnar",
-        });
-        expect(meta2.output_format_legend).toBeUndefined();
-    });
-    it("formatToolOutput re-attaches legend after invalidation", () => {
-        const legend = createSessionLegendTracker();
-        const meta1 = {};
-        formatToolOutput("get_callers", [{ k: "a", v: 1 }], meta1, {
-            legend,
-            tier: "columnar",
-        });
-        expect(meta1.output_format_legend).toBe(OUTPUT_FORMAT_LEGEND);
-        legend.invalidateAll();
-        const meta2 = {};
-        formatToolOutput("get_callers", [{ k: "b", v: 2 }], meta2, {
-            legend,
-            tier: "columnar",
-        });
-        expect(meta2.output_format_legend).toBe(OUTPUT_FORMAT_LEGEND);
-    });
-});