@unerr-ai/unerr 0.1.6 → 0.1.7

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

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

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

@@ -1,292 +0,0 @@
-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

@@ -1,142 +0,0 @@
-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" }));
-        });
-    });
-});