@unerr-ai/unerr 0.1.0 → 0.1.1

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

@@ -0,0 +1,330 @@
+/**
+ * Leapfrog Sprint B TEST: Correction detector.
+ *
+ * Tests the 6-phase correction detection pipeline against synthetic
+ * shadow ledger data. Validates: error signal detection, correction pairing,
+ * confidence scoring, false positive filtering, and deduplication.
+ */
+import { mkdirSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { describe, expect, it } from "vitest";
+import { detectCorrections } from "../tracking/correction-detector.js";
+function createTempLedger(entries) {
+    const dir = join(tmpdir(), `unerr-test-${Date.now()}-${Math.random().toString(36).slice(2)}`);
+    mkdirSync(dir, { recursive: true });
+    const path = join(dir, "shadow.jsonl");
+    const content = `${entries.map((e) => JSON.stringify(e)).join("\n")}\n`;
+    writeFileSync(path, content, "utf-8");
+    return path;
+}
+function makeLedgerEntry(overrides) {
+    return {
+        id: Math.random().toString(36).slice(2),
+        ts: new Date().toISOString(),
+        args_summary: {},
+        result_summary: {},
+        branch: "main",
+        head_sha: "abc123",
+        session_id: "session-1",
+        correlation_id: null,
+        ...overrides,
+    };
+}
+describe("detectCorrections", () => {
+    it("returns empty for nonexistent ledger", () => {
+        const result = detectCorrections("/nonexistent/path.jsonl");
+        expect(result).toEqual([]);
+    });
+    it("returns empty for empty ledger", () => {
+        const path = createTempLedger([]);
+        const result = detectCorrections(path);
+        expect(result).toEqual([]);
+    });
+    it("detects a simple error→fix correction pair", () => {
+        const now = Date.now();
+        const entries = [
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now).toISOString(),
+                args_summary: { key: "src/auth.ts:validateToken" },
+                result_summary: { found: true },
+            }),
+            makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now + 5000).toISOString(),
+                args_summary: { file_path: "src/auth.ts" },
+                result_summary: {},
+            }),
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + 15000).toISOString(),
+                args_summary: { key: "src/auth.ts:validateToken" },
+                result_summary: {
+                    error: "TypeError: Cannot read property 'userId' of null",
+                },
+            }),
+        ];
+        const path = createTempLedger(entries);
+        const result = detectCorrections(path, { min_confidence: 0.4 });
+        expect(result.length).toBeGreaterThanOrEqual(1);
+        const correction = result.find((c) => c.entity_key === "src/auth.ts:validateToken");
+        expect(correction).toBeDefined();
+        expect(correction?.error_type).toBe("type_error");
+        expect(correction?.confidence).toBeGreaterThanOrEqual(0.5);
+    });
+    it("assigns higher confidence when fix succeeded (no re-query within 5min)", () => {
+        const now = Date.now();
+        const entries = [
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now).toISOString(),
+                args_summary: { key: "src/payment.ts:process" },
+                result_summary: { found: true },
+            }),
+            makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now + 5000).toISOString(),
+                args_summary: {},
+                result_summary: {},
+            }),
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + 20000).toISOString(),
+                args_summary: { key: "src/payment.ts:process" },
+                result_summary: { error: "TypeError: amount is not a number" },
+            }),
+            // No further re-query of this entity for 5+ minutes → fix succeeded
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + 600_000).toISOString(),
+                args_summary: { key: "src/other.ts:unrelated" },
+                result_summary: { found: true },
+            }),
+        ];
+        const path = createTempLedger(entries);
+        const result = detectCorrections(path, { min_confidence: 0.4 });
+        const correction = result.find((c) => c.entity_key === "src/payment.ts:process");
+        expect(correction).toBeDefined();
+        // Base 0.5 + fix success bonus 0.2 = at least 0.7
+        expect(correction?.confidence).toBeGreaterThanOrEqual(0.7);
+    });
+    it("filters corrections below minimum confidence threshold", () => {
+        const now = Date.now();
+        const entries = [
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now).toISOString(),
+                args_summary: { key: "src/utils.ts:helper" },
+                result_summary: { found: true },
+            }),
+            makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now + 5000).toISOString(),
+                args_summary: {},
+                result_summary: {},
+            }),
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + 15000).toISOString(),
+                args_summary: { key: "src/utils.ts:helper" },
+                result_summary: { error: "TypeError" },
+            }),
+            // Another re-query immediately → fix didn't succeed → lower confidence
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + 25000).toISOString(),
+                args_summary: { key: "src/utils.ts:helper" },
+                result_summary: { error: "TypeError" },
+            }),
+        ];
+        const path = createTempLedger(entries);
+        const highThreshold = detectCorrections(path, { min_confidence: 0.9 });
+        expect(highThreshold.length).toBe(0);
+    });
+    it("deduplicates patterns by entity_key + error_type", () => {
+        const now = Date.now();
+        const entries = [];
+        // Create two identical error→fix pairs for the same entity
+        for (let session = 0; session < 2; session++) {
+            const offset = session * 100_000;
+            entries.push(makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + offset).toISOString(),
+                args_summary: { key: "src/db.ts:query" },
+                result_summary: { found: true },
+                session_id: `session-${session}`,
+            }), makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now + offset + 5000).toISOString(),
+                args_summary: {},
+                result_summary: {},
+                session_id: `session-${session}`,
+            }), makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + offset + 15000).toISOString(),
+                args_summary: { key: "src/db.ts:query" },
+                result_summary: { error: "TypeError: connection is undefined" },
+                session_id: `session-${session}`,
+            }));
+        }
+        const path = createTempLedger(entries);
+        const result = detectCorrections(path, { min_confidence: 0.4 });
+        // Should be deduplicated to a single pattern with occurrences=2
+        const dbPatterns = result.filter((c) => c.entity_key === "src/db.ts:query");
+        expect(dbPatterns.length).toBe(1);
+        expect(dbPatterns[0]?.occurrences).toBe(2);
+    });
+    it("skips entries outside the correction window", () => {
+        const now = Date.now();
+        const entries = [
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now).toISOString(),
+                args_summary: { key: "src/slow.ts:fn" },
+                result_summary: { found: true },
+            }),
+            makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now + 5000).toISOString(),
+                args_summary: {},
+                result_summary: {},
+            }),
+            // Re-query 5 minutes later — outside the 60s default window
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + 300_000).toISOString(),
+                args_summary: { key: "src/slow.ts:fn" },
+                result_summary: { error: "TypeError" },
+            }),
+        ];
+        const path = createTempLedger(entries);
+        const result = detectCorrections(path);
+        const slowPatterns = result.filter((c) => c.entity_key === "src/slow.ts:fn");
+        expect(slowPatterns.length).toBe(0);
+    });
+    it("classifies different error types correctly", () => {
+        const now = Date.now();
+        const makeErrorPair = (key, errorMessage, offset) => [
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + offset).toISOString(),
+                args_summary: { key },
+                result_summary: { found: true },
+            }),
+            makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now + offset + 3000).toISOString(),
+                args_summary: {},
+                result_summary: {},
+            }),
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now + offset + 10000).toISOString(),
+                args_summary: { key },
+                result_summary: { error: errorMessage },
+            }),
+        ];
+        const entries = [
+            ...makeErrorPair("a", "TypeError: x is undefined", 0),
+            ...makeErrorPair("b", "Cannot find module './missing'", 100_000),
+            ...makeErrorPair("c", "Property 'name' does not exist on type 'Foo'", 200_000),
+            ...makeErrorPair("d", "Expected 2 arguments but got 1", 300_000),
+        ];
+        const path = createTempLedger(entries);
+        const result = detectCorrections(path, { min_confidence: 0.4 });
+        const types = new Map(result.map((c) => [c.entity_key, c.error_type]));
+        expect(types.get("a")).toBe("type_error");
+        expect(types.get("b")).toBe("import_error");
+        expect(types.get("c")).toBe("missing_field");
+        expect(types.get("d")).toBe("wrong_argument");
+    });
+    it("respects since_days filter", () => {
+        const now = Date.now();
+        const entries = [
+            // 10 days ago — outside default 7-day window
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now - 10 * 24 * 60 * 60 * 1000).toISOString(),
+                args_summary: { key: "src/old.ts:fn" },
+                result_summary: { found: true },
+            }),
+            makeLedgerEntry({
+                tool: "sync_local_diff",
+                ts: new Date(now - 10 * 24 * 60 * 60 * 1000 + 5000).toISOString(),
+                args_summary: {},
+                result_summary: {},
+            }),
+            makeLedgerEntry({
+                tool: "get_function",
+                ts: new Date(now - 10 * 24 * 60 * 60 * 1000 + 15000).toISOString(),
+                args_summary: { key: "src/old.ts:fn" },
+                result_summary: { error: "TypeError" },
+            }),
+        ];
+        const path = createTempLedger(entries);
+        // Default 7 days — should find nothing
+        expect(detectCorrections(path, { min_confidence: 0.4 }).length).toBe(0);
+        // 30 days — should find the pattern
+        const result = detectCorrections(path, {
+            since_days: 30,
+            min_confidence: 0.4,
+        });
+        expect(result.length).toBeGreaterThanOrEqual(1);
+    });
+    it("returns patterns sorted by confidence descending", () => {
+        const now = Date.now();
+        const entries = [];
+        // Pattern 1: high confidence (fix succeeded)
+        entries.push(makeLedgerEntry({
+            tool: "get_function",
+            ts: new Date(now).toISOString(),
+            args_summary: { key: "high" },
+            result_summary: { found: true },
+            session_id: "s1",
+        }), makeLedgerEntry({
+            tool: "sync_local_diff",
+            ts: new Date(now + 3000).toISOString(),
+            args_summary: {},
+            result_summary: {},
+            session_id: "s1",
+        }), makeLedgerEntry({
+            tool: "get_function",
+            ts: new Date(now + 10000).toISOString(),
+            args_summary: { key: "high" },
+            result_summary: { error: "TypeError" },
+            session_id: "s1",
+        }));
+        // Pattern 2: lower confidence (fix failed — another re-query)
+        entries.push(makeLedgerEntry({
+            tool: "get_function",
+            ts: new Date(now + 100_000).toISOString(),
+            args_summary: { key: "low" },
+            result_summary: { found: true },
+            session_id: "s2",
+        }), makeLedgerEntry({
+            tool: "sync_local_diff",
+            ts: new Date(now + 103_000).toISOString(),
+            args_summary: {},
+            result_summary: {},
+            session_id: "s2",
+        }), makeLedgerEntry({
+            tool: "get_function",
+            ts: new Date(now + 110_000).toISOString(),
+            args_summary: { key: "low" },
+            result_summary: { error: "TypeError" },
+            session_id: "s2",
+        }), makeLedgerEntry({
+            tool: "get_function",
+            ts: new Date(now + 115_000).toISOString(),
+            args_summary: { key: "low" },
+            result_summary: { error: "TypeError" },
+            session_id: "s2",
+        }));
+        const path = createTempLedger(entries);
+        const result = detectCorrections(path, { min_confidence: 0.4 });
+        if (result.length >= 2) {
+            expect(result[0]?.confidence).toBeGreaterThanOrEqual(result[1]?.confidence);
+        }
+    });
+});

package/dist/__tests__/daemon-autostart-install.test.js

@@ -0,0 +1,283 @@
+/**
+ * Tests for DM-5 autostart gating:
+ *   - First install triggers platform auto-start
+ *   - Second call is a no-op (sentinel blocks)
+ *   - CI=true skips entirely
+ *   - Platform dispatches to correct module
+ */
+import { mkdirSync, rmSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+// Mock the CI detection module
+vi.mock("../daemon/detect-ci.js", () => ({
+    isCI: vi.fn(() => false),
+    resetCICache: vi.fn(),
+}));
+// Mock platform modules
+vi.mock("../daemon/platform-macos.js", () => ({
+    installLaunchd: vi.fn(() => ({ installed: true, path: "/mock/plist" })),
+    uninstallLaunchd: vi.fn(() => ({ installed: false, path: "/mock/plist" })),
+    isLaunchdInstalled: vi.fn(() => false),
+    getLaunchdStatus: vi.fn(() => ({ loaded: false, plistExists: false })),
+}));
+vi.mock("../daemon/platform-linux.js", () => ({
+    installSystemd: vi.fn(() => ({ installed: true, path: "/mock/unit" })),
+    uninstallSystemd: vi.fn(() => ({ installed: false, path: "/mock/unit" })),
+    isSystemdInstalled: vi.fn(() => false),
+    getSystemdStatus: vi.fn(() => ({
+        unitExists: false,
+        active: false,
+        enabled: false,
+    })),
+}));
+vi.mock("../daemon/platform-windows.js", () => ({
+    installWindows: vi.fn(() => ({
+        installed: true,
+        path: "Scheduled Task: Unerr Daemon",
+    })),
+    uninstallWindows: vi.fn(() => ({ installed: false, path: "" })),
+    isWindowsInstalled: vi.fn(() => false),
+}));
+let testHome;
+beforeEach(() => {
+    testHome = join(tmpdir(), `unerr-autostart-test-${Date.now()}-${Math.random().toString(36).slice(2, 8)}`);
+    mkdirSync(join(testHome, ".unerr"), { recursive: true });
+});
+afterEach(() => {
+    try {
+        rmSync(testHome, { recursive: true, force: true });
+    }
+    catch {
+        // cleanup best-effort
+    }
+    vi.restoreAllMocks();
+});
+describe("CI detection", () => {
+    it("detects standard CI env var", async () => {
+        vi.resetModules();
+        // Direct test of detect-ci (unmoacked)
+        vi.doUnmock("../daemon/detect-ci.js");
+        const { isCI, resetCICache } = await import("../daemon/detect-ci.js");
+        resetCICache();
+        const orig = process.env.CI;
+        process.env.CI = "true";
+        try {
+            expect(isCI()).toBe(true);
+        }
+        finally {
+            if (orig === undefined)
+                process.env.CI = undefined;
+            else
+                process.env.CI = orig;
+            resetCICache();
+        }
+    });
+    it("detects GitHub Actions", async () => {
+        vi.resetModules();
+        vi.doUnmock("../daemon/detect-ci.js");
+        const { isCI, resetCICache } = await import("../daemon/detect-ci.js");
+        resetCICache();
+        const orig = process.env.GITHUB_ACTIONS;
+        process.env.GITHUB_ACTIONS = "true";
+        try {
+            expect(isCI()).toBe(true);
+        }
+        finally {
+            if (orig === undefined)
+                process.env.GITHUB_ACTIONS = undefined;
+            else
+                process.env.GITHUB_ACTIONS = orig;
+            resetCICache();
+        }
+    });
+    it("returns false when no CI indicators present", async () => {
+        vi.resetModules();
+        vi.doUnmock("../daemon/detect-ci.js");
+        const { isCI, resetCICache } = await import("../daemon/detect-ci.js");
+        resetCICache();
+        // Temporarily clear all CI-related env vars
+        const ciVars = [
+            "CI",
+            "CONTINUOUS_INTEGRATION",
+            "BUILD_NUMBER",
+            "GITHUB_ACTIONS",
+            "GITLAB_CI",
+            "CIRCLECI",
+            "BUILDKITE",
+            "JENKINS_URL",
+            "TRAVIS",
+            "CODEBUILD_BUILD_ID",
+            "TF_BUILD",
+            "BITBUCKET_PIPELINE_UUID",
+            "DRONE",
+            "WOODPECKER_CI",
+            "TEAMCITY_VERSION",
+            "HEROKU_TEST_RUN_ID",
+        ];
+        const saved = {};
+        for (const v of ciVars) {
+            saved[v] = process.env[v];
+            delete process.env[v];
+        }
+        try {
+            expect(isCI()).toBe(false);
+        }
+        finally {
+            for (const v of ciVars) {
+                if (saved[v] !== undefined)
+                    process.env[v] = saved[v];
+                else
+                    delete process.env[v];
+            }
+            resetCICache();
+        }
+    });
+    it("caches result across calls", async () => {
+        vi.resetModules();
+        vi.doUnmock("../daemon/detect-ci.js");
+        const { isCI, resetCICache } = await import("../daemon/detect-ci.js");
+        resetCICache();
+        const ciVars = [
+            "CI",
+            "GITHUB_ACTIONS",
+            "GITLAB_CI",
+            "CIRCLECI",
+            "BUILDKITE",
+            "JENKINS_URL",
+            "TRAVIS",
+            "CODEBUILD_BUILD_ID",
+            "TF_BUILD",
+            "BITBUCKET_PIPELINE_UUID",
+            "DRONE",
+            "WOODPECKER_CI",
+            "TEAMCITY_VERSION",
+            "HEROKU_TEST_RUN_ID",
+            "CONTINUOUS_INTEGRATION",
+            "BUILD_NUMBER",
+        ];
+        const saved = {};
+        for (const v of ciVars) {
+            saved[v] = process.env[v];
+            delete process.env[v];
+        }
+        try {
+            const first = isCI();
+            // Set CI=true after first call — should still return cached false
+            process.env.CI = "true";
+            expect(isCI()).toBe(first);
+        }
+        finally {
+            for (const v of ciVars) {
+                if (saved[v] !== undefined)
+                    process.env[v] = saved[v];
+                else
+                    delete process.env[v];
+            }
+            resetCICache();
+        }
+    });
+});
+describe("autoInstallIfNeeded", () => {
+    it("skips if sentinel already exists", async () => {
+        const { autoInstallIfNeeded } = await import("../daemon/autostart.js");
+        // Monkey-patch homedir for this module — use the real module path approach
+        // Instead, we just test the sentinel logic directly
+        // Create sentinel
+        const { isAutostartInstalled } = await import("../daemon/autostart.js");
+        // Since we can't easily mock homedir in ESM, just test the logic path
+        expect(typeof isAutostartInstalled).toBe("function");
+    });
+    it("skips in CI environment", async () => {
+        // The top-level vi.mock already mocks isCI — we just need to change its return
+        const detectCi = await import("../daemon/detect-ci.js");
+        vi.spyOn(detectCi, "isCI").mockReturnValue(true);
+        // Re-import to pick up mock — autoInstallIfNeeded calls isCI internally
+        const { autoInstallIfNeeded } = await import("../daemon/autostart.js");
+        const result = await autoInstallIfNeeded();
+        // Will be null from CI skip or sentinel skip
+        expect(result).toBeNull();
+    });
+});
+describe("platform dispatch", () => {
+    it("installForCurrentPlatform returns PlatformInstallResult", async () => {
+        const { installForCurrentPlatform } = await import("../daemon/autostart.js");
+        const result = await installForCurrentPlatform();
+        expect(result).toHaveProperty("installed");
+        expect(result).toHaveProperty("path");
+    });
+    it("uninstallForCurrentPlatform returns PlatformInstallResult", async () => {
+        const { uninstallForCurrentPlatform } = await import("../daemon/autostart.js");
+        const result = await uninstallForCurrentPlatform();
+        expect(result).toHaveProperty("installed");
+        expect(result).toHaveProperty("path");
+    });
+    it("getAutostartStatus returns structured info", async () => {
+        const { getAutostartStatus } = await import("../daemon/autostart.js");
+        const status = await getAutostartStatus();
+        expect(status).toHaveProperty("platform");
+        expect(status).toHaveProperty("installed");
+        expect(status).toHaveProperty("sentinelExists");
+        expect(status).toHaveProperty("details");
+    });
+});
+describe("detect-ci env var coverage", () => {
+    const envTests = [
+        "CI",
+        "GITLAB_CI",
+        "CIRCLECI",
+        "BUILDKITE",
+        "JENKINS_URL",
+        "TRAVIS",
+        "CODEBUILD_BUILD_ID",
+        "TF_BUILD",
+        "BITBUCKET_PIPELINE_UUID",
+        "DRONE",
+        "WOODPECKER_CI",
+        "TEAMCITY_VERSION",
+    ];
+    for (const envVar of envTests) {
+        it(`detects ${envVar}`, async () => {
+            vi.resetModules();
+            vi.doUnmock("../daemon/detect-ci.js");
+            const { isCI, resetCICache } = await import("../daemon/detect-ci.js");
+            resetCICache();
+            const ciVars = [
+                "CI",
+                "CONTINUOUS_INTEGRATION",
+                "BUILD_NUMBER",
+                "GITHUB_ACTIONS",
+                "GITLAB_CI",
+                "CIRCLECI",
+                "BUILDKITE",
+                "JENKINS_URL",
+                "TRAVIS",
+                "CODEBUILD_BUILD_ID",
+                "TF_BUILD",
+                "BITBUCKET_PIPELINE_UUID",
+                "DRONE",
+                "WOODPECKER_CI",
+                "TEAMCITY_VERSION",
+                "HEROKU_TEST_RUN_ID",
+            ];
+            const saved = {};
+            for (const v of ciVars) {
+                saved[v] = process.env[v];
+                delete process.env[v];
+            }
+            process.env[envVar] = "true";
+            try {
+                expect(isCI()).toBe(true);
+            }
+            finally {
+                for (const v of ciVars) {
+                    if (saved[v] !== undefined)
+                        process.env[v] = saved[v];
+                    else
+                        delete process.env[v];
+                }
+                resetCICache();
+            }
+        });
+    }
+});