@unerr-ai/unerr 0.1.6 → 0.1.7

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

@@ -1,174 +0,0 @@
-/**
- * Sprint R.8: Test Detector Tests
- *
- * Verifies isTestFile() and resolveTestSubject() work across all supported languages.
- */
-import { describe, expect, it } from "vitest";
-import { isTestFile, resolveTestSubject, } from "../intelligence/indexer/test-detector.js";
-describe("Sprint R.8: Test File Detection", () => {
-    describe("isTestFile — TypeScript/JavaScript", () => {
-        it("detects .test.ts files", () => {
-            expect(isTestFile("src/utils/exec.test.ts")).toBe(true);
-            expect(isTestFile("src/components/App.test.tsx")).toBe(true);
-        });
-        it("detects .spec.ts files", () => {
-            expect(isTestFile("src/utils/exec.spec.ts")).toBe(true);
-            expect(isTestFile("lib/helpers.spec.js")).toBe(true);
-        });
-        it("detects __tests__ directory", () => {
-            expect(isTestFile("src/__tests__/proxy.test.ts")).toBe(true);
-            expect(isTestFile("src/__tests__/utils.ts")).toBe(true);
-        });
-        it("detects test/ directory", () => {
-            expect(isTestFile("test/integration/auth.ts")).toBe(true);
-            expect(isTestFile("tests/unit/helpers.js")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("src/utils/exec.ts")).toBe(false);
-            expect(isTestFile("src/proxy/proxy.ts")).toBe(false);
-            expect(isTestFile("src/components/App.tsx")).toBe(false);
-        });
-    });
-    describe("isTestFile — Python", () => {
-        it("detects test_ prefix", () => {
-            expect(isTestFile("tests/test_models.py")).toBe(true);
-            expect(isTestFile("test_auth.py")).toBe(true);
-        });
-        it("detects _test suffix", () => {
-            expect(isTestFile("app/models/user_test.py")).toBe(true);
-        });
-        it("detects conftest.py", () => {
-            expect(isTestFile("tests/conftest.py")).toBe(true);
-            expect(isTestFile("conftest.py")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("app/models/user.py")).toBe(false);
-            expect(isTestFile("app/services/auth.py")).toBe(false);
-        });
-    });
-    describe("isTestFile — Go", () => {
-        it("detects _test.go suffix", () => {
-            expect(isTestFile("pkg/handlers/auth_test.go")).toBe(true);
-            expect(isTestFile("internal/db/connection_test.go")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("pkg/handlers/auth.go")).toBe(false);
-            expect(isTestFile("cmd/main.go")).toBe(false);
-        });
-    });
-    describe("isTestFile — Java", () => {
-        it("detects Test suffix", () => {
-            expect(isTestFile("src/test/java/com/example/UserServiceTest.java")).toBe(true);
-            expect(isTestFile("com/example/AuthTest.java")).toBe(true);
-        });
-        it("detects Tests suffix", () => {
-            expect(isTestFile("com/example/UserTests.java")).toBe(true);
-        });
-        it("detects IT suffix (integration test)", () => {
-            expect(isTestFile("com/example/AuthIT.java")).toBe(true);
-        });
-        it("detects src/test/ directory", () => {
-            expect(isTestFile("src/test/java/com/example/Helper.java")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("src/main/java/com/example/UserService.java")).toBe(false);
-            expect(isTestFile("com/example/models/User.java")).toBe(false);
-        });
-    });
-    describe("isTestFile — Rust", () => {
-        it("detects _test.rs suffix", () => {
-            expect(isTestFile("src/auth_test.rs")).toBe(true);
-        });
-        it("detects tests/ directory", () => {
-            expect(isTestFile("tests/integration/auth.rs")).toBe(true);
-            expect(isTestFile("tests/common.rs")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("src/auth.rs")).toBe(false);
-            expect(isTestFile("src/lib.rs")).toBe(false);
-        });
-    });
-    describe("isTestFile — Ruby", () => {
-        it("detects _spec.rb suffix", () => {
-            expect(isTestFile("spec/models/user_spec.rb")).toBe(true);
-        });
-        it("detects _test.rb suffix", () => {
-            expect(isTestFile("test/models/user_test.rb")).toBe(true);
-        });
-        it("detects spec/ directory", () => {
-            expect(isTestFile("spec/helpers/auth.rb")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("lib/models/user.rb")).toBe(false);
-            expect(isTestFile("app/services/auth.rb")).toBe(false);
-        });
-    });
-    describe("isTestFile — C#", () => {
-        it("detects Tests suffix", () => {
-            expect(isTestFile("Tests/UserServiceTests.cs")).toBe(true);
-        });
-        it("detects Test suffix", () => {
-            expect(isTestFile("UserServiceTest.cs")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("Services/UserService.cs")).toBe(false);
-            expect(isTestFile("Models/User.cs")).toBe(false);
-        });
-    });
-    describe("isTestFile — C/C++", () => {
-        it("detects _test suffix", () => {
-            expect(isTestFile("src/auth_test.cpp")).toBe(true);
-            expect(isTestFile("lib/parser_test.c")).toBe(true);
-        });
-        it("detects test_ prefix", () => {
-            expect(isTestFile("test_parser.cpp")).toBe(true);
-        });
-        it("rejects source files", () => {
-            expect(isTestFile("src/auth.cpp")).toBe(false);
-            expect(isTestFile("lib/parser.c")).toBe(false);
-        });
-    });
-});
-describe("Sprint R.8: resolveTestSubject", () => {
-    const projectFiles = new Set([
-        "src/utils/exec.ts",
-        "src/proxy/proxy.ts",
-        "src/exec.ts",
-        "src/__tests__/exec.test.ts",
-        "pkg/handlers/auth.go",
-        "pkg/handlers/auth_test.go",
-        "app/models/user.py",
-        "user.py",
-        "tests/test_user.py",
-        "src/main/java/com/example/UserService.java",
-        "src/test/java/com/example/UserServiceTest.java",
-        "lib/models/user.rb",
-        "models/user.rb",
-        "spec/models/user_spec.rb",
-    ]);
-    it("resolves TS test → source (same dir)", () => {
-        expect(resolveTestSubject("src/utils/exec.test.ts", projectFiles)).toBe("src/utils/exec.ts");
-    });
-    it("resolves TS test → source (__tests__ dir → parent)", () => {
-        // __tests__/exec.test.ts → parent dir is src/, so resolves to src/exec.ts
-        expect(resolveTestSubject("src/__tests__/exec.test.ts", projectFiles)).toBe("src/exec.ts");
-    });
-    it("resolves Go test → source", () => {
-        expect(resolveTestSubject("pkg/handlers/auth_test.go", projectFiles)).toBe("pkg/handlers/auth.go");
-    });
-    it("resolves Python test_ prefix → source (parent dir)", () => {
-        // tests/test_user.py → tries tests/user.py then user.py (parent strip)
-        expect(resolveTestSubject("tests/test_user.py", projectFiles)).toBe("user.py");
-    });
-    it("resolves Java Test suffix → source (Maven convention)", () => {
-        // src/test/java/... → src/main/java/...
-        expect(resolveTestSubject("src/test/java/com/example/UserServiceTest.java", projectFiles)).toBe("src/main/java/com/example/UserService.java");
-    });
-    it("resolves Ruby _spec → source (spec/ → lib/)", () => {
-        // spec/models/user_spec.rb → tries models/user.rb (strip spec/)
-        expect(resolveTestSubject("spec/models/user_spec.rb", projectFiles)).toBe("models/user.rb");
-    });
-    it("returns null for unresolvable", () => {
-        expect(resolveTestSubject("test/unknown_test.go", projectFiles)).toBeNull();
-    });
-});

package/dist/__tests__/theme.test.js

@@ -1,72 +0,0 @@
-/**
- * Tests for Theme.tsx (Task 1.1) — Ink foundation and theme system.
- *
- * Tests validate:
- *   - theme: semantic color palette with correct values
- *   - theme.grade(): letter-to-color mapping (A=green, C=yellow, F=red)
- *   - renderToStderr(): renders to stderr, not stdout
- */
-import { Text } from "ink";
-import { render } from "ink-testing-library";
-import React from "react";
-import { describe, expect, it } from "vitest";
-import { ThemeProvider, theme, useTheme } from "../components/Theme.js";
-describe("Theme System (1.1)", () => {
-    // ── theme object ───────────────────────────────────────────────
-    describe("theme", () => {
-        it("has all semantic color keys", () => {
-            expect(theme.success).toBe("green");
-            expect(theme.warning).toBe("yellow");
-            expect(theme.error).toBe("red");
-            expect(theme.info).toBe("cyan");
-            expect(theme.accent).toBe("magenta");
-            expect(theme.dim).toBe("gray");
-            expect(theme.brand).toBe("cyanBright");
-        });
-        it("grade() maps A to green", () => {
-            expect(theme.grade("A")).toBe("green");
-        });
-        it("grade() maps B+ to cyan (first char B)", () => {
-            expect(theme.grade("B+")).toBe("cyan");
-            expect(theme.grade("B")).toBe("cyan");
-        });
-        it("grade() maps C+ to yellow", () => {
-            expect(theme.grade("C+")).toBe("yellow");
-            expect(theme.grade("C")).toBe("yellow");
-        });
-        it("grade() maps D to red", () => {
-            expect(theme.grade("D")).toBe("red");
-        });
-        it("grade() maps F to red", () => {
-            expect(theme.grade("F")).toBe("red");
-        });
-        it("grade() returns gray for unknown grades", () => {
-            expect(theme.grade("X")).toBe("gray");
-            expect(theme.grade("")).toBe("gray");
-        });
-    });
-    // ── ThemeProvider + useTheme ────────────────────────────────────
-    describe("ThemeProvider + useTheme", () => {
-        function ThemeConsumer() {
-            const t = useTheme();
-            return React.createElement(Text, null, `success=${t.success}`);
-        }
-        it("provides theme to child components", () => {
-            const { lastFrame } = render(React.createElement(ThemeProvider, null, React.createElement(ThemeConsumer)));
-            expect(lastFrame()).toContain("success=green");
-        });
-        it("useTheme works without provider (uses defaults)", () => {
-            const { lastFrame } = render(React.createElement(ThemeConsumer));
-            expect(lastFrame()).toContain("success=green");
-        });
-    });
-    // ── renderToStderr ─────────────────────────────────────────────
-    describe("renderToStderr", () => {
-        it("is exported and callable", async () => {
-            // We can't easily test stderr rendering in vitest without mocking process.stderr,
-            // but we verify the function exists and has the right signature
-            const { renderToStderr } = await import("../components/render.js");
-            expect(typeof renderToStderr).toBe("function");
-        });
-    });
-});

package/dist/__tests__/timeline-agents.test.js

@@ -1,122 +0,0 @@
-/**
- * UX-1 / UX-3: session_agents store + /agents route + /sessions agent_name.
- */
-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 { createTimelineRoutes } from "../server/routes/timeline.js";
-import { CozoTimelineStore } from "../timeline/timeline-store.js";
-let tempDir;
-let store;
-beforeEach(async () => {
-    tempDir = join(tmpdir(), `unerr-agent-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(tempDir, ".unerr"), { recursive: true });
-    store = await CozoTimelineStore.create(tempDir);
-});
-afterEach(() => {
-    try {
-        store.close();
-    }
-    catch {
-        /* ignore */
-    }
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-});
-function turn(overrides) {
-    return {
-        session_id: overrides.session_id ?? "s1",
-        started_at: overrides.started_at ?? 1_000,
-        ended_at: overrides.ended_at ?? 2_000,
-        opened_by: overrides.opened_by ?? "first_call",
-        closed_reason: overrides.closed_reason ?? "session_end",
-        tool_count: overrides.tool_count ?? 3,
-        file_count: overrides.file_count ?? 2,
-        edit_count: overrides.edit_count ?? 1,
-        title: overrides.title ?? "",
-        outcome: overrides.outcome ?? "unknown",
-        ...overrides,
-    };
-}
-describe("session_agents store", () => {
-    it("setSessionAgent / getSessionAgent round-trip", async () => {
-        await store.setSessionAgent("sA", "claude-code", 1_000);
-        expect(await store.getSessionAgent("sA")).toBe("claude-code");
-        expect(await store.getSessionAgent("sB")).toBeNull();
-    });
-    it("setSessionAgent is a no-op for empty agent name", async () => {
-        await store.setSessionAgent("sA", "", 1_000);
-        expect(await store.getSessionAgent("sA")).toBeNull();
-    });
-    it("setSessionAgent preserves first_seen across refresh", async () => {
-        await store.setSessionAgent("sA", "claude-code", 1_000);
-        await store.setSessionAgent("sA", "claude-code", 5_000);
-        const result = await store
-            .getDb()
-            .run("?[first_seen, last_seen] := *session_agents{session_id, first_seen, last_seen}, session_id = $sid", { sid: "sA" });
-        const row = result.rows[0];
-        expect(row[0]).toBe(1_000);
-        expect(row[1]).toBe(5_000);
-    });
-    it("getSessionAgents batch lookup returns only requested ids", async () => {
-        await store.setSessionAgent("sA", "claude-code", 1_000);
-        await store.setSessionAgent("sB", "cursor", 2_000);
-        await store.setSessionAgent("sC", "codex", 3_000);
-        const map = await store.getSessionAgents(["sA", "sC"]);
-        expect(map.get("sA")).toBe("claude-code");
-        expect(map.get("sC")).toBe("codex");
-        expect(map.has("sB")).toBe(false);
-    });
-    it("listAgents returns distinct agent names with session counts", async () => {
-        await store.setSessionAgent("s1", "claude-code", 1_000);
-        await store.setSessionAgent("s2", "claude-code", 2_000);
-        await store.setSessionAgent("s3", "cursor", 3_000);
-        const agents = await store.listAgents();
-        const cc = agents.find((a) => a.agent_name === "claude-code");
-        const cu = agents.find((a) => a.agent_name === "cursor");
-        expect(cc.session_count).toBe(2);
-        expect(cu.session_count).toBe(1);
-        // Ordering: most-recently-seen first.
-        expect(agents[0]?.agent_name).toBe("cursor");
-    });
-    it("listSessions joins agent_name onto each row", async () => {
-        await store.upsertTurn(turn({ turn_id: "t1", session_id: "sa" }));
-        await store.upsertTurn(turn({ turn_id: "t2", session_id: "sb", started_at: 2_000 }));
-        await store.setSessionAgent("sa", "claude-code", 1_500);
-        const list = await store.listSessions();
-        const a = list.find((s) => s.session_id === "sa");
-        const b = list.find((s) => s.session_id === "sb");
-        expect(a?.agent_name).toBe("claude-code");
-        expect(b?.agent_name).toBe("unknown");
-    });
-});
-describe("HTTP routes — /agents + /sessions?agent=", () => {
-    it("GET /agents returns the agent inventory", async () => {
-        await store.setSessionAgent("s1", "claude-code", 1_000);
-        await store.setSessionAgent("s2", "cursor", 2_000);
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/agents");
-        const body = (await res.json());
-        expect(body.total).toBe(2);
-        expect(body.data.map((a) => a.agent_name).sort()).toEqual([
-            "claude-code",
-            "cursor",
-        ]);
-    });
-    it("GET /sessions?agent=claude-code filters by agent", async () => {
-        await store.upsertTurn(turn({ turn_id: "t1", session_id: "sa" }));
-        await store.upsertTurn(turn({ turn_id: "t2", session_id: "sb", started_at: 2_000 }));
-        await store.setSessionAgent("sa", "claude-code", 1_500);
-        await store.setSessionAgent("sb", "cursor", 2_500);
-        const app = createTimelineRoutes({ store });
-        const res = await app.request("/sessions?agent=cursor");
-        const body = (await res.json());
-        expect(body.total).toBe(1);
-        expect(body.data[0]?.session_id).toBe("sb");
-    });
-});

package/dist/__tests__/timeline-bootstrap.test.js

@@ -1,176 +0,0 @@
-/**
- * ST-1c: Timeline bootstrap — kill-switch + turn-close → turn rollup wiring.
- */
-import { existsSync, mkdirSync, rmSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { join } from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { computeTurnRollup, startTimelineBootstrap, } from "../timeline/timeline-bootstrap.js";
-import { CozoTimelineStore } from "../timeline/timeline-store.js";
-import { ShadowLedger } from "../tracking/shadow-ledger.js";
-let tempDir;
-beforeEach(() => {
-    tempDir = join(tmpdir(), `unerr-tb-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
-    mkdirSync(join(tempDir, ".unerr"), { recursive: true });
-    process.env.UNERR_TIMELINE_V2 = undefined;
-});
-afterEach(() => {
-    try {
-        rmSync(tempDir, { recursive: true, force: true });
-    }
-    catch {
-        /* ignore */
-    }
-    process.env.UNERR_TIMELINE_V2 = undefined;
-});
-describe("computeTurnRollup", () => {
-    it("aggregates entries into a turn row with intent title", () => {
-        const event = {
-            turn_id: "T1",
-            session_id: "S1",
-            closed_at: 5_000,
-            reason: "idle_gap",
-        };
-        const entries = [
-            {
-                id: "1",
-                ts: "2026-05-12T10:00:00.000Z",
-                tool: "mark_intent",
-                args_summary: { text: "refactor auth" },
-                result_summary: {},
-                branch: "main",
-                head_sha: "x",
-                session_id: "S1",
-                correlation_id: null,
-                turn_id: "T1",
-                turn_confidence: "first_call",
-            },
-            {
-                id: "2",
-                ts: "2026-05-12T10:00:02.000Z",
-                tool: "file_read",
-                args_summary: { file_path: "src/auth.ts" },
-                result_summary: {},
-                branch: "main",
-                head_sha: "x",
-                session_id: "S1",
-                correlation_id: "1",
-                turn_id: "T1",
-                turn_confidence: "first_call",
-            },
-            {
-                id: "3",
-                ts: "2026-05-12T10:00:04.000Z",
-                tool: "Edit",
-                args_summary: { file_path: "src/auth.ts" },
-                result_summary: {},
-                branch: "main",
-                head_sha: "x",
-                session_id: "S1",
-                correlation_id: "1",
-                turn_id: "T1",
-                turn_confidence: "first_call",
-            },
-        ];
-        const rollup = computeTurnRollup(event, entries);
-        expect(rollup.turn_id).toBe("T1");
-        expect(rollup.session_id).toBe("S1");
-        expect(rollup.tool_count).toBe(3);
-        expect(rollup.file_count).toBe(1);
-        expect(rollup.edit_count).toBe(1);
-        expect(rollup.title).toBe("refactor auth");
-        expect(rollup.opened_by).toBe("first_call");
-        expect(rollup.closed_reason).toBe("idle_gap");
-    });
-    it("falls back to basename when no mark_intent present", () => {
-        const event = {
-            turn_id: "T2",
-            session_id: "S1",
-            closed_at: 100,
-            reason: "stop_hook",
-        };
-        const entries = [
-            {
-                id: "1",
-                ts: "2026-05-12T10:00:00.000Z",
-                tool: "file_read",
-                args_summary: { file_path: "src/auth.ts" },
-                result_summary: {},
-                branch: "main",
-                head_sha: "x",
-                session_id: "S1",
-                correlation_id: null,
-                turn_id: "T2",
-                turn_confidence: "first_call",
-            },
-        ];
-        const rollup = computeTurnRollup(event, entries);
-        expect(rollup.title).toBe("auth.ts");
-    });
-});
-describe("startTimelineBootstrap", () => {
-    it("returns null and does NOT create timeline.db when UNERR_TIMELINE_V2=0", async () => {
-        process.env.UNERR_TIMELINE_V2 = "0";
-        const ledger = new ShadowLedger(join(tempDir, ".unerr"));
-        const handle = await startTimelineBootstrap({
-            projectRoot: tempDir,
-            ledger,
-            log: () => { },
-        });
-        expect(handle).toBeNull();
-        expect(existsSync(join(tempDir, ".unerr", "timeline.db"))).toBe(false);
-    });
-    it("opens timeline.db and upserts a turn when the segmenter closes one", async () => {
-        const ledger = new ShadowLedger(join(tempDir, ".unerr"));
-        const handle = await startTimelineBootstrap({
-            projectRoot: tempDir,
-            ledger,
-            log: () => { },
-        });
-        expect(handle).not.toBeNull();
-        if (!handle)
-            return;
-        try {
-            ledger.record("file_read", { file_path: "src/a.ts" }, {}, "main", "deadbeef");
-            ledger.record("search_code", { query: "foo" }, {}, "main", "deadbeef");
-            ledger.closeTurn("session_end");
-            // Give the async upsertTurn microtask a tick to flush.
-            await new Promise((r) => setTimeout(r, 30));
-            const store = handle.store;
-            const turns = await store.listTurns();
-            expect(turns).toHaveLength(1);
-            expect(turns[0]?.session_id).toBe(ledger.getSessionId());
-            expect(turns[0]?.tool_count).toBe(2);
-            expect(turns[0]?.file_count).toBe(1);
-            expect(turns[0]?.closed_reason).toBe("session_end");
-        }
-        finally {
-            handle.stop();
-        }
-    });
-    it("stop() releases the store and detaches the listener", async () => {
-        const ledger = new ShadowLedger(join(tempDir, ".unerr"));
-        const handle = await startTimelineBootstrap({
-            projectRoot: tempDir,
-            ledger,
-            log: () => { },
-        });
-        if (!handle)
-            throw new Error("expected handle");
-        handle.stop();
-        // Subsequent close should no-op (listener already detached).
-        ledger.record("file_read", { file_path: "src/b.ts" }, {}, "m", "x");
-        ledger.closeTurn();
-        // No error should propagate; store is closed, so we just verify
-        // listTurns on a NEW store opening the same db still works (re-open path).
-        const reopened = await CozoTimelineStore.create(tempDir);
-        try {
-            // Was nothing inserted after stop (listener detached).
-            const turns = await reopened.listTurns();
-            expect(turns).toEqual([]);
-        }
-        finally {
-            reopened.close();
-        }
-    });
-});