@unerr-ai/unerr 0.1.0 → 0.1.2

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

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

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

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

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