@unerr-ai/unerr 0.1.0 → 0.1.1

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

@@ -0,0 +1,235 @@
+/**
+ * ST-4: IntentDetector — Jaccard + marker-anchored stitch, dormant transitions,
+ * IO orchestrator (runIntentStitch).
+ */
+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 { buildSessionSummaries, jaccard, runIntentStitch, stitchIntents, } from "../timeline/intent-detector.js";
+import { CozoTimelineStore, } from "../timeline/timeline-store.js";
+function summary(session_id, files, started_at, last_active_at, intent_text) {
+    return {
+        session_id,
+        started_at,
+        last_active_at: last_active_at ?? started_at,
+        files: new Set(files),
+        intent_text,
+    };
+}
+describe("jaccard", () => {
+    it("returns 0 for empty sets", () => {
+        expect(jaccard(new Set(), new Set())).toBe(0);
+    });
+    it("returns 1 for identical non-empty sets", () => {
+        expect(jaccard(new Set(["a", "b"]), new Set(["b", "a"]))).toBe(1);
+    });
+    it("computes overlap correctly", () => {
+        expect(jaccard(new Set(["a", "b", "c"]), new Set(["b", "c", "d"]))).toBeCloseTo(2 / 4);
+    });
+});
+describe("stitchIntents (pure)", () => {
+    it("creates a fresh intent for the first session", () => {
+        const sessions = [summary("s1", ["a.ts", "b.ts"], 1000)];
+        const result = stitchIntents(sessions, [], [], { nowMs: 2000 });
+        expect(result.intents).toHaveLength(1);
+        expect(result.intents[0]?.status).toBe("active");
+        expect(result.attachments).toEqual([
+            { intent_id: result.intents[0]?.intent_id, session_id: "s1" },
+        ]);
+    });
+    it("attaches a new session via file-set Jaccard when overlap > threshold", () => {
+        const sessions = [
+            summary("s1", ["a.ts", "b.ts", "c.ts"], 1_000, 1_500),
+            summary("s2", ["a.ts", "b.ts", "c.ts", "d.ts"], 2_000, 2_500),
+        ];
+        const result = stitchIntents(sessions, [], [], { nowMs: 3000 });
+        expect(result.intents).toHaveLength(1);
+        expect(result.attachments.map((a) => a.session_id).sort()).toEqual([
+            "s1",
+            "s2",
+        ]);
+    });
+    it("creates a new intent when overlap < threshold", () => {
+        const sessions = [
+            summary("s1", ["a.ts", "b.ts"], 1_000, 1_500),
+            summary("s2", ["x.ts", "y.ts"], 2_000, 2_500),
+        ];
+        const result = stitchIntents(sessions, [], [], { nowMs: 3_000 });
+        expect(result.intents).toHaveLength(2);
+    });
+    it("creates a new intent when overlap is fresh but text marker differs", () => {
+        const sessions = [
+            summary("s1", ["a.ts", "b.ts", "c.ts"], 1_000, 1_500, "auth refactor"),
+            summary("s2", ["a.ts", "b.ts", "c.ts"], 2_000, 2_500, "payments cleanup"),
+        ];
+        const result = stitchIntents(sessions, [], [], { nowMs: 3_000 });
+        expect(result.intents).toHaveLength(2);
+        const titles = result.intents.map((i) => i.title).sort();
+        expect(titles).toEqual(["auth refactor", "payments cleanup"]);
+    });
+    it("transitions intents to dormant after inactivity", () => {
+        const day = 24 * 60 * 60_000;
+        const sessions = [summary("s1", ["a.ts"], 0, 1_000)];
+        const r1 = stitchIntents(sessions, [], [], { nowMs: 30 * day });
+        expect(r1.intents[0]?.status).toBe("dormant");
+        expect(r1.dormantTransitions).toEqual([r1.intents[0]?.intent_id]);
+    });
+    it("does not re-attach a session that's already attached", () => {
+        const sessions = [summary("s1", ["a.ts", "b.ts"], 1_000, 1_500)];
+        const existing = {
+            intent_id: "i1",
+            title: "auth",
+            started_at: 1_000,
+            last_active_at: 1_500,
+            file_set: JSON.stringify(["a.ts", "b.ts"]),
+            file_set_hash: "h",
+            status: "active",
+            confidence: 0.5,
+            source: "file_jaccard",
+        };
+        const result = stitchIntents(sessions, [existing], [{ intent_id: "i1", session_id: "s1" }], { nowMs: 2_000 });
+        expect(result.attachments).toEqual([]);
+    });
+    it("respects the freshness window — stale intents don't absorb new sessions", () => {
+        const day = 24 * 60 * 60_000;
+        const sessions = [
+            summary("s1", ["a.ts", "b.ts", "c.ts"], 30 * day, 30 * day + 1_000),
+        ];
+        const existing = {
+            intent_id: "i1",
+            title: "old work",
+            started_at: 0,
+            last_active_at: 1_000,
+            file_set: JSON.stringify(["a.ts", "b.ts", "c.ts"]),
+            file_set_hash: "h",
+            status: "active",
+            confidence: 0.5,
+            source: "file_jaccard",
+        };
+        const result = stitchIntents(sessions, [existing], [], {
+            nowMs: 31 * day,
+            freshnessMs: 14 * day,
+        });
+        expect(result.attachments).toHaveLength(1);
+        expect(result.attachments[0]?.intent_id).not.toBe("i1");
+    });
+});
+describe("buildSessionSummaries", () => {
+    it("groups turns by session and picks first mark_intent", () => {
+        const turns = [
+            {
+                turn_id: "t1",
+                session_id: "s1",
+                started_at: 1_000,
+                ended_at: 1_500,
+                opened_by: "first_call",
+                closed_reason: "session_end",
+                tool_count: 3,
+                file_count: 2,
+                edit_count: 0,
+                title: "",
+                outcome: "unknown",
+            },
+            {
+                turn_id: "t2",
+                session_id: "s1",
+                started_at: 2_000,
+                ended_at: 2_500,
+                opened_by: "idle_gap",
+                closed_reason: "idle_gap",
+                tool_count: 4,
+                file_count: 1,
+                edit_count: 1,
+                title: "",
+                outcome: "unknown",
+            },
+        ];
+        const markers = [
+            {
+                marker_id: "m1",
+                type: "mark_intent",
+                text: "harden auth",
+                session_id: "s1",
+                turn_id: "t1",
+                ts: 1_100,
+                blocker_ref: "",
+                file_path: "",
+            },
+        ];
+        const summaries = buildSessionSummaries(turns, markers, new Map([["s1", new Set(["a.ts", "b.ts"])]]));
+        expect(summaries).toHaveLength(1);
+        expect(summaries[0]?.intent_text).toBe("harden auth");
+        expect(summaries[0]?.started_at).toBe(1_000);
+        expect(summaries[0]?.last_active_at).toBe(2_500);
+    });
+});
+describe("runIntentStitch (IO)", () => {
+    let tempDir;
+    let store;
+    beforeEach(async () => {
+        tempDir = join(tmpdir(), `unerr-istitch-${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 */
+        }
+    });
+    it("attaches two sessions touching the same files to one intent", async () => {
+        const baseTs = Date.now();
+        for (const sid of ["s1", "s2"]) {
+            await store.upsertTurn({
+                turn_id: `t-${sid}`,
+                session_id: sid,
+                started_at: baseTs,
+                ended_at: baseTs + 1_000,
+                opened_by: "first_call",
+                closed_reason: "session_end",
+                tool_count: 4,
+                file_count: 3,
+                edit_count: 1,
+                title: "",
+                outcome: "unknown",
+            });
+            await store.recordSessionFiles(sid, ["a.ts", "b.ts", "c.ts"]);
+        }
+        const r1 = await runIntentStitch(store);
+        expect(r1.attached).toBe(2);
+        const intents = await store.listIntents();
+        expect(intents).toHaveLength(1);
+        const sessions = await store.listIntentSessions(intents[0].intent_id);
+        expect(sessions.sort()).toEqual(["s1", "s2"]);
+    });
+    it("is idempotent — re-running does not re-attach sessions", async () => {
+        const baseTs = Date.now();
+        await store.upsertTurn({
+            turn_id: "tt",
+            session_id: "s1",
+            started_at: baseTs,
+            ended_at: baseTs + 1_000,
+            opened_by: "first_call",
+            closed_reason: "session_end",
+            tool_count: 1,
+            file_count: 1,
+            edit_count: 0,
+            title: "",
+            outcome: "unknown",
+        });
+        await store.recordSessionFiles("s1", ["a.ts"]);
+        const r1 = await runIntentStitch(store);
+        expect(r1.attached).toBe(1);
+        const r2 = await runIntentStitch(store);
+        expect(r2.attached).toBe(0);
+    });
+});

package/dist/__tests__/intent-encoder.test.js

@@ -0,0 +1,167 @@
+/**
+ * Tests for git notes intent encoding (Task 8.1).
+ */
+import { execSync } from "node:child_process";
+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 { encodeIntentAsNote } from "../tracking/intent-encoder.js";
+describe("Intent Encoder — Git Notes", () => {
+    let repoDir;
+    beforeEach(() => {
+        repoDir = join(tmpdir(), `unerr-test-notes-${Date.now()}`);
+        mkdirSync(repoDir, { recursive: true });
+        // Init a git repo with an initial commit
+        execSync("git init", { cwd: repoDir, stdio: "pipe" });
+        execSync("git config user.email 'test@test.com'", {
+            cwd: repoDir,
+            stdio: "pipe",
+        });
+        execSync("git config user.name 'Test'", { cwd: repoDir, stdio: "pipe" });
+        execSync("echo 'hello' > test.txt", { cwd: repoDir, stdio: "pipe" });
+        execSync("git add test.txt", { cwd: repoDir, stdio: "pipe" });
+        execSync("git commit -m 'initial'", { cwd: repoDir, stdio: "pipe" });
+    });
+    afterEach(() => {
+        rmSync(repoDir, { recursive: true, force: true });
+    });
+    function getHeadSha() {
+        return execSync("git rev-parse HEAD", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+    }
+    function makeCorrelation(overrides = {}) {
+        return {
+            rootIntentId: "intent-001",
+            prompt: "Add error handling to payment flow",
+            files: ["src/billing.ts"],
+            entities: ["processPayment"],
+            toolChain: ["get_function", "check_rules", "sync_local_diff"],
+            createdAt: new Date().toISOString(),
+            commitSha: getHeadSha(),
+            ...overrides,
+        };
+    }
+    it("writes a note to refs/notes/unerr", async () => {
+        const sha = getHeadSha();
+        const ok = await encodeIntentAsNote(sha, [makeCorrelation()], "session-abc123", {
+            currentBranch: "main",
+            baseBranch: "main",
+            headSha: sha,
+            commitsAhead: 0,
+            commitsBehind: 0,
+            baseCommit: "",
+            computedAt: new Date().toISOString(),
+        }, { added: 1, modified: 2, deleted: 0 }, repoDir);
+        expect(ok).toBe(true);
+        // Read the note back
+        const noteContent = execSync(`git notes --ref=unerr show ${sha}`, {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        const note = JSON.parse(noteContent);
+        expect(note.v).toBe(1);
+        expect(note.intents).toHaveLength(1);
+        expect(note.intents[0].id).toBe("intent-001");
+        expect(note.intents[0].prompt).toBe("Add error handling to payment flow");
+        expect(note.intents[0].tools).toEqual([
+            "get_function",
+            "check_rules",
+            "sync_local_diff",
+        ]);
+        expect(note.drift).toEqual({ a: 1, m: 2, d: 0 });
+        expect(note.sid).toBe("session-abc1");
+        expect(note.br).toBe("main");
+    });
+    it("returns false for empty correlations", async () => {
+        const ok = await encodeIntentAsNote(getHeadSha(), [], "session-xyz", null, { added: 0, modified: 0, deleted: 0 }, repoDir);
+        expect(ok).toBe(false);
+    });
+    it("truncates long prompts to 200 chars", async () => {
+        const sha = getHeadSha();
+        const longPrompt = "x".repeat(300);
+        await encodeIntentAsNote(sha, [makeCorrelation({ prompt: longPrompt })], "sess-123", null, { added: 0, modified: 0, deleted: 0 }, repoDir);
+        const noteContent = execSync(`git notes --ref=unerr show ${sha}`, {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        const note = JSON.parse(noteContent);
+        expect(note.intents[0].prompt.length).toBe(200);
+    });
+    it("handles multiple intents per commit", async () => {
+        const sha = getHeadSha();
+        await encodeIntentAsNote(sha, [
+            makeCorrelation({ rootIntentId: "i1", prompt: "First change" }),
+            makeCorrelation({ rootIntentId: "i2", prompt: "Second change" }),
+            makeCorrelation({ rootIntentId: "i3", prompt: "Third change" }),
+        ], "sess-multi", {
+            currentBranch: "feature/test",
+            baseBranch: "main",
+            headSha: sha,
+            commitsAhead: 3,
+            commitsBehind: 0,
+            baseCommit: "",
+            computedAt: new Date().toISOString(),
+        }, { added: 0, modified: 0, deleted: 0 }, repoDir);
+        const noteContent = execSync(`git notes --ref=unerr show ${sha}`, {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        const note = JSON.parse(noteContent);
+        expect(note.intents).toHaveLength(3);
+        expect(note.br).toBe("feature/test");
+    });
+    it("note is invisible in regular git log", async () => {
+        const sha = getHeadSha();
+        await encodeIntentAsNote(sha, [makeCorrelation()], "sess-invisible", null, { added: 0, modified: 0, deleted: 0 }, repoDir);
+        // Regular git log should NOT show the note
+        const log = execSync("git log --oneline -1", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        });
+        expect(log).not.toContain("intent-001");
+        // But --notes=unerr should
+        const logWithNotes = execSync("git log --notes=unerr -1", {
+            cwd: repoDir,
+            encoding: "utf-8",
+        });
+        expect(logWithNotes).toContain("intent-001");
+    });
+    it("payload stays under 2KB for typical commit", async () => {
+        const sha = getHeadSha();
+        const correlations = Array.from({ length: 5 }, (_, i) => makeCorrelation({
+            rootIntentId: `intent-${i}`,
+            prompt: `Typical coding task ${i}`,
+            files: [`src/file${i}.ts`],
+            entities: [`entity${i}`],
+            toolChain: ["get_function", "sync_local_diff"],
+        }));
+        await encodeIntentAsNote(sha, correlations, "sess-budget", {
+            currentBranch: "main",
+            baseBranch: "main",
+            headSha: sha,
+            commitsAhead: 0,
+            commitsBehind: 0,
+            baseCommit: "",
+            computedAt: new Date().toISOString(),
+        }, { added: 2, modified: 3, deleted: 1 }, repoDir);
+        const noteContent = execSync(`git notes --ref=unerr show ${sha}`, {
+            cwd: repoDir,
+            encoding: "utf-8",
+        }).trim();
+        expect(noteContent.length).toBeLessThan(2048);
+    });
+    it("returns false for non-git directory", async () => {
+        const nonGitDir = join(tmpdir(), `unerr-test-nongit-${Date.now()}`);
+        mkdirSync(nonGitDir, { recursive: true });
+        try {
+            const ok = await encodeIntentAsNote("abc1234", [makeCorrelation()], "sess-bad", null, { added: 0, modified: 0, deleted: 0 }, nonGitDir);
+            expect(ok).toBe(false);
+        }
+        finally {
+            rmSync(nonGitDir, { recursive: true, force: true });
+        }
+    });
+});

package/dist/__tests__/java-build-tool-detection.test.js

@@ -0,0 +1,174 @@
+/**
+ * Tests for the deterministic Java build-tool detection heuristic (DM-1 Task 10).
+ *
+ * Uses temp dirs with fixture build files to verify each branch of chooseBuildTool.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { chooseBuildTool, detectJavaBuildTools, } from "../intelligence/indexer/scip/orchestrator.js";
+let root;
+let testCounter = 0;
+beforeEach(() => {
+    testCounter++;
+    root = join(tmpdir(), `unerr-java-test-${process.pid}-${Date.now()}-${testCounter}`);
+    mkdirSync(root, { recursive: true });
+});
+afterEach(() => {
+    // Temp dirs are cleaned up by OS
+});
+function touch(relPath, content = "") {
+    writeFileSync(join(root, relPath), content);
+}
+function touchWithMtime(relPath, mtime) {
+    const fs = require("node:fs");
+    const p = join(root, relPath);
+    writeFileSync(p, "");
+    fs.utimesSync(p, mtime, mtime);
+}
+// ── Detection ────────────────────────────────────────────────────
+describe("detectJavaBuildTools", () => {
+    it("detects Maven from pom.xml", () => {
+        touch("pom.xml");
+        expect(detectJavaBuildTools(root)).toEqual(["Maven"]);
+    });
+    it("detects Gradle from build.gradle", () => {
+        touch("build.gradle");
+        expect(detectJavaBuildTools(root)).toEqual(["Gradle"]);
+    });
+    it("detects Gradle from build.gradle.kts", () => {
+        touch("build.gradle.kts");
+        expect(detectJavaBuildTools(root)).toEqual(["Gradle"]);
+    });
+    it("detects Bazel from BUILD.bazel", () => {
+        touch("BUILD.bazel");
+        expect(detectJavaBuildTools(root)).toEqual(["Bazel"]);
+    });
+    it("detects Sbt from build.sbt", () => {
+        touch("build.sbt");
+        expect(detectJavaBuildTools(root)).toEqual(["Sbt"]);
+    });
+    it("detects multiple tools", () => {
+        touch("pom.xml");
+        touch("build.gradle");
+        const detected = detectJavaBuildTools(root);
+        expect(detected).toContain("Maven");
+        expect(detected).toContain("Gradle");
+    });
+    it("returns empty for no build files", () => {
+        expect(detectJavaBuildTools(root)).toEqual([]);
+    });
+});
+// ── Chooser heuristic ────────────────────────────────────────────
+describe("chooseBuildTool", () => {
+    it("returns null when no tools detected", () => {
+        expect(chooseBuildTool([], root)).toBeNull();
+    });
+    it("returns sole tool without ambiguity", () => {
+        touch("pom.xml");
+        const choice = chooseBuildTool(["Maven"], root);
+        expect(choice).not.toBeNull();
+        expect(choice.tool).toBe("Maven");
+        expect(choice.ambiguous).toBe(false);
+        expect(choice.alternatives).toEqual([]);
+    });
+    describe("Bazel precedence", () => {
+        it("prefers Bazel over Maven + Gradle", () => {
+            touch("pom.xml");
+            touch("build.gradle");
+            touch("BUILD.bazel");
+            const choice = chooseBuildTool(["Maven", "Gradle", "Bazel"], root);
+            expect(choice.tool).toBe("Bazel");
+            expect(choice.ambiguous).toBe(true);
+            expect(choice.alternatives).toContain("Maven");
+            expect(choice.alternatives).toContain("Gradle");
+        });
+    });
+    describe("Sbt precedence", () => {
+        it("prefers Sbt over Maven", () => {
+            touch("pom.xml");
+            touch("build.sbt");
+            const choice = chooseBuildTool(["Maven", "Sbt"], root);
+            expect(choice.tool).toBe("Sbt");
+            expect(choice.ambiguous).toBe(true);
+        });
+        it("prefers Sbt over Gradle", () => {
+            touch("build.gradle");
+            touch("build.sbt");
+            const choice = chooseBuildTool(["Gradle", "Sbt"], root);
+            expect(choice.tool).toBe("Sbt");
+        });
+    });
+    describe("Maven + Gradle with wrappers", () => {
+        it("prefers Gradle when gradlew present", () => {
+            touch("pom.xml");
+            touch("build.gradle");
+            touch("gradlew");
+            const choice = chooseBuildTool(["Maven", "Gradle"], root);
+            expect(choice.tool).toBe("Gradle");
+            expect(choice.reason).toContain("gradlew");
+            expect(choice.alternatives).toEqual(["Maven"]);
+        });
+        it("prefers Gradle when gradlew.bat present (Windows)", () => {
+            touch("pom.xml");
+            touch("build.gradle");
+            touch("gradlew.bat");
+            const choice = chooseBuildTool(["Maven", "Gradle"], root);
+            expect(choice.tool).toBe("Gradle");
+        });
+        it("prefers Maven when mvnw present and no gradlew", () => {
+            touch("pom.xml");
+            touch("build.gradle");
+            touch("mvnw");
+            const choice = chooseBuildTool(["Maven", "Gradle"], root);
+            expect(choice.tool).toBe("Maven");
+            expect(choice.reason).toContain("mvnw");
+            expect(choice.alternatives).toEqual(["Gradle"]);
+        });
+        it("falls to mtime tiebreaker when both wrappers present", () => {
+            touch("pom.xml");
+            touch("build.gradle");
+            touch("gradlew");
+            touch("mvnw");
+            // Both wrappers → mtime tiebreaker. Since we just created them, one
+            // will have a slightly later mtime or they'll be equal. The important
+            // thing is the function returns deterministically without crashing.
+            const choice = chooseBuildTool(["Maven", "Gradle"], root);
+            expect(choice).not.toBeNull();
+            expect(["Maven", "Gradle"]).toContain(choice.tool);
+            expect(choice.ambiguous).toBe(true);
+        });
+        it("falls to mtime tiebreaker when no wrappers present", () => {
+            touch("pom.xml");
+            touch("build.gradle");
+            const choice = chooseBuildTool(["Maven", "Gradle"], root);
+            expect(choice).not.toBeNull();
+            expect(choice.ambiguous).toBe(true);
+        });
+    });
+    describe("Mtime tiebreaker", () => {
+        it("picks tool with most recently modified build file", () => {
+            const old = new Date(2020, 0, 1);
+            const recent = new Date(2026, 0, 1);
+            touchWithMtime("pom.xml", old);
+            touchWithMtime("build.gradle", recent);
+            const choice = chooseBuildTool(["Maven", "Gradle"], root);
+            expect(choice.tool).toBe("Gradle");
+        });
+    });
+});
+// ── Invariant: no process.stdin.isTTY ────────────────────────────
+describe("No interactive prompts in indexer", () => {
+    it("orchestrator.ts does not reference process.stdin.isTTY in code", () => {
+        const { readFileSync } = require("node:fs");
+        const { resolve } = require("node:path");
+        const content = readFileSync(resolve(__dirname, "../intelligence/indexer/scip/orchestrator.ts"), "utf-8");
+        // Only allow the string in comments (lines starting with * or //)
+        const codeLines = content
+            .split("\n")
+            .filter((line) => !line.trim().startsWith("*") && !line.trim().startsWith("//"));
+        const joined = codeLines.join("\n");
+        expect(joined).not.toContain("process.stdin.isTTY");
+    });
+});