@unerr-ai/unerr 0.0.1 → 0.1.1

package/dist/__tests__/loop-miner.test.js

@@ -0,0 +1,226 @@
+/**
+ * ST-3a: Loop miner — file rereads + repeated search_code queries.
+ */
+import { describe, expect, it } from "vitest";
+import { detectFileReadLoops, detectLoops, detectQueryLoops, } from "../timeline/loop-miner.js";
+let idCounter = 0;
+function entry(overrides) {
+    idCounter += 1;
+    return {
+        id: `e${idCounter}`,
+        ts: overrides.ts,
+        tool: overrides.tool,
+        args_summary: overrides.args_summary ?? {},
+        result_summary: overrides.result_summary ?? {},
+        branch: "main",
+        head_sha: "abc",
+        session_id: overrides.session_id ?? "s1",
+        correlation_id: overrides.correlation_id ?? null,
+    };
+}
+const t = (offsetSec) => new Date(Date.parse("2026-05-12T10:00:00Z") + offsetSec * 1000).toISOString();
+describe("detectFileReadLoops", () => {
+    it("flags ≥5 reads of the same file with no edit in between", () => {
+        const entries = [
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "auth.ts" },
+                ts: t(0),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "auth.ts" },
+                ts: t(10),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "auth.ts" },
+                ts: t(30),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "auth.ts" },
+                ts: t(60),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "auth.ts" },
+                ts: t(90),
+            }),
+        ];
+        const loops = detectFileReadLoops(entries);
+        expect(loops).toHaveLength(1);
+        expect(loops[0]).toMatchObject({
+            kind: "file_reread",
+            file_path: "auth.ts",
+            count: 5,
+            session_id: "s1",
+        });
+    });
+    it("an edit between reads resets the run", () => {
+        const entries = [
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(0),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(10),
+            }),
+            entry({ tool: "Edit", args_summary: { file_path: "a.ts" }, ts: t(20) }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(30),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(40),
+            }),
+        ];
+        expect(detectFileReadLoops(entries)).toEqual([]);
+    });
+    it("isolates loops per session", () => {
+        const entries = [];
+        for (let i = 0; i < 5; i++) {
+            entries.push(entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(i * 10),
+                session_id: "s1",
+            }));
+            entries.push(entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(i * 10 + 1),
+                session_id: "s2",
+            }));
+        }
+        const loops = detectFileReadLoops(entries);
+        const sessions = new Set(loops.map((l) => l.session_id));
+        expect(sessions).toEqual(new Set(["s1", "s2"]));
+        expect(loops).toHaveLength(2);
+    });
+    it("ignores entries outside the time window", () => {
+        const entries = [];
+        for (let i = 0; i < 5; i++) {
+            entries.push(entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(i * 10),
+            }));
+        }
+        // Force "now" to be far in the future
+        const loops = detectFileReadLoops(entries, {
+            nowMs: Date.parse(t(0)) + 30 * 60_000, // 30 min after
+            readWindowMs: 60_000, // 1 min window
+        });
+        expect(loops).toEqual([]);
+    });
+    it("does not flag under the threshold", () => {
+        const entries = [
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(0),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(10),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(20),
+            }),
+        ];
+        expect(detectFileReadLoops(entries)).toEqual([]);
+    });
+});
+describe("detectQueryLoops", () => {
+    it("flags ≥3 same search_code queries", () => {
+        const entries = [
+            entry({
+                tool: "search_code",
+                args_summary: { query: "validateToken" },
+                ts: t(0),
+            }),
+            entry({
+                tool: "search_code",
+                args_summary: { query: "validateToken" },
+                ts: t(120),
+            }),
+            entry({
+                tool: "search_code",
+                args_summary: { query: "validateToken" },
+                ts: t(300),
+            }),
+        ];
+        const loops = detectQueryLoops(entries);
+        expect(loops).toHaveLength(1);
+        expect(loops[0]).toMatchObject({
+            kind: "search_repeat",
+            query: "validateToken",
+            count: 3,
+        });
+    });
+    it("different queries don't merge", () => {
+        const entries = [
+            entry({ tool: "search_code", args_summary: { query: "a" }, ts: t(0) }),
+            entry({ tool: "search_code", args_summary: { query: "b" }, ts: t(10) }),
+            entry({ tool: "search_code", args_summary: { query: "a" }, ts: t(20) }),
+            entry({ tool: "search_code", args_summary: { query: "b" }, ts: t(30) }),
+        ];
+        expect(detectQueryLoops(entries)).toEqual([]);
+    });
+    it("non-search_code entries are ignored", () => {
+        const entries = [
+            entry({ tool: "file_read", args_summary: { query: "foo" }, ts: t(0) }),
+            entry({ tool: "file_read", args_summary: { query: "foo" }, ts: t(10) }),
+            entry({ tool: "file_read", args_summary: { query: "foo" }, ts: t(20) }),
+        ];
+        expect(detectQueryLoops(entries)).toEqual([]);
+    });
+});
+describe("detectLoops (union)", () => {
+    it("returns both detections sorted by last_ts desc", () => {
+        const entries = [
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(0),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(10),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(20),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(30),
+            }),
+            entry({
+                tool: "file_read",
+                args_summary: { file_path: "a.ts" },
+                ts: t(40),
+            }),
+            entry({ tool: "search_code", args_summary: { query: "X" }, ts: t(100) }),
+            entry({ tool: "search_code", args_summary: { query: "X" }, ts: t(200) }),
+            entry({ tool: "search_code", args_summary: { query: "X" }, ts: t(300) }),
+        ];
+        const loops = detectLoops(entries);
+        expect(loops).toHaveLength(2);
+        expect(loops[0]?.kind).toBe("search_repeat");
+        expect(loops[1]?.kind).toBe("file_reread");
+    });
+});

package/dist/__tests__/mcp-config.test.js

@@ -0,0 +1,126 @@
+/**
+ * Tests for MCP local proxy config (Task 0.4).
+ */
+import { 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";
+describe("MCP Local Proxy Configuration", () => {
+    let tempDir;
+    beforeEach(() => {
+        tempDir = join(tmpdir(), `unerr-test-mcp-${Date.now()}`);
+        mkdirSync(tempDir, { recursive: true });
+    });
+    afterEach(() => {
+        rmSync(tempDir, { recursive: true, force: true });
+    });
+    it("generates correct local proxy config for Cursor", () => {
+        const mcpConfig = {
+            mcpServers: {
+                unerr: {
+                    command: "npx",
+                    args: ["@unerr/unerr"],
+                    env: {},
+                },
+            },
+        };
+        const configPath = join(tempDir, "mcp.json");
+        writeFileSync(configPath, JSON.stringify(mcpConfig, null, 2));
+        const parsed = JSON.parse(readFileSync(configPath, "utf-8"));
+        const unerr = parsed.mcpServers.unerr;
+        expect(unerr.command).toBe("npx");
+        expect(unerr.args).toEqual(["@unerr/unerr"]);
+        // Must NOT have a url property (local proxy, not remote)
+        expect(unerr.url).toBeUndefined();
+    });
+    it("detects remote URL config needing migration", () => {
+        const cloudConfig = {
+            mcpServers: {
+                unerr: {
+                    url: "https://app.unerr.dev/mcp/org-123",
+                },
+            },
+        };
+        const unerr = cloudConfig.mcpServers.unerr;
+        // Remote config has url but no command — needs migration
+        const needsMigration = !!unerr.url && !("command" in unerr);
+        expect(needsMigration).toBe(true);
+    });
+    it("local proxy config does NOT need migration", () => {
+        const localConfig = {
+            mcpServers: {
+                unerr: {
+                    command: "npx",
+                    args: ["@unerr/unerr"],
+                },
+            },
+        };
+        const unerr = localConfig.mcpServers.unerr;
+        const needsMigration = !!("url" in unerr) && !("command" in unerr);
+        expect(needsMigration).toBe(false);
+    });
+    it("preserves existing MCP servers when adding unerr", () => {
+        const existing = {
+            mcpServers: {
+                "other-server": {
+                    command: "node",
+                    args: ["other-server.js"],
+                },
+            },
+        };
+        // Simulate upsert
+        const updated = {
+            ...existing,
+            mcpServers: {
+                ...existing.mcpServers,
+                unerr: {
+                    command: "npx",
+                    args: ["@unerr/unerr"],
+                    env: {},
+                },
+            },
+        };
+        expect(updated.mcpServers["other-server"]).toBeDefined();
+        expect(updated.mcpServers.unerr).toBeDefined();
+        expect(Object.keys(updated.mcpServers)).toHaveLength(2);
+    });
+    it("config-verify repair writes local proxy config", async () => {
+        // Create a mock IDE config directory
+        const ideDir = join(tempDir, ".cursor");
+        mkdirSync(ideDir, { recursive: true });
+        // Write a remote config that needs migration
+        const configPath = join(ideDir, "mcp.json");
+        writeFileSync(configPath, JSON.stringify({
+            mcpServers: {
+                unerr: { url: "https://app.unerr.dev/mcp/org-123" },
+            },
+        }));
+        // Simulate repair by writing local proxy config
+        const config = JSON.parse(readFileSync(configPath, "utf-8"));
+        config.mcpServers.unerr = {
+            command: "npx",
+            args: ["@unerr/unerr"],
+            env: {},
+        };
+        writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
+        // Verify repair result
+        const repaired = JSON.parse(readFileSync(configPath, "utf-8"));
+        expect(repaired.mcpServers.unerr?.command).toBe("npx");
+        expect(repaired.mcpServers.unerr?.url).toBeUndefined();
+    });
+    it("VS Code config uses mcpServers key in settings.json", () => {
+        const vscodeConfig = {
+            "editor.fontSize": 14,
+            mcpServers: {
+                unerr: {
+                    command: "npx",
+                    args: ["@unerr/unerr"],
+                    env: {},
+                },
+            },
+        };
+        // VS Code settings.json has mixed keys — mcpServers lives alongside editor settings
+        expect(vscodeConfig.mcpServers.unerr.command).toBe("npx");
+        expect(vscodeConfig["editor.fontSize"]).toBe(14);
+    });
+});

package/dist/__tests__/mcp-content-json.test.js

@@ -0,0 +1,10 @@
+import { describe, expect, it } from "vitest";
+import { stringifyMcpToolJson } from "../utils/mcp-content-json.js";
+describe("stringifyMcpToolJson (Layer 6 Phase 1)", () => {
+    it("emits compact JSON without indentation whitespace", () => {
+        const obj = { a: 1, b: { c: "x\ny" } };
+        const compact = stringifyMcpToolJson(obj);
+        expect(compact).not.toContain("\n  ");
+        expect(compact).toBe(JSON.stringify(obj));
+    });
+});

package/dist/__tests__/mcp-envelope.test.js

@@ -0,0 +1,124 @@
+/**
+ * C.6: MCP Integration Test — Full Envelope Cycle
+ *
+ * Uses the MCP harness from A.6 to set up a server with a tool that
+ * returns an envelope-wrapped response, then verifies the client
+ * receives _meta + _context fields.
+ */
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { describe, expect, it } from "vitest";
+import { createEnvelopePipeline, estimateTokens, } from "../proxy/response-envelope.js";
+import { createSessionDedup } from "../proxy/session-dedup.js";
+import { createTokenCounter } from "../proxy/token-counter.js";
+import { createMcpHarness } from "./helpers/mcp-harness.js";
+describe("MCP Envelope Integration", () => {
+    it("full pipeline: envelope + injector + dedup + token counter", async () => {
+        const messages = [];
+        const tokenCounter = createTokenCounter({
+            emitEveryN: 1,
+            sink: (msg) => messages.push(msg),
+        });
+        const dedup = createSessionDedup();
+        const testInjector = {
+            key: "test",
+            inject: ({ toolArgs }) => {
+                if (toolArgs.key) {
+                    return { "dev.unerr/test_context": { entity: toolArgs.key } };
+                }
+                return null;
+            },
+        };
+        const pipeline = createEnvelopePipeline([testInjector]);
+        const harness = await createMcpHarness({
+            setupServer: (server) => {
+                server.setRequestHandler(ListToolsRequestSchema, async () => ({
+                    tools: [
+                        {
+                            name: "test_tool",
+                            description: "A test tool with envelope wrapping",
+                            inputSchema: {
+                                type: "object",
+                                properties: { key: { type: "string" } },
+                                required: ["key"],
+                            },
+                        },
+                    ],
+                }));
+                server.setRequestHandler(CallToolRequestSchema, async (request) => {
+                    const args = (request.params.arguments ?? {});
+                    const start = performance.now();
+                    const rawContent = { found: true, name: "testEntity", fan_in: 5 };
+                    const latencyMs = performance.now() - start;
+                    const originalTokens = estimateTokens(args);
+                    const envelope = await pipeline.wrapResponse(rawContent, latencyMs, request.params.name, args, originalTokens);
+                    const entityKey = String(args.key ?? "");
+                    let context = envelope._context ?? {};
+                    if (Object.keys(context).length > 0) {
+                        context = dedup.filter(entityKey, context);
+                    }
+                    tokenCounter.record(envelope._meta["dev.unerr/tokens_saved"], estimateTokens(rawContent));
+                    const responseText = JSON.stringify({
+                        ...rawContent,
+                        _meta: envelope._meta,
+                        ...(Object.keys(context).length > 0 ? { _context: context } : {}),
+                    }, null, 2);
+                    return {
+                        content: [{ type: "text", text: responseText }],
+                    };
+                });
+            },
+        });
+        const result = await harness.callTool("test_tool", {
+            key: "src/auth.ts::login",
+        });
+        const content = result.content;
+        expect(content).toHaveLength(1);
+        const parsed = JSON.parse(content[0].text);
+        expect(parsed._meta).toBeDefined();
+        expect(parsed._meta["dev.unerr/version"]).toBe("0.1.0");
+        expect(typeof parsed._meta["dev.unerr/latency_ms"]).toBe("number");
+        expect(typeof parsed._meta["dev.unerr/tokens_saved"]).toBe("number");
+        expect(parsed._context).toBeDefined();
+        expect(parsed._context["dev.unerr/test_context"]).toBeDefined();
+        expect(parsed._context["dev.unerr/test_context"].entity).toBe("src/auth.ts::login");
+        expect(tokenCounter.getCallCount()).toBe(1);
+        expect(messages).toHaveLength(1);
+        const result2 = await harness.callTool("test_tool", {
+            key: "src/auth.ts::login",
+        });
+        const parsed2 = JSON.parse(result2.content[0].text);
+        expect(parsed2._context).toBeUndefined();
+        expect(dedup.hasDelivered("src/auth.ts::login", "dev.unerr/test_context")).toBe(true);
+        await harness.close();
+    });
+    it("envelope works without any injectors", async () => {
+        const pipeline = createEnvelopePipeline();
+        const harness = await createMcpHarness({
+            setupServer: (server) => {
+                server.setRequestHandler(ListToolsRequestSchema, async () => ({
+                    tools: [
+                        {
+                            name: "simple_tool",
+                            description: "No injectors",
+                            inputSchema: { type: "object", properties: {} },
+                        },
+                    ],
+                }));
+                server.setRequestHandler(CallToolRequestSchema, async () => {
+                    const envelope = await pipeline.wrapResponse({ result: "ok" }, 0.5);
+                    return {
+                        content: [
+                            { type: "text", text: JSON.stringify(envelope) },
+                        ],
+                    };
+                });
+            },
+        });
+        const result = await harness.callTool("simple_tool", {});
+        const content = result.content;
+        const parsed = JSON.parse(content[0].text);
+        expect(parsed._meta["dev.unerr/version"]).toBe("0.1.0");
+        expect(parsed._context).toBeUndefined();
+        await harness.close();
+    });
+});