akm-cli 0.7.0 → 0.7.1

package/dist/tests/llm-client.test.js

@@ -1,115 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { chatCompletion, redactErrorBody } from "../src/llm/client";
-// ── redactErrorBody ─────────────────────────────────────────────────────────
-describe("redactErrorBody", () => {
-    test("redacts Bearer tokens", () => {
-        const out = redactErrorBody("Authorization: Bearer abc123XYZ.token-value");
-        expect(out).not.toContain("abc123XYZ");
-        expect(out).toContain("Bearer [REDACTED]");
-    });
-    test("redacts sk-* style API keys", () => {
-        const out = redactErrorBody('{"error":"bad key sk-proj-Abcdef1234567890ZZZ"}');
-        expect(out).not.toContain("sk-proj-Abcdef");
-        expect(out).toContain("[REDACTED]");
-    });
-    test("redacts JSON api_key fields", () => {
-        const out = redactErrorBody('{"api_key":"super-secret-12345","other":"safe"}');
-        expect(out).not.toContain("super-secret-12345");
-        expect(out).toContain("[REDACTED]");
-        expect(out).toContain("other");
-    });
-    test("redacts JSON apiKey camelCase fields", () => {
-        const out = redactErrorBody('{"apiKey": "topsecretvalue"}');
-        expect(out).not.toContain("topsecretvalue");
-        expect(out).toContain("[REDACTED]");
-    });
-    test("trims output to 200 chars", () => {
-        const huge = "x".repeat(2000);
-        const out = redactErrorBody(huge);
-        expect(out.length).toBeLessThanOrEqual(201); // 200 + ellipsis char
-    });
-    test("returns empty for empty input", () => {
-        expect(redactErrorBody("")).toBe("");
-    });
-    test("preserves non-secret content under cap", () => {
-        expect(redactErrorBody("plain error message")).toBe("plain error message");
-    });
-});
-// ── chatCompletion error path ───────────────────────────────────────────────
-function createErrorServer(statusCode, body) {
-    const server = Bun.serve({
-        port: 0,
-        fetch() {
-            return new Response(body, { status: statusCode });
-        },
-    });
-    return { url: `http://localhost:${server.port}`, server };
-}
-describe("chatCompletion error redaction", () => {
-    test("redacts API key from 401 response body and keeps status + URL", async () => {
-        const leakBody = '{"error":{"message":"Invalid API key sk-proj-LEAKYKEYABCDEF12345"}}';
-        const { url, server } = createErrorServer(401, leakBody);
-        try {
-            const config = {
-                endpoint: url,
-                model: "test-model",
-                apiKey: "sk-proj-LEAKYKEYABCDEF12345",
-            };
-            let caught;
-            try {
-                await chatCompletion(config, [{ role: "user", content: "hi" }]);
-            }
-            catch (err) {
-                caught = err;
-            }
-            expect(caught).toBeDefined();
-            expect(caught?.message).toContain("(401)");
-            expect(caught?.message).toContain(url);
-            expect(caught?.message).not.toContain("sk-proj-LEAKYKEYABCDEF12345");
-            expect(caught?.message).toContain("[REDACTED]");
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("trims oversized error body but keeps status code intact", async () => {
-        const huge = "A".repeat(5000);
-        const { url, server } = createErrorServer(503, huge);
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            let caught;
-            try {
-                await chatCompletion(config, [{ role: "user", content: "hi" }]);
-            }
-            catch (err) {
-                caught = err;
-            }
-            expect(caught).toBeDefined();
-            expect(caught?.message).toContain("(503)");
-            // Status + URL prefix should remain; the body portion is truncated.
-            expect((caught?.message ?? "").length).toBeLessThan(huge.length);
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("redacts Bearer header echoed back by provider", async () => {
-        const body = "Got header Authorization: Bearer abcXYZsupersecret999";
-        const { url, server } = createErrorServer(403, body);
-        try {
-            const config = { endpoint: url, model: "test-model", apiKey: "abcXYZsupersecret999" };
-            let caught;
-            try {
-                await chatCompletion(config, [{ role: "user", content: "hi" }]);
-            }
-            catch (err) {
-                caught = err;
-            }
-            expect(caught?.message).not.toContain("abcXYZsupersecret999");
-            expect(caught?.message).toContain("Bearer [REDACTED]");
-        }
-        finally {
-            server.stop();
-        }
-    });
-});

package/dist/tests/llm-feature-gate.test.js

@@ -1,151 +0,0 @@
-/**
- * Per-feature LLM gate seam (v1 spec §14, #227).
- *
- * Locks:
- *   - `isLlmFeatureEnabled` returns `true` only when the named flag is the
- *     literal boolean `true` in config (defaults are `false`).
- *   - `tryLlmFeature` returns the fallback on disablement, on any thrown
- *     error, and on hard-timeout — and never lets `fn`'s exception bubble.
- *   - The fallback may be a value or a thunk; the thunk is only invoked on
- *     the fallback path.
- *   - The wrapper notifies the optional `onFallback` sink with a structured
- *     `{ feature, reason, error? }` event, where `reason` is one of
- *     `"disabled" | "timeout" | "error"`.
- */
-import { describe, expect, test } from "bun:test";
-import { isLlmFeatureEnabled, LlmFeatureTimeoutError, tryLlmFeature } from "../src/llm/feature-gate";
-const baseLlm = {
-    endpoint: "http://example.invalid/v1/chat",
-    model: "test-model",
-};
-function configWith(features) {
-    return {
-        stashDir: "/tmp/stash",
-        llm: { ...baseLlm, features },
-    };
-}
-describe("isLlmFeatureEnabled", () => {
-    test("returns false when no llm config is present", () => {
-        expect(isLlmFeatureEnabled(undefined, "curate_rerank")).toBe(false);
-        expect(isLlmFeatureEnabled({}, "curate_rerank")).toBe(false);
-    });
-    test("returns false when the features block is missing", () => {
-        const cfg = { stashDir: "/tmp", llm: baseLlm };
-        expect(isLlmFeatureEnabled(cfg, "feedback_distillation")).toBe(false);
-    });
-    test("returns false when the key is absent (default-false)", () => {
-        const cfg = configWith({});
-        expect(isLlmFeatureEnabled(cfg, "graph_extraction")).toBe(false);
-    });
-    test("returns true only on literal boolean true", () => {
-        expect(isLlmFeatureEnabled(configWith({ feedback_distillation: true }), "feedback_distillation")).toBe(true);
-        expect(isLlmFeatureEnabled(configWith({ feedback_distillation: false }), "feedback_distillation")).toBe(false);
-    });
-});
-describe("tryLlmFeature", () => {
-    test("returns the fallback (and never calls fn) when the gate is disabled", async () => {
-        let called = false;
-        const events = [];
-        const result = await tryLlmFeature("curate_rerank", configWith({}), async () => {
-            called = true;
-            return "real";
-        }, "fallback", { onFallback: (e) => events.push(e) });
-        expect(result).toBe("fallback");
-        expect(called).toBe(false);
-        expect(events).toEqual([{ feature: "curate_rerank", reason: "disabled" }]);
-    });
-    test("invokes a thunk fallback only on the fallback path", async () => {
-        let fallbackInvocations = 0;
-        const result = await tryLlmFeature("memory_inference", configWith({ memory_inference: true }), async () => "real", () => {
-            fallbackInvocations += 1;
-            return "thunk-fallback";
-        });
-        expect(result).toBe("real");
-        expect(fallbackInvocations).toBe(0);
-    });
-    test("returns the fallback on a synchronous throw", async () => {
-        const events = [];
-        const result = await tryLlmFeature("curate_rerank", configWith({ curate_rerank: true }), () => {
-            throw new Error("boom");
-        }, "fallback", { onFallback: (e) => events.push({ reason: e.reason, error: e.error }) });
-        expect(result).toBe("fallback");
-        expect(events).toHaveLength(1);
-        expect(events[0].reason).toBe("error");
-        expect(events[0].error?.message).toBe("boom");
-    });
-    test("returns the fallback on an async rejection", async () => {
-        const result = await tryLlmFeature("graph_extraction", configWith({ graph_extraction: true }), async () => {
-            throw new Error("kaboom");
-        }, 42);
-        expect(result).toBe(42);
-    });
-    test("returns the fallback on hard timeout", async () => {
-        const events = [];
-        const result = await tryLlmFeature("memory_inference", configWith({ memory_inference: true }), () => new Promise((resolve) => setTimeout(() => resolve("late"), 200)), "fallback", { timeoutMs: 25, onFallback: (e) => events.push({ reason: e.reason, error: e.error }) });
-        expect(result).toBe("fallback");
-        expect(events).toHaveLength(1);
-        expect(events[0].reason).toBe("timeout");
-        expect(events[0].error).toBeInstanceOf(LlmFeatureTimeoutError);
-    });
-    test("returns fn's result when enabled and successful", async () => {
-        const result = await tryLlmFeature("feedback_distillation", configWith({ feedback_distillation: true }), async () => ({ ok: true }), { ok: false });
-        expect(result).toEqual({ ok: true });
-    });
-});
-// ── #284 GAP-LOW: parametrise over the stable feature keys ─────────────────
-//
-// Wave B may drop `tag_dedup` / `memory_consolidation` / `embedding_fallback_score`
-// — we restrict this parametrised sweep to the 4 keys that are
-// definitely actually-implemented and used by the current code.
-const STABLE_FEATURE_KEYS = ["feedback_distillation", "memory_inference", "graph_extraction", "curate_rerank"];
-describe("isLlmFeatureEnabled — parametrised over stable feature keys (#284)", () => {
-    for (const key of STABLE_FEATURE_KEYS) {
-        test(`${key}: default-false when features block is missing`, () => {
-            const cfg = { stashDir: "/tmp", llm: baseLlm };
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            expect(isLlmFeatureEnabled(cfg, key)).toBe(false);
-        });
-        test(`${key}: false when key is absent (default-false)`, () => {
-            const cfg = configWith({});
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            expect(isLlmFeatureEnabled(cfg, key)).toBe(false);
-        });
-        test(`${key}: literal true → enabled`, () => {
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            expect(isLlmFeatureEnabled(configWith({ [key]: true }), key)).toBe(true);
-        });
-        test(`${key}: literal false → disabled`, () => {
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            expect(isLlmFeatureEnabled(configWith({ [key]: false }), key)).toBe(false);
-        });
-    }
-});
-describe("tryLlmFeature — parametrised over stable feature keys (#284)", () => {
-    for (const key of STABLE_FEATURE_KEYS) {
-        test(`${key}: disabled → returns fallback, never calls fn`, async () => {
-            let called = false;
-            const result = await tryLlmFeature(
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            key, configWith({}), async () => {
-                called = true;
-                return "real";
-            }, "fallback");
-            expect(result).toBe("fallback");
-            expect(called).toBe(false);
-        });
-        test(`${key}: enabled + happy → returns fn's result`, async () => {
-            const result = await tryLlmFeature(
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            key, configWith({ [key]: true }), async () => "real", "fallback");
-            expect(result).toBe("real");
-        });
-        test(`${key}: enabled + throw → returns fallback`, async () => {
-            const result = await tryLlmFeature(
-            // biome-ignore lint/suspicious/noExplicitAny: gate accepts any LlmFeatureKey
-            key, configWith({ [key]: true }), async () => {
-                throw new Error("boom");
-            }, "fallback");
-            expect(result).toBe("fallback");
-        });
-    }
-});

package/dist/tests/llm.test.js

@@ -1,139 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { enhanceMetadata } from "../src/llm/metadata-enhance";
-// These tests verify the LLM module's response parsing logic.
-// They use a mock server to simulate an OpenAI-compatible endpoint.
-function createMockServer(responseBody, statusCode = 200, onRequest) {
-    const server = Bun.serve({
-        port: 0,
-        async fetch(request) {
-            const body = (await request.json());
-            onRequest?.(body);
-            return new Response(JSON.stringify({
-                choices: [{ message: { content: responseBody } }],
-            }), {
-                status: statusCode,
-                headers: { "Content-Type": "application/json" },
-            });
-        },
-    });
-    return { url: `http://localhost:${server.port}`, server };
-}
-function createErrorServer(statusCode, body = "error") {
-    const server = Bun.serve({
-        port: 0,
-        fetch() {
-            return new Response(body, { status: statusCode });
-        },
-    });
-    return { url: `http://localhost:${server.port}`, server };
-}
-describe("enhanceMetadata", () => {
-    test("parses valid LLM JSON response", async () => {
-        const { url, server } = createMockServer(JSON.stringify({
-            description: "Builds Docker images from Dockerfiles",
-            searchHints: ["build a docker image", "create container image", "package application"],
-            tags: ["docker", "container", "build", "image"],
-        }));
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            const entry = { name: "build-image", type: "script", description: "build image" };
-            const result = await enhanceMetadata(config, entry);
-            expect(result.description).toBe("Builds Docker images from Dockerfiles");
-            expect(result.searchHints).toHaveLength(3);
-            expect(result.tags).toContain("docker");
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("handles markdown-fenced JSON response", async () => {
-        const { url, server } = createMockServer('```json\n{"description":"test desc","searchHints":["do thing"],"tags":["tag1"]}\n```');
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            const entry = { name: "test", type: "script" };
-            const result = await enhanceMetadata(config, entry);
-            expect(result.description).toBe("test desc");
-            expect(result.searchHints).toEqual(["do thing"]);
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("returns empty object on unparseable response", async () => {
-        const { url, server } = createMockServer("This is not JSON at all");
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            const entry = { name: "test", type: "script" };
-            const result = await enhanceMetadata(config, entry);
-            expect(result).toEqual({});
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("throws on HTTP error", async () => {
-        const { url, server } = createErrorServer(500, "Internal Server Error");
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            const entry = { name: "test", type: "script" };
-            await expect(enhanceMetadata(config, entry)).rejects.toThrow("LLM request failed (500)");
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("uses configured temperature and maxTokens", async () => {
-        let requestBody;
-        const { url, server } = createMockServer(JSON.stringify({ description: "ok" }), 200, (body) => {
-            requestBody = body;
-        });
-        try {
-            const config = {
-                endpoint: url,
-                model: "test-model",
-                temperature: 0.7,
-                maxTokens: 256,
-            };
-            const entry = { name: "test", type: "script" };
-            await enhanceMetadata(config, entry);
-            expect(requestBody).toMatchObject({
-                model: "test-model",
-                temperature: 0.7,
-                max_tokens: 256,
-            });
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("caps searchHints at 8 items", async () => {
-        const { url, server } = createMockServer(JSON.stringify({
-            searchHints: ["a", "b", "c", "d", "e", "f", "g", "h", "i", "j"],
-        }));
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            const entry = { name: "test", type: "script" };
-            const result = await enhanceMetadata(config, entry);
-            expect(result.searchHints?.length).toBeLessThanOrEqual(8);
-        }
-        finally {
-            server.stop();
-        }
-    });
-    test("filters non-string values from searchHints and tags", async () => {
-        const { url, server } = createMockServer(JSON.stringify({
-            searchHints: ["valid", 123, null, "also valid"],
-            tags: ["good", false, "fine"],
-        }));
-        try {
-            const config = { endpoint: url, model: "test-model" };
-            const entry = { name: "test", type: "script" };
-            const result = await enhanceMetadata(config, entry);
-            expect(result.searchHints).toEqual(["valid", "also valid"]);
-            expect(result.tags).toEqual(["good", "fine"]);
-        }
-        finally {
-            server.stop();
-        }
-    });
-});

package/dist/tests/lockfile.test.js

@@ -1,216 +0,0 @@
-import { afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { readLockfile, removeLockEntry, upsertLockEntry, writeLockfile, } from "../src/integrations/lockfile";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
-let testConfigDir = "";
-function makeTmpDir() {
-    return fs.mkdtempSync(path.join(os.tmpdir(), "akm-lockfile-test-"));
-}
-function getLockfilePath() {
-    return path.join(testConfigDir, "akm", "akm.lock");
-}
-function writeRawLockfile(content) {
-    const lockPath = getLockfilePath();
-    fs.mkdirSync(path.dirname(lockPath), { recursive: true });
-    fs.writeFileSync(lockPath, content, "utf8");
-}
-function validEntry(overrides) {
-    return {
-        id: "test-entry",
-        source: "npm",
-        ref: "@scope/pkg",
-        ...overrides,
-    };
-}
-beforeEach(() => {
-    testConfigDir = makeTmpDir();
-    process.env.XDG_CONFIG_HOME = testConfigDir;
-});
-afterEach(() => {
-    if (originalXdgConfigHome === undefined) {
-        delete process.env.XDG_CONFIG_HOME;
-    }
-    else {
-        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
-    }
-    if (testConfigDir) {
-        fs.rmSync(testConfigDir, { recursive: true, force: true });
-        testConfigDir = "";
-    }
-});
-// ── readLockfile ────────────────────────────────────────────────────────────
-describe("readLockfile", () => {
-    test("returns empty array when lockfile does not exist", () => {
-        expect(readLockfile()).toEqual([]);
-    });
-    test("returns empty array for corrupted JSON", () => {
-        writeRawLockfile("not valid json {{{");
-        expect(readLockfile()).toEqual([]);
-    });
-    test("returns empty array for non-array JSON", () => {
-        writeRawLockfile('{"key": "value"}');
-        expect(readLockfile()).toEqual([]);
-    });
-    test("returns empty array for JSON string value", () => {
-        writeRawLockfile('"just a string"');
-        expect(readLockfile()).toEqual([]);
-    });
-    test("reads valid entries", () => {
-        const entries = [validEntry()];
-        writeRawLockfile(JSON.stringify(entries));
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe("test-entry");
-        expect(result[0].source).toBe("npm");
-        expect(result[0].ref).toBe("@scope/pkg");
-    });
-    test("filters out invalid entries from the array", () => {
-        const raw = [
-            validEntry(),
-            { id: "", source: "npm", ref: "pkg" }, // empty id
-            { id: "x", source: "invalid-source", ref: "y" }, // bad source
-            { id: "y", source: "github", ref: "" }, // empty ref
-            null,
-            42,
-            "string",
-            { source: "npm", ref: "no-id" }, // missing id
-        ];
-        writeRawLockfile(JSON.stringify(raw));
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe("test-entry");
-    });
-    test("preserves optional fields on valid entries", () => {
-        const entry = validEntry({
-            resolvedVersion: "1.2.3",
-            resolvedRevision: "abc123",
-            integrity: "sha512-xyz",
-        });
-        writeRawLockfile(JSON.stringify([entry]));
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].resolvedVersion).toBe("1.2.3");
-        expect(result[0].resolvedRevision).toBe("abc123");
-        expect(result[0].integrity).toBe("sha512-xyz");
-    });
-    test("accepts all valid source types", () => {
-        const entries = [
-            validEntry({ id: "a", source: "npm" }),
-            validEntry({ id: "b", source: "github" }),
-            validEntry({ id: "c", source: "git" }),
-            validEntry({ id: "d", source: "local" }),
-        ];
-        writeRawLockfile(JSON.stringify(entries));
-        const result = readLockfile();
-        expect(result).toHaveLength(4);
-    });
-});
-// ── writeLockfile ───────────────────────────────────────────────────────────
-describe("writeLockfile", () => {
-    test("writes formatted JSON with trailing newline", () => {
-        const entries = [validEntry()];
-        writeLockfile(entries);
-        const raw = fs.readFileSync(getLockfilePath(), "utf8");
-        expect(raw.endsWith("\n")).toBe(true);
-        expect(JSON.parse(raw)).toEqual(entries);
-        expect(raw).toContain("  "); // pretty-printed
-    });
-    test("creates directory structure if not present", () => {
-        const entries = [validEntry()];
-        writeLockfile(entries);
-        expect(fs.existsSync(getLockfilePath())).toBe(true);
-    });
-    test("overwrites existing lockfile atomically", () => {
-        writeLockfile([validEntry({ id: "first" })]);
-        writeLockfile([validEntry({ id: "second" })]);
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe("second");
-    });
-    test("does not leave temp file on success", () => {
-        writeLockfile([validEntry()]);
-        const dir = path.dirname(getLockfilePath());
-        const files = fs.readdirSync(dir);
-        const tmpFiles = files.filter((f) => f.includes(".tmp."));
-        expect(tmpFiles).toHaveLength(0);
-    });
-    test("writes empty array", () => {
-        writeLockfile([]);
-        const raw = fs.readFileSync(getLockfilePath(), "utf8");
-        expect(JSON.parse(raw)).toEqual([]);
-    });
-    test("roundtrips with readLockfile", () => {
-        const entries = [
-            validEntry({ id: "a", source: "github", ref: "owner/repo" }),
-            validEntry({ id: "b", source: "npm", ref: "@scope/pkg" }),
-        ];
-        writeLockfile(entries);
-        expect(readLockfile()).toEqual(entries);
-    });
-});
-// ── upsertLockEntry ─────────────────────────────────────────────────────────
-describe("upsertLockEntry", () => {
-    test("adds entry when lockfile is empty", async () => {
-        await upsertLockEntry(validEntry({ id: "new-entry" }));
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe("new-entry");
-    });
-    test("adds entry when lockfile does not exist", async () => {
-        await upsertLockEntry(validEntry({ id: "first" }));
-        expect(readLockfile()).toHaveLength(1);
-    });
-    test("replaces entry with same id", async () => {
-        writeLockfile([validEntry({ id: "pkg", ref: "old-ref" })]);
-        await upsertLockEntry(validEntry({ id: "pkg", ref: "new-ref" }));
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].ref).toBe("new-ref");
-    });
-    test("preserves other entries when upserting", async () => {
-        writeLockfile([validEntry({ id: "keep-me", ref: "keep" }), validEntry({ id: "update-me", ref: "old" })]);
-        await upsertLockEntry(validEntry({ id: "update-me", ref: "new" }));
-        const result = readLockfile();
-        expect(result).toHaveLength(2);
-        const kept = result.find((e) => e.id === "keep-me");
-        const updated = result.find((e) => e.id === "update-me");
-        expect(kept?.ref).toBe("keep");
-        expect(updated?.ref).toBe("new");
-    });
-    test("appends new entry when id does not exist", async () => {
-        writeLockfile([validEntry({ id: "existing" })]);
-        await upsertLockEntry(validEntry({ id: "brand-new" }));
-        const result = readLockfile();
-        expect(result).toHaveLength(2);
-    });
-});
-// ── removeLockEntry ─────────────────────────────────────────────────────────
-describe("removeLockEntry", () => {
-    test("removes entry by id", async () => {
-        writeLockfile([validEntry({ id: "remove-me" }), validEntry({ id: "keep-me" })]);
-        await removeLockEntry("remove-me");
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe("keep-me");
-    });
-    test("no-op when id does not exist", async () => {
-        writeLockfile([validEntry({ id: "existing" })]);
-        await removeLockEntry("nonexistent");
-        const result = readLockfile();
-        expect(result).toHaveLength(1);
-        expect(result[0].id).toBe("existing");
-    });
-    test("works when lockfile does not exist", async () => {
-        // Should not throw
-        await removeLockEntry("anything");
-        expect(readLockfile()).toEqual([]);
-    });
-    test("removes all entries if all match", async () => {
-        writeLockfile([validEntry({ id: "only-one" })]);
-        await removeLockEntry("only-one");
-        expect(readLockfile()).toEqual([]);
-    });
-});