@unerr-ai/unerr 0.1.0 → 0.1.2

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

@@ -0,0 +1,165 @@
+/**
+ * Tests for config-verify.ts (P5.6-ADV-04) — Self-healing MCP configuration.
+ *
+ * Tests the actual checkIdeConfig and repairIdeConfig functions
+ * against real filesystem state to validate detection and repair logic.
+ */
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { checkIdeConfig, repairIdeConfig } from "../commands/config-verify.js";
+describe("Config Healer (P5.6-ADV-04)", () => {
+    let tmpDir;
+    beforeEach(() => {
+        tmpDir = path.join(os.tmpdir(), `test-config-healer-${Date.now()}`);
+        fs.mkdirSync(tmpDir, { recursive: true });
+    });
+    afterEach(() => {
+        fs.rmSync(tmpDir, { recursive: true, force: true });
+    });
+    // ── checkIdeConfig ────────────────────────────────────────────────
+    describe("checkIdeConfig", () => {
+        it("returns found=false when config file does not exist", () => {
+            const result = checkIdeConfig("cursor", path.join(tmpDir, "nonexistent.json"));
+            expect(result.found).toBe(false);
+            expect(result.configured).toBe(false);
+            expect(result.needsMigration).toBe(false);
+            expect(result.issues).toHaveLength(1);
+            expect(result.issues[0]).toContain("not found");
+        });
+        it("returns configured=false when mcpServers section is missing", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({ someOther: true }));
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.found).toBe(true);
+            expect(result.configured).toBe(false);
+            expect(result.issues[0]).toContain("No mcpServers section");
+        });
+        it("returns configured=false when unerr key is absent from mcpServers", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: { copilot: { command: "npx", args: ["copilot"] } },
+            }));
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.found).toBe(true);
+            expect(result.configured).toBe(false);
+            expect(result.issues[0]).toContain("No unerr MCP server configured");
+        });
+        it("flags remote URL config as needing migration", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: {
+                    unerr: { url: "https://api.unerr.io/mcp/sse" },
+                },
+            }));
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.found).toBe(true);
+            expect(result.configured).toBe(true);
+            expect(result.needsMigration).toBe(true);
+            expect(result.issues[0]).toContain("remote URL");
+            expect(result.issues[0]).toContain("local proxy");
+        });
+        it("passes when using correct local proxy format", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: {
+                    unerr: { command: "unerr", args: ["--mcp"] },
+                },
+            }));
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.found).toBe(true);
+            expect(result.configured).toBe(true);
+            expect(result.needsMigration).toBe(false);
+            expect(result.issues).toHaveLength(0);
+        });
+        it("flags unexpected config format as needing migration", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: {
+                    unerr: { command: "node", args: ["custom-server.js"] },
+                },
+            }));
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.needsMigration).toBe(true);
+            expect(result.issues[0]).toContain("unexpected format");
+        });
+        it("handles malformed JSON gracefully", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, "{ invalid json !!!");
+            const result = checkIdeConfig("cursor", configPath);
+            expect(result.found).toBe(true);
+            expect(result.configured).toBe(false);
+            expect(result.issues[0]).toContain("Failed to parse");
+        });
+    });
+    // ── repairIdeConfig ───────────────────────────────────────────────
+    describe("repairIdeConfig", () => {
+        it("creates config file from scratch when none exists", () => {
+            const configDir = path.join(tmpDir, ".cursor");
+            const configPath = path.join(configDir, "mcp.json");
+            expect(fs.existsSync(configPath)).toBe(false);
+            const success = repairIdeConfig("cursor", configPath);
+            expect(success).toBe(true);
+            const written = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            expect(written.mcpServers.unerr?.command).toBe("unerr");
+            expect(written.mcpServers.unerr?.args).toContain("--mcp");
+        });
+        it("preserves existing non-unerr MCP servers during repair", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: {
+                    copilot: { command: "npx", args: ["copilot-mcp"] },
+                    cody: { url: "http://localhost:4000/mcp" },
+                },
+            }));
+            repairIdeConfig("cursor", configPath);
+            const result = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            expect(Object.keys(result.mcpServers)).toHaveLength(3);
+            expect(result.mcpServers.copilot).toBeDefined();
+            expect(result.mcpServers.cody).toBeDefined();
+            expect(result.mcpServers.unerr).toBeDefined();
+        });
+        it("replaces remote URL config with local proxy config", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: {
+                    unerr: { url: "https://api.unerr.io/mcp/sse" },
+                },
+            }));
+            repairIdeConfig("cursor", configPath);
+            const result = JSON.parse(fs.readFileSync(configPath, "utf-8"));
+            // Should now be local proxy format, not remote URL
+            expect(result.mcpServers.unerr?.command).toBe("unerr");
+            expect(result.mcpServers.unerr?.url).toBeUndefined();
+        });
+        it("creates parent directory if it doesn't exist", () => {
+            const deepPath = path.join(tmpDir, "a", "b", "c", "mcp.json");
+            const success = repairIdeConfig("cursor", deepPath);
+            expect(success).toBe(true);
+            expect(fs.existsSync(deepPath)).toBe(true);
+        });
+    });
+    // ── checkIdeConfig + repairIdeConfig integration ──────────────────
+    describe("check → repair → re-check cycle", () => {
+        it("repair fixes all issues detected by check", () => {
+            const configPath = path.join(tmpDir, "mcp.json");
+            // Start with broken config
+            fs.writeFileSync(configPath, JSON.stringify({
+                mcpServers: { other: { url: "http://example.com" } },
+            }));
+            // Step 1: check — should find issues
+            const check1 = checkIdeConfig("cursor", configPath);
+            expect(check1.configured).toBe(false);
+            expect(check1.issues.length).toBeGreaterThan(0);
+            // Step 2: repair
+            const repaired = repairIdeConfig("cursor", configPath);
+            expect(repaired).toBe(true);
+            // Step 3: re-check — should pass
+            const check2 = checkIdeConfig("cursor", configPath);
+            expect(check2.configured).toBe(true);
+            expect(check2.needsMigration).toBe(false);
+            expect(check2.issues).toHaveLength(0);
+        });
+    });
+});

package/dist/__tests__/context-ledger.test.js

@@ -0,0 +1,58 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { createContextLedger } from "../tracking/context-ledger.js";
+let tempDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-ctx-ledger-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(tempDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+describe("createContextLedger", () => {
+    it("initializes with empty state", () => {
+        const ledger = createContextLedger(tempDir);
+        expect(ledger.getDeliveredCount()).toBe(0);
+    });
+    it("marks and queries delivered keys", () => {
+        const ledger = createContextLedger(tempDir);
+        ledger.markDelivered("entity-a", ["blast_radius", "conventions"]);
+        expect(ledger.hasDelivered("entity-a", "blast_radius")).toBe(true);
+        expect(ledger.hasDelivered("entity-a", "conventions")).toBe(true);
+        expect(ledger.hasDelivered("entity-a", "unknown")).toBe(false);
+        expect(ledger.hasDelivered("entity-b", "blast_radius")).toBe(false);
+    });
+    it("persists across sessions (save + load)", () => {
+        const ledger1 = createContextLedger(tempDir);
+        ledger1.markDelivered("entity-x", ["ctx-1", "ctx-2"]);
+        ledger1.save(ledger1.load());
+        const delivered = new Map();
+        delivered.set("entity-x", new Set(["ctx-1", "ctx-2"]));
+        ledger1.save(delivered);
+        const ledger2 = createContextLedger(tempDir);
+        expect(ledger2.hasDelivered("entity-x", "ctx-1")).toBe(true);
+        expect(ledger2.hasDelivered("entity-x", "ctx-2")).toBe(true);
+        expect(ledger2.getDeliveredCount()).toBe(2);
+    });
+    it("tracks delivered count", () => {
+        const ledger = createContextLedger(tempDir);
+        ledger.markDelivered("e1", ["a", "b"]);
+        ledger.markDelivered("e2", ["c"]);
+        expect(ledger.getDeliveredCount()).toBe(3);
+    });
+    it("prune removes old entries", () => {
+        const ledger = createContextLedger(tempDir);
+        ledger.markDelivered("e1", ["old-key"]);
+        const pruned = ledger.prune();
+        expect(pruned).toBeGreaterThanOrEqual(0);
+    });
+    it("handles missing state directory", () => {
+        const nonExistent = join(tempDir, "deep", "nested");
+        const ledger = createContextLedger(nonExistent);
+        expect(ledger.getDeliveredCount()).toBe(0);
+        ledger.markDelivered("e1", ["k1"]);
+        expect(ledger.getDeliveredCount()).toBe(1);
+    });
+});

package/dist/__tests__/convention-detector.test.js

@@ -0,0 +1,99 @@
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { detectAllConventions, detectNamingConventions, detectStructureConventions, loadConventions, persistConventions, } from "../intelligence/convention-detector.js";
+import { entityKey } from "../intelligence/indexer/entity-key.js";
+let tempDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-conv-${Date.now()}`);
+    mkdirSync(tempDir, { recursive: true });
+});
+afterEach(() => {
+    rmSync(tempDir, { recursive: true, force: true });
+});
+function makeEntity(name, kind, filePath) {
+    return {
+        key: entityKey(filePath, kind, name, ""),
+        kind: kind,
+        name,
+        file_path: filePath,
+        start_line: 1,
+        end_line: 5,
+        signature: `${name}()`,
+        body_hash: "h",
+        exported: true,
+        parent_key: null,
+        language: "typescript",
+        is_async: false,
+        parameter_count: 0,
+        doc: null,
+    };
+}
+describe("Convention Detector (O.6-O.10)", () => {
+    it("detects naming suffix convention for Services", () => {
+        const entities = [
+            makeEntity("AuthService", "class", "src/auth.ts"),
+            makeEntity("PaymentService", "class", "src/payment.ts"),
+            makeEntity("UserService", "class", "src/user.ts"),
+            makeEntity("EmailService", "class", "src/email.ts"),
+        ];
+        const conventions = detectNamingConventions(entities);
+        const serviceSuffix = conventions.find((c) => c.pattern === "*Service");
+        expect(serviceSuffix).toBeDefined();
+        expect(serviceSuffix?.confidence).toBeGreaterThan(0.5);
+        expect(serviceSuffix?.entityCount).toBeGreaterThanOrEqual(3);
+    });
+    it("detects naming prefix convention for functions", () => {
+        const entities = Array.from({ length: 8 }, (_, i) => makeEntity(`getUser${i}`, "function", `src/f${i}.ts`));
+        const conventions = detectNamingConventions(entities);
+        const getPrefix = conventions.find((c) => c.pattern === "get*");
+        expect(getPrefix).toBeDefined();
+        expect(getPrefix?.confidence).toBeGreaterThan(0.4);
+    });
+    it("detects structural conventions from directory organization", () => {
+        const entities = [
+            makeEntity("fn1", "function", "src/services/auth.ts"),
+            makeEntity("fn2", "function", "src/services/user.ts"),
+            makeEntity("fn3", "function", "src/services/payment.ts"),
+            makeEntity("fn4", "function", "src/utils/helper.ts"),
+            makeEntity("fn5", "function", "src/utils/format.ts"),
+            makeEntity("fn6", "function", "src/utils/validate.ts"),
+        ];
+        const conventions = detectStructureConventions(entities);
+        expect(conventions.length).toBeGreaterThanOrEqual(0);
+    });
+    it("produces combined convention report", () => {
+        const entities = [
+            makeEntity("AuthService", "class", "src/services/auth.ts"),
+            makeEntity("UserService", "class", "src/services/user.ts"),
+            makeEntity("PayService", "class", "src/services/pay.ts"),
+        ];
+        const edges = [];
+        const report = detectAllConventions(entities, edges);
+        expect(report.totalEntities).toBe(3);
+        expect(report.analyzedAt).toBeTruthy();
+    });
+    it("persists and loads conventions", () => {
+        const entities = [
+            makeEntity("AuthService", "class", "src/a.ts"),
+            makeEntity("UserService", "class", "src/b.ts"),
+            makeEntity("PayService", "class", "src/c.ts"),
+        ];
+        const report = detectAllConventions(entities, []);
+        persistConventions(tempDir, report);
+        const loaded = loadConventions(tempDir);
+        expect(loaded).not.toBeNull();
+        expect(loaded?.totalEntities).toBe(3);
+    });
+    it("returns null for missing conventions file", () => {
+        expect(loadConventions(tempDir)).toBeNull();
+    });
+    it("filters low-confidence conventions", () => {
+        const entities = [makeEntity("foo", "function", "src/a.ts")];
+        const report = detectAllConventions(entities, []);
+        for (const conv of report.conventions) {
+            expect(conv.confidence).toBeGreaterThanOrEqual(0.5);
+        }
+    });
+});

package/dist/__tests__/convention-learner.test.js

@@ -0,0 +1,86 @@
+import { describe, expect, it } from "vitest";
+import { learnConventions } from "../intelligence/convention-learner.js";
+describe("learnConventions", () => {
+    it("detects co-change patterns from repeated file pairs", () => {
+        const entries = Array.from({ length: 4 }, (_, i) => ({
+            id: `e${i}`,
+            ts: new Date(Date.now() - (4 - i) * 60000).toISOString(),
+            tool: "sync_local_diff",
+            args_summary: { files: ["src/auth.ts", "src/auth.test.ts"] },
+            result_summary: {},
+        }));
+        const conventions = learnConventions(entries);
+        const coChange = conventions.find((c) => c.pattern === "co-change");
+        expect(coChange).toBeDefined();
+        expect(coChange?.observationCount).toBeGreaterThanOrEqual(3);
+    });
+    it("returns empty for insufficient data", () => {
+        const entries = [
+            {
+                id: "e1",
+                ts: "2026-04-30T10:00:00Z",
+                tool: "sync_local_diff",
+                args_summary: { files: ["a.ts"] },
+                result_summary: {},
+            },
+        ];
+        const conventions = learnConventions(entries);
+        expect(conventions.filter((c) => c.pattern === "co-change")).toHaveLength(0);
+    });
+    it("returns empty for non-sync entries", () => {
+        const entries = [
+            {
+                id: "e1",
+                ts: "2026-04-30T10:00:00Z",
+                tool: "get_function",
+                args_summary: { key: "a" },
+                result_summary: {},
+            },
+            {
+                id: "e2",
+                ts: "2026-04-30T10:01:00Z",
+                tool: "get_callers",
+                args_summary: { key: "b" },
+                result_summary: {},
+            },
+        ];
+        expect(learnConventions(entries)).toHaveLength(0);
+    });
+    it("detects rename patterns from content changes", () => {
+        const entries = [
+            {
+                id: "e1",
+                ts: "2026-04-30T10:00:00Z",
+                tool: "sync_local_diff",
+                args_summary: {
+                    files: [
+                        {
+                            path: "src/api.ts",
+                            content: "export function getData() { return fetch('/api'); }",
+                        },
+                    ],
+                },
+                result_summary: {},
+            },
+            {
+                id: "e2",
+                ts: "2026-04-30T10:01:00Z",
+                tool: "sync_local_diff",
+                args_summary: {
+                    files: [
+                        {
+                            path: "src/api.ts",
+                            content: "export function fetchData() { return fetch('/api'); }",
+                        },
+                    ],
+                },
+                result_summary: {},
+            },
+        ];
+        const conventions = learnConventions(entries);
+        const rename = conventions.find((c) => c.name.startsWith("Naming:"));
+        if (rename) {
+            expect(rename.pattern).toContain("fetch");
+        }
+    });
+});