muonroi-cli 1.8.0 → 1.8.3

package/dist/src/storage/__tests__/migrations.test.js

@@ -1,357 +0,0 @@
-/**
- * src/storage/__tests__/migrations.test.ts
- *
- * Tests for DB migration v3 (pil_active + enrichment_delta columns).
- *
- * Uses an in-memory SQLiteDatabase implemented via vi.mock for bun:sqlite,
- * then delegates to a pure-JS in-memory store to verify schema mutations.
- *
- * Strategy: mock `bun:sqlite` before import, then use the SQLiteDatabase
- * interface directly to call applyMigrations() and assert column additions.
- */
-import { describe, expect, it } from "vitest";
-class InMemoryDatabase {
-    tables = new Map();
-    rows = new Map();
-    userVersion = 0;
-    exec(sql) {
-        // Parse CREATE TABLE statements to extract column info
-        this.parseAndApply(sql);
-    }
-    parseAndApply(sql) {
-        // Split on semicolons for multi-statement exec
-        const stmts = sql
-            .split(";")
-            .map((s) => s.trim())
-            .filter(Boolean);
-        for (const stmt of stmts) {
-            this.applySingleStatement(stmt);
-        }
-    }
-    applySingleStatement(stmt) {
-        const upper = stmt.trim().toUpperCase();
-        if (upper.startsWith("CREATE TABLE")) {
-            this.applyCreateTable(stmt);
-        }
-        else if (upper.startsWith("ALTER TABLE") && upper.includes("ADD COLUMN")) {
-            this.applyAlterTable(stmt);
-        }
-        else if (upper.startsWith("CREATE INDEX") || upper.startsWith("PRAGMA")) {
-            // Ignore indexes and pragma in exec (pragma handled separately)
-        }
-        // INSERT, SELECT, etc. handled in prepare()
-    }
-    applyCreateTable(stmt) {
-        // Extract table name
-        const match = stmt.match(/CREATE\s+TABLE\s+(?:IF\s+NOT\s+EXISTS\s+)?(\w+)\s*\(/i);
-        if (!match)
-            return;
-        const tableName = match[1].toLowerCase();
-        if (this.tables.has(tableName))
-            return; // IF NOT EXISTS
-        const columns = new Map();
-        // Extract column definitions (simplified — handles PRIMARY KEY, NOT NULL, DEFAULT)
-        const body = stmt.slice(stmt.indexOf("(") + 1, stmt.lastIndexOf(")"));
-        const colDefs = this.splitColumnDefs(body);
-        for (const def of colDefs) {
-            const parsed = this.parseColumnDef(def);
-            if (parsed)
-                columns.set(parsed.name.toLowerCase(), parsed);
-        }
-        this.tables.set(tableName, columns);
-        this.rows.set(tableName, []);
-    }
-    applyAlterTable(stmt) {
-        const match = stmt.match(/ALTER\s+TABLE\s+(\w+)\s+ADD\s+COLUMN\s+(.*)/i);
-        if (!match)
-            return;
-        const tableName = match[1].toLowerCase();
-        const colDef = match[2].trim().replace(/;$/, "");
-        const parsed = this.parseColumnDef(colDef);
-        if (!parsed)
-            return;
-        const table = this.tables.get(tableName);
-        if (!table)
-            return;
-        // Do not add if already exists (idempotent)
-        if (!table.has(parsed.name.toLowerCase())) {
-            table.set(parsed.name.toLowerCase(), parsed);
-        }
-    }
-    splitColumnDefs(body) {
-        const defs = [];
-        let depth = 0;
-        let current = "";
-        for (const ch of body) {
-            if (ch === "(")
-                depth++;
-            else if (ch === ")")
-                depth--;
-            else if (ch === "," && depth === 0) {
-                defs.push(current.trim());
-                current = "";
-                continue;
-            }
-            current += ch;
-        }
-        if (current.trim())
-            defs.push(current.trim());
-        return defs;
-    }
-    parseColumnDef(def) {
-        const tokens = def.trim().split(/\s+/);
-        if (!tokens[0])
-            return null;
-        const name = tokens[0].replace(/^"|"$/g, "");
-        // Skip table constraints (PRIMARY KEY, UNIQUE, FOREIGN KEY, CHECK)
-        const upper = name.toUpperCase();
-        if (["PRIMARY", "UNIQUE", "FOREIGN", "CHECK", "CONSTRAINT"].includes(upper))
-            return null;
-        const type = tokens[1] ?? "TEXT";
-        const notNull = def.toUpperCase().includes("NOT NULL");
-        let defaultVal = null;
-        const defaultMatch = def.match(/DEFAULT\s+(\S+)/i);
-        if (defaultMatch) {
-            const raw = defaultMatch[1].replace(/['"]/g, "");
-            defaultVal = Number.isNaN(Number(raw)) ? raw : Number(raw);
-        }
-        return { name: name.toLowerCase(), type, notNull, defaultVal };
-    }
-    prepare(sql) {
-        return {
-            run: (...params) => this.runInsert(sql, params),
-            get: (...params) => this.runQuery(sql, params),
-            all: (...params) => this.runQueryAll(sql, params),
-        };
-    }
-    runInsert(sql, params) {
-        const upper = sql.trim().toUpperCase();
-        if (!upper.startsWith("INSERT"))
-            return;
-        // Extract table name
-        const match = sql.match(/INSERT\s+INTO\s+(\w+)\s*\(([^)]+)\)\s*VALUES/i);
-        if (!match)
-            return;
-        const tableName = match[1].toLowerCase();
-        const colNames = match[2].split(",").map((c) => c.trim().toLowerCase());
-        const tableRows = this.rows.get(tableName) ?? [];
-        const table = this.tables.get(tableName);
-        if (!table)
-            return;
-        // Build row from params + defaults
-        const row = {};
-        for (const [i, colName] of colNames.entries()) {
-            row[colName] = params[i];
-        }
-        // Apply defaults for missing columns
-        for (const [colName, def] of table.entries()) {
-            if (!(colName in row)) {
-                row[colName] = def.defaultVal;
-            }
-        }
-        tableRows.push(row);
-        this.rows.set(tableName, tableRows);
-        return row;
-    }
-    runQuery(sql, _params) {
-        const upper = sql.trim().toUpperCase();
-        if (upper.startsWith("PRAGMA")) {
-            if (upper.includes("TABLE_INFO")) {
-                const match = sql.match(/table_info\((\w+)\)/i);
-                if (!match)
-                    return null;
-                const tableName = match[1].toLowerCase();
-                const table = this.tables.get(tableName);
-                if (!table)
-                    return null;
-                const cols = [...table.values()];
-                return cols.length > 0 ? cols[0] : null;
-            }
-            if (upper.includes("USER_VERSION")) {
-                return { user_version: this.userVersion };
-            }
-            return null;
-        }
-        return null;
-    }
-    runQueryAll(sql, params) {
-        const upper = sql.trim().toUpperCase();
-        if (upper.startsWith("PRAGMA") && upper.includes("TABLE_INFO")) {
-            const match = sql.match(/table_info\((\w+)\)/i);
-            if (!match)
-                return [];
-            const tableName = match[1].toLowerCase();
-            const table = this.tables.get(tableName);
-            if (!table)
-                return [];
-            return [...table.values()].map((col, i) => ({
-                cid: i,
-                name: col.name,
-                type: col.type,
-                notnull: col.notNull ? 1 : 0,
-                dflt_value: col.defaultVal,
-                pk: 0,
-            }));
-        }
-        if (upper.startsWith("SELECT")) {
-            const fromMatch = sql.match(/FROM\s+(\w+)/i);
-            if (!fromMatch)
-                return [];
-            const tableName = fromMatch[1].toLowerCase();
-            const tableRows = this.rows.get(tableName) ?? [];
-            // Handle WHERE clause with = ?
-            const whereMatch = sql.match(/WHERE\s+(\w+)\s*=\s*\?/i);
-            if (whereMatch) {
-                const col = whereMatch[1].toLowerCase();
-                const val = params[0];
-                return tableRows.filter((r) => r[col] === val);
-            }
-            return tableRows;
-        }
-        return [];
-    }
-    pragma(query, options) {
-        if (query.includes("=")) {
-            const versionMatch = query.match(/user_version\s*=\s*(\d+)/i);
-            if (versionMatch) {
-                this.userVersion = Number(versionMatch[1]);
-            }
-            return undefined;
-        }
-        if (query.toLowerCase().includes("user_version")) {
-            if (options?.simple)
-                return this.userVersion;
-            return { user_version: this.userVersion };
-        }
-        return undefined;
-    }
-    transaction(fn) {
-        return fn; // No-op transaction for test
-    }
-    close() {
-        /* no-op */
-    }
-}
-import { applyMigrations } from "../migrations.js";
-function makeDb() {
-    const raw = new InMemoryDatabase();
-    return { db: raw, raw };
-}
-describe("DB migrations", () => {
-    it("Test 1: DB starting at version 0 creates usage_events with pil_active + enrichment_delta columns", () => {
-        const { db, raw } = makeDb();
-        applyMigrations(db);
-        const table = raw.tables.get("usage_events");
-        expect(table).toBeDefined();
-        expect(table.has("pil_active")).toBe(true);
-        expect(table.has("enrichment_delta")).toBe(true);
-    });
-    it("Test 2: DB at version 2 — migration v3 adds both columns without dropping existing ones", () => {
-        const { db, raw } = makeDb();
-        // Simulate existing v2 schema with usage_events but no pil_active
-        raw.tables.set("usage_events", new Map([
-            ["id", { name: "id", type: "INTEGER", notNull: true, defaultVal: null }],
-            ["session_id", { name: "session_id", type: "TEXT", notNull: true, defaultVal: null }],
-            ["source", { name: "source", type: "TEXT", notNull: true, defaultVal: null }],
-            ["model", { name: "model", type: "TEXT", notNull: true, defaultVal: null }],
-            ["created_at", { name: "created_at", type: "TEXT", notNull: true, defaultVal: null }],
-            ["cost_micros", { name: "cost_micros", type: "INTEGER", notNull: true, defaultVal: 0 }],
-        ]));
-        raw.tables.set("sessions", new Map());
-        raw.tables.set("workspaces", new Map());
-        raw.tables.set("messages", new Map());
-        raw.tables.set("tool_calls", new Map());
-        raw.tables.set("tool_results", new Map());
-        raw.tables.set("compactions", new Map());
-        raw.userVersion = 2;
-        applyMigrations(db);
-        const table = raw.tables.get("usage_events");
-        expect(table.has("pil_active")).toBe(true);
-        expect(table.has("enrichment_delta")).toBe(true);
-        // Existing columns preserved
-        expect(table.has("session_id")).toBe(true);
-        expect(table.has("cost_micros")).toBe(true);
-        expect(table.has("created_at")).toBe(true);
-    });
-    it("Test 3: DB already at version 3 — applyMigrations is idempotent (no error, no duplicate columns)", () => {
-        const { db, raw } = makeDb();
-        applyMigrations(db);
-        expect(() => applyMigrations(db)).not.toThrow();
-        const table = raw.tables.get("usage_events");
-        // Columns should appear exactly once
-        const cols = [...table.keys()];
-        const pilCount = cols.filter((c) => c === "pil_active").length;
-        const deltaCount = cols.filter((c) => c === "enrichment_delta").length;
-        expect(pilCount).toBe(1);
-        expect(deltaCount).toBe(1);
-    });
-    it("Test 4: row inserted without pil_active/enrichment_delta uses DEFAULT 0", () => {
-        const { db, raw } = makeDb();
-        applyMigrations(db);
-        // Add required parent rows to tables
-        raw.rows.set("workspaces", [
-            {
-                id: "ws1",
-                scope_key: "/tmp",
-                canonical_path: "/tmp",
-                display_name: "test",
-                last_seen_at: new Date().toISOString(),
-            },
-        ]);
-        raw.rows.set("sessions", [
-            {
-                id: "sess1",
-                workspace_id: "ws1",
-                model: "claude",
-                mode: "safe",
-                cwd_at_start: "/tmp",
-                cwd_last: "/tmp",
-                status: "active",
-                created_at: new Date().toISOString(),
-                updated_at: new Date().toISOString(),
-            },
-        ]);
-        raw.rows.set("usage_events", []);
-        // Insert without pil_active/enrichment_delta — should default to 0
-        db.prepare(`INSERT INTO usage_events (session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?)`).run("sess1", null, "orchestrator", "claude", 100, 50, 150, 0, new Date().toISOString());
-        const usageRows = raw.rows.get("usage_events");
-        expect(usageRows).toHaveLength(1);
-        expect(usageRows[0].pil_active).toBe(0);
-        expect(usageRows[0].enrichment_delta).toBe(0);
-    });
-    it("Test 5: row inserted with pilActive=true and enrichmentDelta=-120 stores 1 and -120", () => {
-        const { db, raw } = makeDb();
-        applyMigrations(db);
-        raw.rows.set("workspaces", [
-            {
-                id: "ws2",
-                scope_key: "/tmp2",
-                canonical_path: "/tmp2",
-                display_name: "test2",
-                last_seen_at: new Date().toISOString(),
-            },
-        ]);
-        raw.rows.set("sessions", [
-            {
-                id: "sess2",
-                workspace_id: "ws2",
-                model: "claude",
-                mode: "safe",
-                cwd_at_start: "/tmp2",
-                cwd_last: "/tmp2",
-                status: "active",
-                created_at: new Date().toISOString(),
-                updated_at: new Date().toISOString(),
-            },
-        ]);
-        raw.rows.set("usage_events", []);
-        db.prepare(`INSERT INTO usage_events (session_id, message_seq, source, model, input_tokens, output_tokens, total_tokens, cost_micros, created_at, pil_active, enrichment_delta)
-       VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`).run("sess2", null, "orchestrator", "claude", 100, 50, 150, 0, new Date().toISOString(), 1, -120);
-        const usageRows = raw.rows.get("usage_events");
-        expect(usageRows).toHaveLength(1);
-        expect(usageRows[0].pil_active).toBe(1);
-        expect(usageRows[0].enrichment_delta).toBe(-120);
-    });
-});
-//# sourceMappingURL=migrations.test.js.map

package/dist/src/storage/__tests__/sweep-stale-pending.test.d.ts

@@ -1,10 +0,0 @@
-/**
- * src/storage/__tests__/sweep-stale-pending.test.ts
- *
- * Verifies sweepStalePendingRows shapes its SQL correctly and threads the
- * staleness cutoff through to both UPDATE statements. bun:sqlite is mocked
- * globally for vitest (see src/__test-stubs__/vitest-setup.ts); we capture
- * every prepare() + run() to assert SQL + bound params without standing up
- * a real DB.
- */
-export {};

package/dist/src/storage/__tests__/sweep-stale-pending.test.js

@@ -1,97 +0,0 @@
-/**
- * src/storage/__tests__/sweep-stale-pending.test.ts
- *
- * Verifies sweepStalePendingRows shapes its SQL correctly and threads the
- * staleness cutoff through to both UPDATE statements. bun:sqlite is mocked
- * globally for vitest (see src/__test-stubs__/vitest-setup.ts); we capture
- * every prepare() + run() to assert SQL + bound params without standing up
- * a real DB.
- */
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-const preparedCalls = [];
-let dbShouldThrow = false;
-let toolCallsChanges = 0;
-let messagesChanges = 0;
-vi.mock("../db", () => {
-    const makeDb = () => ({
-        prepare: (sql) => ({
-            run: (...args) => {
-                preparedCalls.push({ sql, runArgs: args });
-                const lower = sql.toLowerCase();
-                if (lower.includes("update tool_calls")) {
-                    return { changes: toolCallsChanges };
-                }
-                if (lower.includes("update messages")) {
-                    return { changes: messagesChanges };
-                }
-                return { changes: 0 };
-            },
-            get: () => undefined,
-            all: () => [],
-        }),
-        exec: () => undefined,
-        pragma: () => undefined,
-        transaction: (fn) => fn,
-        close: () => undefined,
-    });
-    return {
-        getDatabase: () => {
-            if (dbShouldThrow)
-                throw new Error("simulated SQL failure");
-            return makeDb();
-        },
-    };
-});
-import { sweepStalePendingRows } from "../transcript.js";
-describe("sweepStalePendingRows", () => {
-    beforeEach(() => {
-        preparedCalls.length = 0;
-        dbShouldThrow = false;
-        toolCallsChanges = 0;
-        messagesChanges = 0;
-    });
-    afterEach(() => {
-        vi.restoreAllMocks();
-    });
-    it("emits two UPDATE statements — one per pending-row class", () => {
-        sweepStalePendingRows();
-        const sqls = preparedCalls.map((c) => c.sql.toLowerCase());
-        expect(sqls.some((s) => s.includes("update tool_calls") && s.includes("status = 'aborted'"))).toBe(true);
-        expect(sqls.some((s) => s.includes("update messages") && s.includes("status = 'aborted'"))).toBe(true);
-    });
-    it("scopes tool_calls update to status='pending' and stale started_at", () => {
-        sweepStalePendingRows(1000);
-        const toolCallSql = preparedCalls.find((c) => c.sql.toLowerCase().includes("update tool_calls"))?.sql.toLowerCase();
-        expect(toolCallSql).toContain("status = 'pending'");
-        expect(toolCallSql).toContain("started_at <");
-    });
-    it("scopes messages update to status='pending' and stale created_at", () => {
-        sweepStalePendingRows(1000);
-        const messagesSql = preparedCalls.find((c) => c.sql.toLowerCase().includes("update messages"))?.sql.toLowerCase();
-        expect(messagesSql).toContain("status = 'pending'");
-        expect(messagesSql).toContain("created_at <");
-    });
-    it("returns the changed-row counts surfaced by SQLite", () => {
-        toolCallsChanges = 3;
-        messagesChanges = 1;
-        const result = sweepStalePendingRows();
-        expect(result).toEqual({ toolCalls: 3, messages: 1 });
-    });
-    it("returns zeroed counts on DB exception (fail-open)", () => {
-        dbShouldThrow = true;
-        const consoleSpy = vi.spyOn(console, "error").mockImplementation(() => undefined);
-        const result = sweepStalePendingRows();
-        expect(result).toEqual({ toolCalls: 0, messages: 0 });
-        expect(consoleSpy).toHaveBeenCalledWith(expect.stringContaining("sweepStalePendingRows failed"));
-    });
-    it("computes the cutoff timestamp as Date.now() - staleAfterMs", () => {
-        const fixedNow = new Date("2026-05-22T10:00:00.000Z").getTime();
-        vi.spyOn(Date, "now").mockReturnValue(fixedNow);
-        sweepStalePendingRows(60_000);
-        const toolCallCall = preparedCalls.find((c) => c.sql.toLowerCase().includes("update tool_calls"));
-        // run args: [now, cutoff]
-        const cutoff = toolCallCall?.runArgs[1];
-        expect(cutoff).toBe("2026-05-22T09:59:00.000Z");
-    });
-});
-//# sourceMappingURL=sweep-stale-pending.test.js.map

package/dist/src/storage/__tests__/ui-interaction-log.test.d.ts

@@ -1,7 +0,0 @@
-/**
- * Tests for logUIInteraction — verify subtype routing and fail-open behaviour.
- *
- * The underlying logInteraction is mocked so we can assert the call shape
- * without standing up a SQLite test fixture.
- */
-export {};

package/dist/src/storage/__tests__/ui-interaction-log.test.js

@@ -1,127 +0,0 @@
-/**
- * Tests for logUIInteraction — verify subtype routing and fail-open behaviour.
- *
- * The underlying logInteraction is mocked so we can assert the call shape
- * without standing up a SQLite test fixture.
- */
-import { beforeEach, describe, expect, it, vi } from "vitest";
-vi.mock("../interaction-log.js", () => ({
-    logInteraction: vi.fn(),
-}));
-import { logInteraction } from "../interaction-log.js";
-import { logUIInteraction } from "../ui-interaction-log.js";
-describe("logUIInteraction", () => {
-    beforeEach(() => {
-        vi.mocked(logInteraction).mockClear();
-    });
-    it("skips persistence when sessionId is null", () => {
-        logUIInteraction(null, {
-            subtype: "route_decision",
-            data: { path: "hot-path", complexity: "low", forceCouncil: false, runId: "r1" },
-        });
-        expect(logInteraction).not.toHaveBeenCalled();
-    });
-    it("skips persistence when sessionId is undefined", () => {
-        logUIInteraction(undefined, {
-            subtype: "askcard_open",
-            data: { questionId: "q1", question: "?", phase: "clarify", optionCount: 2 },
-        });
-        expect(logInteraction).not.toHaveBeenCalled();
-    });
-    it("persists askcard_open option labels + recommended label for measurement", () => {
-        // Observability gap (live obs 2026-06-04): askcard_open only stored
-        // optionCount + defaultIndex, so a DB/forensics audit could see WHICH index
-        // was recommended but never WHAT it pointed at — making the scope-card
-        // recommend fix (#47) unverifiable from past sessions. Persist the labels.
-        logUIInteraction("sess-labels", {
-            subtype: "askcard_open",
-            data: {
-                questionId: "q-scope",
-                question: "Which part of the codebase should this target?",
-                phase: "clarify",
-                optionCount: 3,
-                defaultIndex: 2,
-                optionLabels: ["src/cli (cli)", "src/council (council)", "Entire project"],
-                recommendedLabel: "Entire project",
-            },
-        });
-        expect(logInteraction).toHaveBeenCalledWith("sess-labels", "ui_interaction", {
-            eventSubtype: "askcard_open",
-            data: {
-                questionId: "q-scope",
-                question: "Which part of the codebase should this target?",
-                phase: "clarify",
-                optionCount: 3,
-                defaultIndex: 2,
-                optionLabels: ["src/cli (cli)", "src/council (council)", "Entire project"],
-                recommendedLabel: "Entire project",
-            },
-        });
-    });
-    it("writes ui_interaction with subtype and structured payload", () => {
-        logUIInteraction("sess-1", {
-            subtype: "askcard_answered",
-            data: { questionId: "q1", answerKind: "choice", answerText: "React" },
-        });
-        expect(logInteraction).toHaveBeenCalledWith("sess-1", "ui_interaction", {
-            eventSubtype: "askcard_answered",
-            data: { questionId: "q1", answerKind: "choice", answerText: "React" },
-        });
-    });
-    it("routes each subtype with the right shape", () => {
-        const cases = [
-            {
-                subtype: "route_decision",
-                data: { path: "council", complexity: "high", forceCouncil: true, runId: "r9" },
-            },
-            {
-                subtype: "sprint_stage",
-                data: { sprintIndex: 1, stage: "planning", runId: "r9" },
-            },
-            { subtype: "sprint_halt", data: { sprintN: 2, reason: "no_recipe", runId: "r9" } },
-            { subtype: "askcard_cancel", data: { questionId: "q9" } },
-            {
-                subtype: "halt_card_open",
-                data: {
-                    reason: "no_recipe",
-                    optionCount: 3,
-                    optionIds: ["init_new", "point_to_existing", "continue_as_council"],
-                },
-            },
-            {
-                subtype: "halt_card_answered",
-                data: { chosenId: "init_new", chosenLabel: "Init new project", index: 0 },
-            },
-            { subtype: "init_new_step", data: { from: "name", to: "fe-stack" } },
-            {
-                subtype: "init_new_submitted",
-                data: { projectName: "todo-app", feStack: "react", bbTemplate: "mr-base-sln", packageCount: 5 },
-            },
-            {
-                subtype: "init_new_result",
-                data: { outcome: "error", message: "dotnet new install failed: exit 1" },
-            },
-        ];
-        for (const c of cases) {
-            logUIInteraction("sess-2", c);
-        }
-        expect(vi.mocked(logInteraction).mock.calls.map(([, , meta]) => meta?.eventSubtype)).toEqual([
-            "route_decision",
-            "sprint_stage",
-            "sprint_halt",
-            "askcard_cancel",
-            "halt_card_open",
-            "halt_card_answered",
-            "init_new_step",
-            "init_new_submitted",
-            "init_new_result",
-        ]);
-    });
-    it("fails open when logInteraction throws", () => {
-        vi.mocked(logInteraction).mockImplementationOnce(() => {
-            throw new Error("db gone");
-        });
-        expect(() => logUIInteraction("sess-3", { subtype: "askcard_cancel", data: { questionId: "q1" } })).not.toThrow();
-    });
-});
-//# sourceMappingURL=ui-interaction-log.test.js.map

package/dist/src/storage/atomic-io.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/src/storage/atomic-io.test.js

@@ -1,74 +0,0 @@
-import { promises as fs } from "node:fs";
-import * as os from "node:os";
-import * as path from "node:path";
-import { afterEach, beforeEach, describe, expect, it } from "vitest";
-import { atomicReadJSON, atomicWriteJSON, sweepStaleAtomicTemps } from "./atomic-io.js";
-let tmpDir;
-beforeEach(async () => {
-    tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "atomic-io-test-"));
-});
-afterEach(async () => {
-    await fs.rm(tmpDir, { recursive: true, force: true, maxRetries: 10, retryDelay: 50 });
-});
-describe("atomicWriteJSON", () => {
-    it("Test 1: writes file and removes .tmp on success", { retry: 2 }, async () => {
-        const filePath = path.join(tmpDir, "foo.json");
-        await atomicWriteJSON(filePath, { hello: 1 });
-        const raw = await fs.readFile(filePath, "utf8");
-        expect(JSON.parse(raw)).toEqual({ hello: 1 });
-        // .tmp must NOT exist after success
-        await expect(fs.access(`${filePath}.tmp`)).rejects.toThrow();
-    });
-    it("Test 2: throws on circular reference and does not leave .tmp", async () => {
-        const filePath = path.join(tmpDir, "cyclic.json");
-        // Write a pre-existing file to confirm it remains untouched on error
-        await fs.writeFile(filePath, JSON.stringify({ safe: true }), "utf8");
-        // Create a circular object
-        const cyclic = {};
-        cyclic.self = cyclic;
-        await expect(atomicWriteJSON(filePath, cyclic)).rejects.toThrow();
-        // Pre-existing file must be untouched
-        const raw = await fs.readFile(filePath, "utf8");
-        expect(JSON.parse(raw)).toEqual({ safe: true });
-        // .tmp must NOT exist after failure
-        await expect(fs.access(`${filePath}.tmp`)).rejects.toThrow();
-    });
-});
-describe("atomicReadJSON", () => {
-    it("Test 3: returns null for absent file", async () => {
-        const filePath = path.join(tmpDir, "never-written.json");
-        const result = await atomicReadJSON(filePath);
-        expect(result).toBeNull();
-    });
-    it("Test 4: throws on corrupted (invalid JSON) file", async () => {
-        const filePath = path.join(tmpDir, "corrupt.json");
-        await fs.writeFile(filePath, "{ this is not valid json }", "utf8");
-        await expect(atomicReadJSON(filePath)).rejects.toThrow();
-    });
-});
-describe("sweepStaleAtomicTemps", () => {
-    it("Test 5: removes only matching .{pid}.{hex}.tmp older than cutoff", async () => {
-        const oldStale = path.join(tmpDir, "state.json.12345.abcdef012345.tmp");
-        const freshStale = path.join(tmpDir, "state.json.99999.fedcba543210.tmp");
-        const unrelated = path.join(tmpDir, "notes.tmp");
-        const real = path.join(tmpDir, "state.json");
-        await fs.writeFile(oldStale, "{}");
-        await fs.writeFile(freshStale, "{}");
-        await fs.writeFile(unrelated, "junk");
-        await fs.writeFile(real, "{}");
-        // Backdate oldStale by 48h
-        const old = Date.now() / 1000 - 48 * 3600;
-        await fs.utimes(oldStale, old, old);
-        const removed = await sweepStaleAtomicTemps(tmpDir, 24 * 60 * 60 * 1000);
-        expect(removed).toBe(1);
-        await expect(fs.access(oldStale)).rejects.toThrow();
-        await expect(fs.access(freshStale)).resolves.toBeUndefined();
-        await expect(fs.access(unrelated)).resolves.toBeUndefined();
-        await expect(fs.access(real)).resolves.toBeUndefined();
-    });
-    it("Test 6: returns 0 and does not throw when dir does not exist", async () => {
-        const removed = await sweepStaleAtomicTemps(path.join(tmpDir, "does-not-exist"));
-        expect(removed).toBe(0);
-    });
-});
-//# sourceMappingURL=atomic-io.test.js.map

package/dist/src/storage/config.test.d.ts

@@ -1 +0,0 @@
-export {};