@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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

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

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