@unerr-ai/unerr 0.1.0 → 0.1.1

package/dist/__tests__/decision-point-detector.test.js

@@ -0,0 +1,98 @@
+/**
+ * Decision Point Detector tests — tool→decision level mapping, pre-edit detection.
+ */
+import { describe, expect, it } from "vitest";
+import { DecisionPointDetector, getDecisionPointDetector, } from "../intelligence/decision-point-detector.js";
+import { SessionContext } from "../intelligence/session-context.js";
+describe("DecisionPointDetector", () => {
+    const detector = new DecisionPointDetector();
+    function makeSession(historyEntities = []) {
+        const ctx = new SessionContext();
+        for (const key of historyEntities) {
+            ctx.recordEntityHistory(key, 3, "normal");
+        }
+        return ctx;
+    }
+    describe("exploration tools → low", () => {
+        const explorationTools = [
+            "file_outline",
+            "get_project_stats",
+            "get_conventions",
+            "get_critical_nodes",
+            "get_cross_boundary_links",
+        ];
+        for (const tool of explorationTools) {
+            it(`${tool} → low`, () => {
+                const level = detector.detect(tool, {}, makeSession());
+                expect(level).toBe("low");
+            });
+        }
+    });
+    describe("understanding tools → medium", () => {
+        const understandingTools = [
+            "get_references",
+            "get_imports",
+            "get_callers",
+            "get_callees",
+            "search_code",
+            "file_connections",
+            "get_test_coverage",
+        ];
+        for (const tool of understandingTools) {
+            it(`${tool} → medium`, () => {
+                const level = detector.detect(tool, {}, makeSession());
+                expect(level).toBe("medium");
+            });
+        }
+    });
+    describe("pre-edit tools", () => {
+        it("file_read without history → medium", () => {
+            const level = detector.detect("file_read", { key: "fn1" }, makeSession());
+            expect(level).toBe("medium");
+        });
+        it("file_read with prior entity history → high", () => {
+            const level = detector.detect("file_read", { key: "fn1" }, makeSession(["fn1"]));
+            expect(level).toBe("high");
+        });
+        it("get_entity with prior history → high", () => {
+            const level = detector.detect("get_entity", { key: "myClass" }, makeSession(["myClass"]));
+            expect(level).toBe("high");
+        });
+        it("get_function with prior history → high", () => {
+            const level = detector.detect("get_function", { key: "doStuff" }, makeSession(["doStuff"]));
+            expect(level).toBe("high");
+        });
+        it("file_read with purpose=edit → high (even without history)", () => {
+            const level = detector.detect("file_read", { key: "fn1", purpose: "edit" }, makeSession());
+            expect(level).toBe("high");
+        });
+        it("get_file without history → medium", () => {
+            const level = detector.detect("get_file", { name: "src/index.ts" }, makeSession());
+            expect(level).toBe("medium");
+        });
+    });
+    describe("unknown tools → medium", () => {
+        it("unknown tool defaults to medium", () => {
+            const level = detector.detect("some_new_tool", {}, makeSession());
+            expect(level).toBe("medium");
+        });
+    });
+    describe("getMaxSignals", () => {
+        it("high → 5", () => {
+            expect(detector.getMaxSignals("high")).toBe(5);
+        });
+        it("medium → 3", () => {
+            expect(detector.getMaxSignals("medium")).toBe(3);
+        });
+        it("low → 2", () => {
+            expect(detector.getMaxSignals("low")).toBe(2);
+        });
+    });
+    describe("singleton", () => {
+        it("returns same instance", () => {
+            const a = getDecisionPointDetector();
+            const b = getDecisionPointDetector();
+            expect(a).toBe(b);
+        });
+    });
+});

package/dist/__tests__/deep-link.test.js

@@ -0,0 +1,143 @@
+/**
+ * Tests for deep-link.ts (Task 1.6) — URL generation for CLI → web dashboard bridge.
+ *
+ * Tests validate:
+ *   - buildDeepLink(): correct URL structure with repo path and query params
+ *   - utm_source: always present (default "cli", overridable)
+ *   - View targeting: health, drift, timeline, graph views
+ *   - Entity/intent list serialization (comma-joined)
+ *   - Fallback: returns generic landing when repoId is missing
+ */
+import { describe, expect, it } from "vitest";
+import { buildDeepLink } from "../utils/deep-link.js";
+describe("Deep-Link URL Generation (1.6)", () => {
+    // ── Basic URL structure ────────────────────────────────────────
+    describe("basic URL structure", () => {
+        it("generates URL with repo path and default utm_source", () => {
+            const url = buildDeepLink("repo_abc123");
+            expect(url).toBe("https://app.unerr.dev/r/repo_abc123?utm_source=cli");
+        });
+        it("includes view parameter when specified", () => {
+            const url = buildDeepLink("repo_abc123", { view: "health" });
+            const parsed = new URL(url);
+            expect(parsed.pathname).toBe("/r/repo_abc123");
+            expect(parsed.searchParams.get("view")).toBe("health");
+            expect(parsed.searchParams.get("utm_source")).toBe("cli");
+        });
+        it("includes branch parameter", () => {
+            const url = buildDeepLink("repo_abc123", { branch: "feature/auth" });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("branch")).toBe("feature/auth");
+        });
+        it("serializes entities as comma-joined list", () => {
+            const url = buildDeepLink("repo_abc123", {
+                entities: ["fn_pay", "cls_user", "fn_validate"],
+            });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("entities")).toBe("fn_pay,cls_user,fn_validate");
+        });
+        it("serializes intents as comma-joined list", () => {
+            const url = buildDeepLink("repo_abc123", {
+                intents: ["intent_001", "intent_002"],
+            });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("intents")).toBe("intent_001,intent_002");
+        });
+    });
+    // ── utm_source tracking ────────────────────────────────────────
+    describe("utm_source tracking", () => {
+        it("defaults to 'cli' when no utm_source provided", () => {
+            const url = buildDeepLink("repo_abc123");
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("utm_source")).toBe("cli");
+        });
+        it("uses custom utm_source for startup context", () => {
+            const url = buildDeepLink("repo_abc123", {
+                utm_source: "cli_startup",
+            });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("utm_source")).toBe("cli_startup");
+        });
+        it("uses custom utm_source for first boot health shock", () => {
+            const url = buildDeepLink("repo_abc123", {
+                view: "health",
+                utm_source: "cli_first_boot",
+            });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("utm_source")).toBe("cli_first_boot");
+        });
+        it("uses custom utm_source for session summary", () => {
+            const url = buildDeepLink("repo_abc123", {
+                view: "timeline",
+                intents: ["i1"],
+                utm_source: "cli_session",
+            });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.get("utm_source")).toBe("cli_session");
+        });
+    });
+    // ── View types ─────────────────────────────────────────────────
+    describe("view types", () => {
+        for (const view of ["health", "drift", "timeline", "graph"]) {
+            it(`generates correct URL for '${view}' view`, () => {
+                const url = buildDeepLink("repo_123", { view });
+                const parsed = new URL(url);
+                expect(parsed.searchParams.get("view")).toBe(view);
+            });
+        }
+    });
+    // ── Combined parameters ────────────────────────────────────────
+    describe("combined parameters", () => {
+        it("generates URL with all parameters", () => {
+            const url = buildDeepLink("repo_abc123", {
+                view: "drift",
+                branch: "main",
+                entities: ["fn_a", "fn_b"],
+                intents: ["intent_1"],
+                utm_source: "cli_status",
+            });
+            const parsed = new URL(url);
+            expect(parsed.pathname).toBe("/r/repo_abc123");
+            expect(parsed.searchParams.get("view")).toBe("drift");
+            expect(parsed.searchParams.get("branch")).toBe("main");
+            expect(parsed.searchParams.get("entities")).toBe("fn_a,fn_b");
+            expect(parsed.searchParams.get("intents")).toBe("intent_1");
+            expect(parsed.searchParams.get("utm_source")).toBe("cli_status");
+        });
+        it("omits empty optional parameters", () => {
+            const url = buildDeepLink("repo_abc123", { utm_source: "cli" });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.has("view")).toBe(false);
+            expect(parsed.searchParams.has("branch")).toBe(false);
+            expect(parsed.searchParams.has("entities")).toBe(false);
+            expect(parsed.searchParams.has("intents")).toBe(false);
+        });
+        it("omits entities when array is empty", () => {
+            const url = buildDeepLink("repo_abc123", { entities: [] });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.has("entities")).toBe(false);
+        });
+        it("omits intents when array is empty", () => {
+            const url = buildDeepLink("repo_abc123", { intents: [] });
+            const parsed = new URL(url);
+            expect(parsed.searchParams.has("intents")).toBe(false);
+        });
+    });
+    // ── Fallback behavior ──────────────────────────────────────────
+    describe("fallback when repoId unavailable", () => {
+        it("returns generic landing URL when repoId is undefined", () => {
+            const url = buildDeepLink(undefined);
+            expect(url).toBe("https://app.unerr.dev?utm_source=cli");
+        });
+        it("returns generic landing URL when repoId is empty string", () => {
+            const url = buildDeepLink("");
+            expect(url).toBe("https://app.unerr.dev?utm_source=cli");
+        });
+        it("preserves utm_source on fallback URL", () => {
+            const url = buildDeepLink(undefined, {
+                utm_source: "cli_startup",
+            });
+            expect(url).toBe("https://app.unerr.dev?utm_source=cli_startup");
+        });
+    });
+});

package/dist/__tests__/disallowed-tools.test.js

@@ -0,0 +1,115 @@
+/**
+ * S8: --disallowedTools integration tests.
+ *
+ * Tests: add/remove permissions.deny entries in .claude/settings.json.
+ */
+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";
+import { addDisallowedTools, removeDisallowedTools, } from "../config/claude-settings-hooks.js";
+let testDir;
+beforeEach(() => {
+    testDir = join(tmpdir(), `unerr-disallow-test-${Date.now()}`);
+    mkdirSync(testDir, { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(testDir, { recursive: true, force: true });
+    }
+    catch {
+        // Cleanup best-effort
+    }
+});
+// DISALLOWED_TOOLS was reduced from ["Read", "Grep", "Glob"] to ["Grep", "Glob"].
+// Read is required by the native Edit workflow (Edit refuses to run if Read
+// wasn't called first), so denying it breaks editing across all agents.
+// `addDisallowedTools` also migrates existing settings: if "Read" was previously
+// denied, it gets removed. See src/config/claude-settings-hooks.ts:200-242.
+describe("addDisallowedTools", () => {
+    it("creates settings with deny entries when no settings exist", () => {
+        const result = addDisallowedTools(testDir);
+        expect(result.added).toBe(2); // Grep + Glob
+        const settings = JSON.parse(readFileSync(join(testDir, ".claude", "settings.json"), "utf-8"));
+        expect(settings.permissions.deny).not.toContain("Read"); // intentionally excluded
+        expect(settings.permissions.deny).toContain("Grep");
+        expect(settings.permissions.deny).toContain("Glob");
+    });
+    it("adds deny entries to existing settings without overwriting", () => {
+        const dir = join(testDir, ".claude");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({ someExisting: true }, null, 2));
+        const result = addDisallowedTools(testDir);
+        expect(result.added).toBe(2);
+        const settings = JSON.parse(readFileSync(join(dir, "settings.json"), "utf-8"));
+        expect(settings.someExisting).toBe(true);
+        expect(settings.permissions.deny).toContain("Grep");
+        expect(settings.permissions.deny).toContain("Glob");
+    });
+    it("preserves existing non-managed deny entries", () => {
+        const dir = join(testDir, ".claude");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({ permissions: { deny: ["SomeOtherTool"] } }, null, 2));
+        addDisallowedTools(testDir);
+        const settings = JSON.parse(readFileSync(join(dir, "settings.json"), "utf-8"));
+        expect(settings.permissions.deny).toContain("SomeOtherTool");
+        expect(settings.permissions.deny).toContain("Grep");
+        expect(settings.permissions.deny).toContain("Glob");
+        expect(settings.permissions.deny).toHaveLength(3); // 1 existing + 2 new
+    });
+    it("is idempotent — skips already-denied tools", () => {
+        addDisallowedTools(testDir);
+        const result = addDisallowedTools(testDir);
+        expect(result.added).toBe(0);
+        const settings = JSON.parse(readFileSync(join(testDir, ".claude", "settings.json"), "utf-8"));
+        // No duplicates — only Grep + Glob
+        expect(settings.permissions.deny).toHaveLength(2);
+    });
+});
+describe("removeDisallowedTools", () => {
+    it("removes deny entries", () => {
+        addDisallowedTools(testDir);
+        const removed = removeDisallowedTools(testDir);
+        expect(removed).toBe(true);
+        const settings = JSON.parse(readFileSync(join(testDir, ".claude", "settings.json"), "utf-8"));
+        // permissions.deny cleaned up entirely
+        expect(settings.permissions).toBeUndefined();
+    });
+    it("preserves non-unerr deny entries", () => {
+        const dir = join(testDir, ".claude");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({ permissions: { deny: ["Read", "Grep", "Glob", "SomeOtherTool"] } }, null, 2));
+        removeDisallowedTools(testDir);
+        const settings = JSON.parse(readFileSync(join(dir, "settings.json"), "utf-8"));
+        // Read is no longer unerr-managed, so it survives a `remove`. Migration
+        // away from Read happens only on `add`.
+        expect(settings.permissions.deny).toEqual(["Read", "SomeOtherTool"]);
+    });
+    it("returns false when no settings file exists", () => {
+        expect(removeDisallowedTools(testDir)).toBe(false);
+    });
+    it("returns false when no deny entries exist", () => {
+        const dir = join(testDir, ".claude");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({}, null, 2));
+        expect(removeDisallowedTools(testDir)).toBe(false);
+    });
+    it("returns false when deny list has no unerr entries", () => {
+        const dir = join(testDir, ".claude");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({ permissions: { deny: ["SomeOtherTool"] } }, null, 2));
+        expect(removeDisallowedTools(testDir)).toBe(false);
+    });
+});
+describe("add + remove roundtrip", () => {
+    it("leaves settings clean after roundtrip", () => {
+        const dir = join(testDir, ".claude");
+        mkdirSync(dir, { recursive: true });
+        writeFileSync(join(dir, "settings.json"), JSON.stringify({ hooks: { PreToolUse: [] } }, null, 2));
+        addDisallowedTools(testDir);
+        removeDisallowedTools(testDir);
+        const settings = JSON.parse(readFileSync(join(dir, "settings.json"), "utf-8"));
+        expect(settings.hooks).toBeDefined(); // preserved
+        expect(settings.permissions).toBeUndefined(); // cleaned up
+    });
+});