@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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

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

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