@unerr-ai/unerr 0.0.1 → 0.1.1

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

@@ -0,0 +1,92 @@
+/**
+ * P10-TEST-02: State Machine Tests — unit tests for smart default state detector.
+ */
+import { existsSync, mkdirSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it } from "vitest";
+import { detectState } from "../state-detector.js";
+let tempDir;
+let unerrDir;
+beforeEach(() => {
+    tempDir = join(tmpdir(), `unerr-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    unerrDir = join(tempDir, ".unerr");
+    mkdirSync(join(unerrDir, "state"), { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(tempDir, { recursive: true, force: true });
+    }
+    catch {
+        /* ignore */
+    }
+});
+function makeConfig(repoId = "repo-123") {
+    writeFileSync(join(unerrDir, "config.json"), JSON.stringify({ repoId }), "utf-8");
+}
+function makePid(pid) {
+    mkdirSync(join(unerrDir, "state"), { recursive: true });
+    writeFileSync(join(unerrDir, "state", "proxy.pid"), String(pid), "utf-8");
+}
+function baseDeps(overrides) {
+    return {
+        cwd: tempDir,
+        isGitRepo: () => true,
+        ...overrides,
+    };
+}
+describe("detectState", () => {
+    it("returns not_git_repo when not inside a git repo", async () => {
+        const result = await detectState(baseDeps({ isGitRepo: () => false }));
+        expect(result.state).toBe("not_git_repo");
+    });
+    it("returns needs_setup when no .unerr/config.json", async () => {
+        const result = await detectState(baseDeps());
+        expect(result.state).toBe("needs_setup");
+    });
+    it("returns needs_setup when config.json is invalid JSON", async () => {
+        writeFileSync(join(unerrDir, "config.json"), "not json", "utf-8");
+        const result = await detectState(baseDeps());
+        expect(result.state).toBe("needs_setup");
+    });
+    it("returns already_running when PID is alive", async () => {
+        makeConfig();
+        makePid(process.pid);
+        const result = await detectState(baseDeps());
+        expect(result.state).toBe("already_running");
+        expect(result.pid).toBe(process.pid);
+        expect(result.repoId).toBe("repo-123");
+    });
+    it("returns stale_pid when PID is dead and cleans up", async () => {
+        makeConfig();
+        const deadPid = 9999999;
+        makePid(deadPid);
+        const result = await detectState(baseDeps());
+        expect(result.state).toBe("stale_pid");
+        expect(result.pid).toBe(deadPid);
+        expect(existsSync(join(unerrDir, "state", "proxy.pid"))).toBe(false);
+    });
+    it("returns needs_pull when no snapshot exists", async () => {
+        makeConfig();
+        const result = await detectState(baseDeps());
+        expect(["needs_pull", "stale_graph", "ready"]).toContain(result.state);
+        expect(result.repoId).toBe("repo-123");
+    });
+    it("returns ready when everything is configured", async () => {
+        makeConfig();
+        const result = await detectState(baseDeps());
+        expect(result.repoId).toBe("repo-123");
+        expect(["needs_pull", "stale_graph", "ready"]).toContain(result.state);
+    });
+    it("preserves repoId from config", async () => {
+        makeConfig("my-special-repo");
+        const result = await detectState(baseDeps());
+        expect(result.repoId).toBe("my-special-repo");
+    });
+    it("state transitions follow priority order", async () => {
+        const result = await detectState(baseDeps({
+            isGitRepo: () => false,
+        }));
+        expect(result.state).toBe("not_git_repo");
+    });
+});

package/dist/__tests__/status-dashboard.test.js

@@ -0,0 +1,142 @@
+/**
+ * Tests for StatusDashboard Ink component (Task 1.5).
+ *
+ * Tests validate:
+ *   - Repo name, branch, commits ahead/behind display
+ *   - Proxy state (running/stopped) with color
+ *   - Graph stats (entity count, edge count, age)
+ *   - Drift summary
+ *   - Health grade with score
+ *   - Live session stats with local rate bar
+ *   - Latency display with budget warning
+ *   - Deep link display
+ */
+import { render } from "ink-testing-library";
+import React from "react";
+import { describe, expect, it } from "vitest";
+import { StatusDashboard, } from "../components/StatusDashboard.js";
+import { ThemeProvider } from "../components/Theme.js";
+function renderStatus(data) {
+    return render(React.createElement(ThemeProvider, null, React.createElement(StatusDashboard, { data })));
+}
+const baseData = {
+    repoName: "acme/monorepo",
+    repoId: "repo_abc123",
+    branch: "main",
+    branchDetail: "main (3 ahead, 1 behind)",
+    proxyStatus: "Running (PID 12345)",
+    proxyRunning: true,
+    graphInfo: "2,341 entities, 1,892 edges (pulled 2h ago)",
+};
+describe("StatusDashboard", () => {
+    it("renders section header", () => {
+        const { lastFrame } = renderStatus(baseData);
+        expect(lastFrame()).toContain("unerr status");
+    });
+    it("renders repo name and ID", () => {
+        const { lastFrame } = renderStatus(baseData);
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("acme/monorepo");
+        expect(frame).toContain("repo_abc123");
+    });
+    it("renders branch with detail", () => {
+        const { lastFrame } = renderStatus(baseData);
+        expect(lastFrame()).toContain("main (3 ahead, 1 behind)");
+    });
+    it("renders proxy running status", () => {
+        const { lastFrame } = renderStatus(baseData);
+        expect(lastFrame()).toContain("Running (PID 12345)");
+    });
+    it("renders proxy not running", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            proxyStatus: "Not running",
+            proxyRunning: false,
+        });
+        expect(lastFrame()).toContain("Not running");
+    });
+    it("renders graph info", () => {
+        const { lastFrame } = renderStatus(baseData);
+        expect(lastFrame()).toContain("2,341 entities");
+        expect(lastFrame()).toContain("1,892 edges");
+    });
+    it("renders health grade", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            healthGrade: "B+",
+            healthScore: 78,
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("B+");
+        expect(frame).toContain("78/100");
+    });
+    it("renders drift summary", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            drift: { modified: 5, added: 2, deleted: 1 },
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("5 modified");
+        expect(frame).toContain("2 added");
+        expect(frame).toContain("1 deleted");
+    });
+    it("renders live session tool calls", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            liveToolCalls: { local: 80 },
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("80 calls");
+        expect(frame).toContain("all local");
+        expect(frame).toContain("Local rate");
+    });
+    it("renders latency stats", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            latency: {
+                localP50: 0.8,
+                localP99: 3.2,
+            },
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("0.8ms");
+    });
+    it("shows budget warning when local p99 exceeds 5ms", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            latency: {
+                localP50: 2.0,
+                localP99: 7.5,
+                localBudgetExceeded: true,
+            },
+        });
+        expect(lastFrame()).toContain("⚠ >5ms");
+    });
+    it("renders deep link", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            deepLink: "https://app.unerr.dev/r/repo_abc123?view=drift",
+        });
+        expect(lastFrame()).toContain("https://app.unerr.dev/r/repo_abc123");
+    });
+    it("renders indexing status", () => {
+        const { lastFrame } = renderStatus({
+            ...baseData,
+            indexingStatus: "Ready",
+        });
+        expect(lastFrame()).toContain("Ready");
+    });
+    it("renders minimal data gracefully", () => {
+        const { lastFrame } = renderStatus({
+            repoName: "(no repo)",
+            branch: "unknown",
+            proxyStatus: "Not running",
+            proxyRunning: false,
+            graphInfo: "No local graph",
+        });
+        const frame = lastFrame() ?? "";
+        expect(frame).toContain("(no repo)");
+        expect(frame).toContain("No local graph");
+        expect(frame).not.toContain("undefined");
+    });
+});

package/dist/__tests__/temporal-facts.test.js

@@ -0,0 +1,292 @@
+import { beforeEach, describe, expect, it } from "vitest";
+import { initFactsSchema } from "../intelligence/facts-schema.js";
+import { TemporalFactStore, } from "../intelligence/temporal-facts.js";
+async function createTestDb() {
+    const cozoModule = await import("cozo-node");
+    const CozoDbConstructor = cozoModule.default
+        ? cozoModule.default.CozoDb
+        : cozoModule.CozoDb;
+    return new CozoDbConstructor("mem", "");
+}
+describe("TemporalFactStore", () => {
+    let db;
+    let store;
+    beforeEach(async () => {
+        db = await createTestDb();
+        await initFactsSchema(db);
+        store = TemporalFactStore.fromDb(db);
+    });
+    describe("createFact", () => {
+        it("creates a new fact and returns fact_id", async () => {
+            const input = {
+                fact_type: "semantic",
+                scope: "project",
+                subject: "auth-module",
+                content: "The auth module uses JWT tokens for session management",
+                source: "agent_explicit",
+            };
+            const factId = await store.createFact(input);
+            expect(factId).toBeDefined();
+            expect(factId.length).toBe(36);
+        });
+        it("deduplicates on (fact_type, scope, subject) match", async () => {
+            const input = {
+                fact_type: "semantic",
+                scope: "project",
+                subject: "database",
+                content: "We use PostgreSQL",
+                source: "agent_explicit",
+            };
+            const id1 = await store.createFact(input);
+            const id2 = await store.createFact({
+                ...input,
+                content: "We use PostgreSQL for all data",
+            });
+            expect(id2).toBe(id1);
+        });
+        it("truncates content at 280 characters", async () => {
+            const longContent = "x".repeat(500);
+            const factId = await store.createFact({
+                fact_type: "procedural",
+                scope: "project",
+                subject: "testing",
+                content: longContent,
+                source: "agent_explicit",
+            });
+            expect(factId).toBeDefined();
+        });
+    });
+    describe("convention fact type", () => {
+        it("creates and recalls a convention fact with slow decay", async () => {
+            const factId = await store.createFact({
+                fact_type: "convention",
+                scope: "project",
+                subject: "api-standards",
+                content: "All API handlers must return structured JSON responses",
+                source: "agent_explicit",
+            });
+            expect(factId).toBeDefined();
+            const facts = await store.recallByScope("project");
+            const convention = facts.find((f) => f.fact_type === "convention");
+            expect(convention).toBeDefined();
+            expect(convention.content).toBe("All API handlers must return structured JSON responses");
+            expect(convention.effective_confidence).toBeGreaterThan(0.9);
+        });
+        it("includes convention in getFactHealth by_type", async () => {
+            await store.createFact({
+                fact_type: "convention",
+                scope: "project",
+                subject: "naming",
+                content: "Use camelCase for all function names",
+                source: "agent_explicit",
+            });
+            const health = await store.getFactHealth();
+            expect(health.by_type.convention).toBe(1);
+        });
+    });
+    describe("recallByScope", () => {
+        it("recalls facts matching scope with decay applied", async () => {
+            await store.createFact({
+                fact_type: "semantic",
+                scope: "src/proxy/proxy.ts",
+                subject: "proxy",
+                content: "The proxy module owns all MCP communication",
+                source: "agent_explicit",
+            });
+            const facts = await store.recallByScope("src/proxy/proxy.ts");
+            expect(facts.length).toBe(1);
+            expect(facts[0].content).toBe("The proxy module owns all MCP communication");
+            expect(facts[0].effective_confidence).toBeGreaterThan(0);
+        });
+        it("returns empty array for unknown scope", async () => {
+            const facts = await store.recallByScope("nonexistent/file.ts");
+            expect(facts).toEqual([]);
+        });
+    });
+    describe("recallBySubject", () => {
+        it("recalls facts matching subject", async () => {
+            await store.createFact({
+                fact_type: "semantic",
+                scope: "project",
+                subject: "src/auth.ts::login",
+                content: "Login function requires rate limiting",
+                source: "agent_explicit",
+            });
+            const facts = await store.recallBySubject("src/auth.ts::login");
+            expect(facts.length).toBe(1);
+            expect(facts[0].subject).toBe("src/auth.ts::login");
+        });
+    });
+    describe("recallNegative", () => {
+        it("recalls all negative facts regardless of scope", async () => {
+            await store.createFact({
+                fact_type: "negative",
+                scope: "project",
+                subject: "testing",
+                content: "Don't mock CozoDB in integration tests",
+                source: "negative_knowledge",
+            });
+            await store.createFact({
+                fact_type: "semantic",
+                scope: "project",
+                subject: "architecture",
+                content: "Semantic fact that should not appear",
+                source: "agent_explicit",
+            });
+            const facts = await store.recallNegative();
+            expect(facts.length).toBe(1);
+            expect(facts[0].fact_type).toBe("negative");
+        });
+    });
+    describe("reinforceFact", () => {
+        it("increases reinforcement_count", async () => {
+            const factId = await store.createFact({
+                fact_type: "semantic",
+                scope: "src/index.ts",
+                subject: "arch",
+                content: "Microservices architecture",
+                source: "agent_explicit",
+            });
+            await store.reinforceFact(factId, {
+                session_id: "sess-1",
+                action: "reinforced",
+                timestamp: Date.now(),
+            });
+            const facts = await store.recallByScope("src/index.ts", 0);
+            const fact = facts.find((f) => f.fact_id === factId);
+            expect(fact).toBeDefined();
+            expect(fact.reinforcement_count).toBe(2);
+        });
+        it("increases effective confidence via evidence factor", async () => {
+            const factId = await store.createFact({
+                fact_type: "semantic",
+                scope: "src/util.ts",
+                subject: "utils",
+                content: "Utility functions are pure",
+                source: "convention_detector",
+            });
+            const before = await store.recallByScope("src/util.ts", 0);
+            const confBefore = before[0].effective_confidence;
+            await store.reinforceFact(factId, {
+                session_id: "s2",
+                action: "reinforced",
+                timestamp: Date.now(),
+            });
+            await store.reinforceFact(factId, {
+                session_id: "s3",
+                action: "reinforced",
+                timestamp: Date.now(),
+            });
+            const after = await store.recallByScope("src/util.ts", 0);
+            const confAfter = after[0].effective_confidence;
+            expect(confAfter).toBeGreaterThan(confBefore);
+        });
+    });
+    describe("contradictFact", () => {
+        it("halves base_confidence", async () => {
+            const factId = await store.createFact({
+                fact_type: "semantic",
+                scope: "src/db.ts",
+                subject: "db",
+                content: "We use MySQL",
+                source: "agent_explicit",
+                base_confidence: 0.9,
+            });
+            await store.contradictFact(factId, "Actually using PostgreSQL");
+            const facts = await store.recallByScope("src/db.ts", 0);
+            const fact = facts.find((f) => f.fact_id === factId);
+            expect(fact).toBeDefined();
+            expect(fact.base_confidence).toBeCloseTo(0.45, 1);
+        });
+    });
+    describe("getFactHealth", () => {
+        it("returns health summary with correct counts", async () => {
+            await store.createFact({
+                fact_type: "semantic",
+                scope: "project",
+                subject: "a",
+                content: "Fact A",
+                source: "agent_explicit",
+            });
+            await store.createFact({
+                fact_type: "negative",
+                scope: "project",
+                subject: "b",
+                content: "Fact B",
+                source: "negative_knowledge",
+            });
+            const health = await store.getFactHealth();
+            expect(health.total).toBe(2);
+            expect(health.by_type.semantic).toBe(1);
+            expect(health.by_type.negative).toBe(1);
+            expect(health.avg_confidence).toBeGreaterThan(0);
+        });
+    });
+    describe("pruneDecayed", () => {
+        it("removes facts below prune threshold", async () => {
+            const factId = await store.createFact({
+                fact_type: "semantic",
+                scope: "src/old.ts",
+                subject: "prune-target",
+                content: "Will be contradicted into oblivion",
+                source: "agent_explicit",
+                base_confidence: 0.1,
+            });
+            // Contradict multiple times to drive confidence below threshold
+            await store.contradictFact(factId, "wrong");
+            await store.contradictFact(factId, "still wrong");
+            await store.contradictFact(factId, "really wrong");
+            // 0.1 * 0.5^3 = 0.0125, evidence_factor = 1/3 = 0.33
+            // effective = 0.0125 * 1.0 * 0.33 = 0.004 — well below 0.05
+            const pruned = await store.pruneDecayed(0.05);
+            expect(pruned).toBe(1);
+        });
+    });
+    describe("recallForFile", () => {
+        it("combines scope + subject + negative facts", async () => {
+            await store.createFact({
+                fact_type: "semantic",
+                scope: "src/auth.ts",
+                subject: "auth",
+                content: "Auth uses bcrypt for password hashing",
+                source: "agent_explicit",
+            });
+            const negId = await store.createFact({
+                fact_type: "negative",
+                scope: "project",
+                subject: "security",
+                content: "Never store passwords in plain text",
+                source: "negative_knowledge",
+                base_confidence: 0.95,
+            });
+            // Reinforce to push evidence_factor above threshold boundary
+            await store.reinforceFact(negId, {
+                session_id: "s2",
+                action: "reinforced",
+                timestamp: Date.now(),
+            });
+            await store.reinforceFact(negId, {
+                session_id: "s3",
+                action: "reinforced",
+                timestamp: Date.now(),
+            });
+            await store.createFact({
+                fact_type: "procedural",
+                scope: "src/unrelated.ts",
+                subject: "unrelated",
+                content: "This should not appear",
+                source: "session_analysis",
+            });
+            const facts = await store.recallForFile("src/auth.ts", ["auth"]);
+            expect(facts.length).toBe(2);
+            const types = facts.map((f) => f.fact_type);
+            expect(types).toContain("semantic");
+            expect(types).toContain("negative");
+        });
+    });
+    describe("recordInteraction", () => {
+        it("records entity interaction without error", async () => {
+            await expect(store.recordInteraction("src/auth.ts::login", "session-abc", "read", "get_function", "success")).resolves.not.toThrow();
+        });
+    });
+});

package/dist/__tests__/temporal-routes.test.js

@@ -0,0 +1,142 @@
+import { Hono } from "hono";
+import { describe, expect, it, vi } from "vitest";
+import { createTemporalRoutes, } from "../server/routes/temporal.js";
+function makeFact(overrides = {}) {
+    return {
+        fact_id: "fact-001",
+        fact_type: "semantic",
+        scope: "project",
+        subject: "architecture",
+        content: "We use microservices",
+        base_confidence: 0.9,
+        effective_confidence: 0.85,
+        reinforcement_count: 3,
+        created_at: Date.now() - 86400000,
+        last_reinforced_at: Date.now() - 3600000,
+        last_contradicted_at: 0,
+        source: "agent_explicit",
+        ...overrides,
+    };
+}
+function makeSession(overrides = {}) {
+    return {
+        session_id: "sess-test",
+        written_at: new Date().toISOString(),
+        started_at: new Date(Date.now() - 3600000).toISOString(),
+        ended_at: new Date().toISOString(),
+        duration_ms: 3600000,
+        tool_calls: 15,
+        chains: 4,
+        files_modified: ["src/a.ts"],
+        entities_touched: ["src/a.ts::fn"],
+        tools_used: { get_function: 10 },
+        feature_areas: ["src"],
+        facts_recorded: 1,
+        facts_surfaced: ["f1"],
+        revert_count: 0,
+        rot_score: 0.1,
+        token_estimate: 8000,
+        branch: "main",
+        ...overrides,
+    };
+}
+function createTestDeps(overrides = {}) {
+    return {
+        factStore: {
+            recallByScope: vi.fn().mockResolvedValue([makeFact()]),
+            getFactHealth: vi.fn().mockResolvedValue({
+                total: 5,
+                active: 4,
+                decayed: 1,
+                by_type: { semantic: 2, procedural: 1, negative: 1, episodic: 1 },
+                avg_confidence: 0.72,
+            }),
+            reinforceFact: vi.fn().mockResolvedValue(undefined),
+            contradictFact: vi.fn().mockResolvedValue(undefined),
+        },
+        loadRecentSessions: vi.fn().mockReturnValue([makeSession()]),
+        emitEvent: vi.fn(),
+        ...overrides,
+    };
+}
+describe("temporal routes", () => {
+    describe("GET /api/facts", () => {
+        it("returns facts with default filters", async () => {
+            const deps = createTestDeps();
+            const app = new Hono();
+            app.route("", createTemporalRoutes(deps));
+            const res = await app.request("/api/facts");
+            expect(res.status).toBe(200);
+            const body = await res.json();
+            expect(body.facts.length).toBe(1);
+            expect(body.facts[0].fact_id).toBe("fact-001");
+            expect(body.total).toBe(1);
+        });
+        it("returns empty when factStore is null", async () => {
+            const deps = createTestDeps({ factStore: null });
+            const app = new Hono();
+            app.route("", createTemporalRoutes(deps));
+            const res = await app.request("/api/facts");
+            expect(res.status).toBe(200);
+            const body = await res.json();
+            expect(body.facts).toEqual([]);
+        });
+    });
+    describe("GET /api/facts/health", () => {
+        it("returns health summary", async () => {
+            const deps = createTestDeps();
+            const app = new Hono();
+            app.route("", createTemporalRoutes(deps));
+            const res = await app.request("/api/facts/health");
+            expect(res.status).toBe(200);
+            const body = await res.json();
+            expect(body.total).toBe(5);
+            expect(body.active).toBe(4);
+            expect(body.avg_confidence).toBe(0.72);
+        });
+    });
+    describe("GET /api/sessions", () => {
+        it("returns recent sessions", async () => {
+            const deps = createTestDeps();
+            const app = new Hono();
+            app.route("", createTemporalRoutes(deps));
+            const res = await app.request("/api/sessions");
+            expect(res.status).toBe(200);
+            const body = await res.json();
+            expect(body.sessions.length).toBe(1);
+            expect(body.sessions[0].session_id).toBe("sess-test");
+        });
+    });
+    describe("POST /api/facts/:id/reinforce", () => {
+        it("reinforces a fact and emits event", async () => {
+            const deps = createTestDeps();
+            const app = new Hono();
+            app.route("", createTemporalRoutes(deps));
+            const res = await app.request("/api/facts/fact-001/reinforce", {
+                method: "POST",
+            });
+            expect(res.status).toBe(200);
+            const body = await res.json();
+            expect(body.success).toBe(true);
+            expect(body.action).toBe("reinforced");
+            expect(deps.factStore.reinforceFact).toHaveBeenCalledWith("fact-001", expect.objectContaining({ action: "reinforced" }));
+            expect(deps.emitEvent).toHaveBeenCalledWith("fact:reinforced", expect.objectContaining({ fact_id: "fact-001" }));
+        });
+    });
+    describe("DELETE /api/facts/:id", () => {
+        it("dismisses a fact and emits event", async () => {
+            const deps = createTestDeps();
+            const app = new Hono();
+            app.route("", createTemporalRoutes(deps));
+            const res = await app.request("/api/facts/fact-001", {
+                method: "DELETE",
+            });
+            expect(res.status).toBe(200);
+            const body = await res.json();
+            expect(body.success).toBe(true);
+            expect(body.action).toBe("dismissed");
+            expect(deps.factStore.contradictFact).toHaveBeenCalledWith("fact-001", "Manually dismissed from dashboard");
+            expect(deps.emitEvent).toHaveBeenCalledWith("fact:expired", expect.objectContaining({ fact_id: "fact-001" }));
+        });
+    });
+});