akm-cli 0.7.0-rc1 → 0.7.1

package/dist/tests/registry-build-index.test.js

@@ -1,378 +0,0 @@
-import { afterAll, afterEach, describe, expect, test } from "bun:test";
-import { spawn, spawnSync } from "node:child_process";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { buildRegistryIndex } from "../src/registry/build-index";
-const CLI = path.join(import.meta.dir, "..", "src", "cli.ts");
-const tempDirs = [];
-const servers = [];
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function writeFile(filePath, content) {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content, "utf8");
-}
-function createTarball(sourceDir, archivePath) {
-    const result = spawnSync("tar", ["czf", archivePath, "-C", path.dirname(sourceDir), path.basename(sourceDir)], {
-        encoding: "utf8",
-        timeout: 30_000,
-    });
-    expect(result.status).toBe(0);
-}
-function createRegistryServer(npmArchivePath, githubArchivePath) {
-    const server = Bun.serve({
-        port: 0,
-        async fetch(request) {
-            const url = new URL(request.url);
-            const pathname = url.pathname;
-            if (pathname === "/-/v1/search") {
-                return Response.json({
-                    objects: [
-                        {
-                            package: {
-                                name: "agent-stash",
-                                version: "1.2.3",
-                                description: "npm description",
-                                keywords: ["akm-stash", "deploy"],
-                                links: {
-                                    homepage: "https://example.test/agent-stash",
-                                    repository: "https://github.com/acme/agent-stash",
-                                },
-                                author: { name: "acme" },
-                            },
-                        },
-                    ],
-                });
-            }
-            if (pathname === "/agent-stash/latest") {
-                return Response.json({
-                    version: "1.2.3",
-                    description: "npm latest description",
-                    keywords: ["akm-stash", "deploy", "review"],
-                    license: "MIT",
-                    dist: {
-                        tarball: `${url.origin}/archives/npm-agent-stash.tgz`,
-                    },
-                });
-            }
-            if (pathname === "/search/repositories") {
-                return Response.json({
-                    items: [
-                        {
-                            full_name: "acme/release-stash",
-                            name: "release-stash",
-                            description: "github description",
-                            html_url: "https://github.com/acme/release-stash",
-                            owner: { login: "acme" },
-                            license: { spdx_id: "Apache-2.0" },
-                            topics: ["akm-stash", "release"],
-                            default_branch: "main",
-                        },
-                    ],
-                });
-            }
-            if (pathname === "/repos/acme/release-stash/tarball/main") {
-                return new Response(Bun.file(githubArchivePath), {
-                    headers: { "Content-Type": "application/gzip" },
-                });
-            }
-            if (pathname === "/archives/npm-agent-stash.tgz") {
-                return new Response(Bun.file(npmArchivePath), {
-                    headers: { "Content-Type": "application/gzip" },
-                });
-            }
-            return new Response("not found", { status: 404 });
-        },
-    });
-    servers.push(server);
-    return `http://127.0.0.1:${server.port}`;
-}
-afterEach(() => {
-    while (servers.length > 0) {
-        servers.pop()?.stop(true);
-    }
-    while (tempDirs.length > 0) {
-        fs.rmSync(tempDirs.pop() ?? "", { recursive: true, force: true });
-    }
-});
-afterAll(() => {
-    while (servers.length > 0) {
-        servers.pop()?.stop(true);
-    }
-});
-describe("buildRegistryIndex", () => {
-    test("builds a v2 index from discovery and manual entries", async () => {
-        const fixtureRoot = makeTempDir("akm-registry-build-fixture-");
-        const npmPackageDir = path.join(fixtureRoot, "package");
-        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({
-            name: "agent-stash",
-            version: "1.2.3",
-            description: "package archive description",
-            keywords: ["akm-stash", "deploy", "review"],
-            license: "MIT",
-        }));
-        writeFile(path.join(npmPackageDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\n");
-        writeFile(path.join(npmPackageDir, "skills", "review", "SKILL.md"), "---\ndescription: Review code\n---\n");
-        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
-        createTarball(npmPackageDir, npmArchivePath);
-        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
-        writeFile(path.join(githubRepoDir, "package.json"), JSON.stringify({
-            name: "release-stash",
-            version: "0.4.0",
-            description: "repo archive description",
-            keywords: ["akm-stash", "release", "automation"],
-        }));
-        writeFile(path.join(githubRepoDir, "agents", "planner.md"), "---\ndescription: Plan releases\n---\n");
-        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
-        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
-        createTarball(githubRepoDir, githubArchivePath);
-        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
-        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
-        fs.writeFileSync(manualEntriesPath, `${JSON.stringify([
-            {
-                id: "npm:agent-stash",
-                name: "Agent Stash",
-                description: "manual description",
-                ref: "agent-stash",
-                source: "npm",
-                tags: ["curated"],
-                assets: [{ type: "knowledge", name: "guide", description: "Manual guide" }],
-                curated: true,
-            },
-            {
-                id: "github:manual/only",
-                name: "Manual Only",
-                description: "manual only entry",
-                ref: "manual/only",
-                source: "github",
-                assetTypes: ["skill"],
-                curated: true,
-            },
-        ], null, 2)}\n`, "utf8");
-        const result = await buildRegistryIndex({
-            manualEntriesPath,
-            npmRegistryBase: serverBase,
-            githubApiBase: serverBase,
-        });
-        expect(result.index.version).toBe(3);
-        expect(result.counts).toEqual({ manual: 2, npm: 1, github: 1, total: 3 });
-        const npmStash = result.index.stashes.find((stash) => stash.id === "npm:agent-stash");
-        expect(npmStash).toBeDefined();
-        expect(npmStash?.description).toBe("manual description");
-        // v1 spec §4.2: the legacy `curated` boolean is removed. The builder must
-        // not surface it on emitted stash entries even when input contained it.
-        expect(npmStash).not.toHaveProperty("curated");
-        expect(npmStash?.assetTypes).toEqual(["knowledge", "script", "skill"]);
-        expect(npmStash?.tags).toEqual(["curated", "deploy", "review"]);
-        expect(npmStash?.assets?.map((asset) => `${asset.type}:${asset.name}`)).toEqual([
-            "knowledge:guide",
-            "script:deploy.sh",
-            "skill:review",
-        ]);
-        const githubStash = result.index.stashes.find((stash) => stash.id === "github:acme/release-stash");
-        expect(githubStash).toBeDefined();
-        expect(githubStash?.assetTypes).toEqual(["agent", "command"]);
-        expect(githubStash?.assets?.map((asset) => `${asset.type}:${asset.name}`)).toEqual([
-            "agent:planner",
-            "command:release",
-        ]);
-        expect(githubStash?.assets?.every((asset) => typeof asset.estimatedTokens === "number")).toBe(true);
-        expect(githubStash?.latestVersion).toBe("0.4.0");
-        expect(githubStash?.tags).toEqual(["automation", "release"]);
-        const manualOnlyStash = result.index.stashes.find((stash) => stash.id === "github:manual/only");
-        expect(manualOnlyStash).toBeDefined();
-        // v1 spec §4.2: legacy `curated` from manual entries is silently ignored.
-        expect(manualOnlyStash).not.toHaveProperty("curated");
-        expect(manualOnlyStash?.assetTypes).toEqual(["skill"]);
-    });
-    test("legacy curated key parses without error", async () => {
-        // v1 spec §4.2: `curated: true` is a removed legacy field on registry
-        // entries. Manual-entry JSON in the wild may still contain it. The
-        // builder MUST silently ignore it (not throw, not fail validation),
-        // and the entry MUST still be processed end-to-end.
-        const fixtureRoot = makeTempDir("akm-registry-build-legacy-curated-");
-        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
-        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
-        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
-        createTarball(githubRepoDir, githubArchivePath);
-        const npmPackageDir = path.join(fixtureRoot, "package");
-        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({ name: "agent-stash", version: "1.2.3" }));
-        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
-        createTarball(npmPackageDir, npmArchivePath);
-        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
-        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
-        fs.writeFileSync(manualEntriesPath, `${JSON.stringify([
-            {
-                id: "github:legacy/curated",
-                name: "Legacy Curated",
-                description: "entry retaining the removed `curated: true` field",
-                ref: "legacy/curated",
-                source: "github",
-                assetTypes: ["skill"],
-                curated: true,
-            },
-        ], null, 2)}\n`, "utf8");
-        await expect(buildRegistryIndex({
-            manualEntriesPath,
-            npmRegistryBase: serverBase,
-            githubApiBase: serverBase,
-        })).resolves.toBeDefined();
-        // Re-run to inspect the actual result; resolves above proves no throw.
-        const result = await buildRegistryIndex({
-            manualEntriesPath,
-            npmRegistryBase: serverBase,
-            githubApiBase: serverBase,
-        });
-        // Non-empty kit list proves the legacy entry was processed, not silently
-        // dropped on parse error.
-        expect(result.index.stashes.length).toBeGreaterThan(0);
-        const legacyStash = result.index.stashes.find((stash) => stash.id === "github:legacy/curated");
-        expect(legacyStash).toBeDefined();
-        expect(legacyStash).not.toHaveProperty("curated");
-    });
-    test("respects .stash.json metadata and akm.include when enriching assets", async () => {
-        const fixtureRoot = makeTempDir("akm-registry-build-include-");
-        const npmPackageDir = path.join(fixtureRoot, "package");
-        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({
-            name: "agent-stash",
-            version: "1.2.3",
-            akm: { include: ["skills", "docs"] },
-        }));
-        writeFile(path.join(npmPackageDir, "scripts", "ignored.sh"), "#!/usr/bin/env bash\n");
-        writeFile(path.join(npmPackageDir, "skills", "review", "SKILL.md"), "# Review\n");
-        writeFile(path.join(npmPackageDir, "skills", "review", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "review",
-                    type: "skill",
-                    filename: "SKILL.md",
-                    description: "Curated review workflow",
-                    tags: ["quality", "code-review"],
-                },
-            ],
-        }));
-        writeFile(path.join(npmPackageDir, "docs", "guide.md"), "# Guide\n");
-        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
-        createTarball(npmPackageDir, npmArchivePath);
-        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
-        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
-        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
-        createTarball(githubRepoDir, githubArchivePath);
-        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
-        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
-        fs.writeFileSync(manualEntriesPath, "[]\n", "utf8");
-        const result = await buildRegistryIndex({
-            manualEntriesPath,
-            npmRegistryBase: serverBase,
-            githubApiBase: serverBase,
-        });
-        const npmStash = result.index.stashes.find((stash) => stash.id === "npm:agent-stash");
-        expect(npmStash?.assetTypes).toEqual(["knowledge", "skill"]);
-        expect(npmStash?.assets?.map((asset) => `${asset.type}:${asset.name}`)).toEqual([
-            "knowledge:docs/guide",
-            "skill:review",
-        ]);
-        const reviewAsset = npmStash?.assets?.find((asset) => asset.type === "skill" && asset.name === "review");
-        expect(reviewAsset?.description).toBe("Curated review workflow");
-        expect(reviewAsset?.tags).toEqual(["quality", "code-review"]);
-        expect(reviewAsset?.estimatedTokens).toBeGreaterThan(0);
-        expect(npmStash?.assets?.some((asset) => asset.name === "ignored.sh")).toBe(false);
-    });
-});
-function waitForChild(child, timeoutMs) {
-    return new Promise((resolve, reject) => {
-        let stdout = "";
-        let stderr = "";
-        let settled = false;
-        child.stdout?.on("data", (chunk) => {
-            stdout += String(chunk);
-        });
-        child.stderr?.on("data", (chunk) => {
-            stderr += String(chunk);
-        });
-        const timer = setTimeout(() => {
-            if (!settled) {
-                settled = true;
-                child.kill("SIGKILL");
-                reject(new Error(`Child process timed out after ${timeoutMs}ms\nstdout: ${stdout}\nstderr: ${stderr}`));
-            }
-        }, timeoutMs);
-        child.on("error", (err) => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timer);
-                reject(err);
-            }
-        });
-        child.on("close", (code) => {
-            if (!settled) {
-                settled = true;
-                clearTimeout(timer);
-                resolve({ code: code ?? 1, stdout, stderr });
-            }
-        });
-    });
-}
-describe("akm registry build-index", () => {
-    test("writes the generated index to disk", async () => {
-        const fixtureRoot = makeTempDir("akm-registry-build-cli-");
-        const npmPackageDir = path.join(fixtureRoot, "package");
-        writeFile(path.join(npmPackageDir, "package.json"), JSON.stringify({ name: "agent-stash", version: "1.2.3" }));
-        writeFile(path.join(npmPackageDir, "scripts", "deploy.sh"), "#!/usr/bin/env bash\n");
-        const npmArchivePath = path.join(fixtureRoot, "npm-agent-stash.tgz");
-        createTarball(npmPackageDir, npmArchivePath);
-        const githubRepoDir = path.join(fixtureRoot, "release-stash-main");
-        writeFile(path.join(githubRepoDir, "commands", "release.md"), "Use $ARGUMENTS\n");
-        const githubArchivePath = path.join(fixtureRoot, "github-release-stash.tgz");
-        createTarball(githubRepoDir, githubArchivePath);
-        const serverBase = createRegistryServer(npmArchivePath, githubArchivePath);
-        const manualEntriesPath = path.join(fixtureRoot, "manual-entries.json");
-        fs.writeFileSync(manualEntriesPath, "[]\n", "utf8");
-        const outPath = path.join(fixtureRoot, "out", "index.json");
-        const xdgCache = makeTempDir("akm-registry-build-cache-");
-        const xdgConfig = makeTempDir("akm-registry-build-config-");
-        const homeDir = makeTempDir("akm-registry-build-home-");
-        const child = spawn("bun", [
-            CLI,
-            "registry",
-            "build-index",
-            "--format=json",
-            "--out",
-            outPath,
-            "--manual",
-            manualEntriesPath,
-            "--npmRegistry",
-            serverBase,
-            "--githubApi",
-            serverBase,
-        ], {
-            cwd: path.join(import.meta.dir, ".."),
-            stdio: ["ignore", "pipe", "pipe"],
-            env: {
-                ...process.env,
-                HOME: homeDir,
-                NO_PROXY: "127.0.0.1,localhost",
-                GITHUB_TOKEN: "",
-                XDG_CACHE_HOME: xdgCache,
-                XDG_CONFIG_HOME: xdgConfig,
-            },
-        });
-        const result = await waitForChild(child, 30_000);
-        if (result.code !== 0) {
-            console.error("stderr:", result.stderr);
-            console.error("stdout:", result.stdout);
-        }
-        expect(result.code).toBe(0);
-        expect(result.stderr.trim()).toBe("");
-        const stdout = JSON.parse(result.stdout.trim());
-        expect(stdout.outPath).toBe(outPath);
-        expect(stdout.totalKits).toBe(2);
-        const written = JSON.parse(fs.readFileSync(outPath, "utf8"));
-        expect(written.version).toBe(3);
-        expect(written.stashes.map((stash) => stash.id)).toEqual(["npm:agent-stash", "github:acme/release-stash"]);
-    }, { timeout: 60_000 });
-});

package/dist/tests/registry-cli.test.js

@@ -1,290 +0,0 @@
-import { afterAll, afterEach, beforeEach, describe, expect, test } from "bun:test";
-import fs from "node:fs";
-import os from "node:os";
-import path from "node:path";
-import { resolveRegistries, searchRegistry } from "../src/commands/registry-search";
-import { getConfigPath, loadConfig, saveConfig } from "../src/core/config";
-// ── Helpers ─────────────────────────────────────────────────────────────────
-const createdTmpDirs = [];
-function createTmpDir(prefix = "akm-reg-cli-") {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    createdTmpDirs.push(dir);
-    return dir;
-}
-function writeConfig(configPath, config) {
-    fs.mkdirSync(path.dirname(configPath), { recursive: true });
-    fs.writeFileSync(configPath, `${JSON.stringify(config, null, 2)}\n`);
-}
-function serveIndex(index) {
-    const body = JSON.stringify(index);
-    const server = Bun.serve({
-        port: 0,
-        fetch() {
-            return new Response(body, {
-                headers: { "Content-Type": "application/json" },
-            });
-        },
-    });
-    return {
-        url: `http://localhost:${server.port}/index.json`,
-        close: () => server.stop(true),
-    };
-}
-afterAll(() => {
-    for (const dir of createdTmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
-const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-const originalRegistryUrl = process.env.AKM_REGISTRY_URL;
-beforeEach(() => {
-    process.env.XDG_CONFIG_HOME = createTmpDir("akm-reg-config-");
-    process.env.XDG_CACHE_HOME = createTmpDir("akm-reg-cache-");
-    delete process.env.AKM_REGISTRY_URL;
-});
-afterEach(() => {
-    if (originalXdgConfigHome === undefined) {
-        delete process.env.XDG_CONFIG_HOME;
-    }
-    else {
-        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
-    }
-    if (originalXdgCacheHome === undefined) {
-        delete process.env.XDG_CACHE_HOME;
-    }
-    else {
-        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-    if (originalRegistryUrl === undefined) {
-        delete process.env.AKM_REGISTRY_URL;
-    }
-    else {
-        process.env.AKM_REGISTRY_URL = originalRegistryUrl;
-    }
-});
-// ── Registry add/remove/list ─────────────────────────────────────────────────
-describe("registry add/remove/list via config", () => {
-    test("list returns default registries when none configured", () => {
-        const config = loadConfig();
-        const registries = config.registries ?? [];
-        expect(registries.length).toBe(2);
-        expect(registries[0].name).toBe("official");
-        expect(registries[0].url).toContain("akm-registry");
-        expect(registries[1].name).toBe("skills.sh");
-        expect(registries[1].provider).toBe("skills-sh");
-    });
-    test("add appends a registry entry", () => {
-        const config = loadConfig();
-        const registries = [...(config.registries ?? [])];
-        const newEntry = { url: "https://example.com/index.json", name: "custom" };
-        registries.push(newEntry);
-        saveConfig({ ...config, registries });
-        const updated = loadConfig();
-        expect(updated.registries?.length).toBe(3);
-        expect(updated.registries?.[2].url).toBe("https://example.com/index.json");
-        expect(updated.registries?.[2].name).toBe("custom");
-    });
-    test("add deduplicates by URL", () => {
-        // Start with a known registry entry
-        const url = "https://example.com/dedup-test.json";
-        const config = loadConfig();
-        const registries = [...(config.registries ?? [])];
-        registries.push({ url, name: "dedup-target" });
-        saveConfig({ ...config, registries });
-        // Verify it was added
-        const afterFirst = loadConfig();
-        const countAfterFirst = afterFirst.registries?.length ?? 0;
-        // Try to add the same URL again using the CLI's dedup logic
-        const current = loadConfig();
-        const currentRegistries = [...(current.registries ?? [])];
-        if (!currentRegistries.some((r) => r.url === url)) {
-            currentRegistries.push({ url, name: "dedup-target" });
-        }
-        saveConfig({ ...current, registries: currentRegistries });
-        // Verify length is unchanged — the duplicate was rejected
-        const afterSecond = loadConfig();
-        expect(afterSecond.registries?.length).toBe(countAfterFirst);
-    });
-    test("remove by URL", () => {
-        const config = loadConfig();
-        const registries = [
-            { url: "https://example.com/a.json", name: "a" },
-            { url: "https://example.com/b.json", name: "b" },
-        ];
-        saveConfig({ ...config, registries });
-        const current = loadConfig();
-        const remaining = (current.registries ?? []).filter((r) => r.url !== "https://example.com/a.json");
-        saveConfig({ ...current, registries: remaining });
-        const final = loadConfig();
-        expect(final.registries?.length).toBe(1);
-        expect(final.registries?.[0].name).toBe("b");
-    });
-    test("remove by name", () => {
-        const config = loadConfig();
-        const registries = [
-            { url: "https://example.com/a.json", name: "alpha" },
-            { url: "https://example.com/b.json", name: "beta" },
-        ];
-        saveConfig({ ...config, registries });
-        const current = loadConfig();
-        const remaining = (current.registries ?? []).filter((r) => r.name !== "alpha");
-        saveConfig({ ...current, registries: remaining });
-        const final = loadConfig();
-        expect(final.registries?.length).toBe(1);
-        expect(final.registries?.[0].name).toBe("beta");
-    });
-});
-// ── resolveRegistries ───────────────────────────────────────────────────────
-describe("resolveRegistries", () => {
-    test("filters out disabled registries", () => {
-        const entries = [
-            { url: "https://a.com/index.json", name: "a", enabled: true },
-            { url: "https://b.com/index.json", name: "b", enabled: false },
-            { url: "https://c.com/index.json", name: "c" },
-        ];
-        const resolved = resolveRegistries(entries);
-        expect(resolved.length).toBe(2);
-        expect(resolved.map((r) => r.name)).toEqual(["a", "c"]);
-    });
-    test("AKM_REGISTRY_URL env var overrides config", () => {
-        process.env.AKM_REGISTRY_URL = "https://override.com/index.json";
-        const resolved = resolveRegistries([{ url: "https://config.com/index.json" }]);
-        expect(resolved.length).toBe(1);
-        expect(resolved[0].url).toBe("https://override.com/index.json");
-    });
-    test("returns empty array when passed empty array", () => {
-        const resolved = resolveRegistries([]);
-        // Empty array passed explicitly — returns empty, no fallback
-        expect(resolved).toEqual([]);
-    });
-    test("returns default from config when no override", () => {
-        const resolved = resolveRegistries(undefined);
-        // Will read from loadConfig which returns DEFAULT_CONFIG registries
-        expect(resolved.length).toBeGreaterThan(0);
-        expect(resolved[0].name).toBe("official");
-    });
-});
-// ── Registry search with RegistryConfigEntry ────────────────────────────────
-describe("registry search with config entries", () => {
-    test("basic query against mock index", async () => {
-        const index = {
-            version: 3,
-            updatedAt: "2026-01-01T00:00:00Z",
-            stashes: [
-                {
-                    id: "npm:test-stash",
-                    name: "Test Stash",
-                    description: "A test stash for deploy",
-                    ref: "test-stash",
-                    source: "npm",
-                    tags: ["deploy"],
-                },
-            ],
-        };
-        const srv = serveIndex(index);
-        try {
-            const result = await searchRegistry("deploy", {
-                registries: [{ url: srv.url, name: "test-reg" }],
-            });
-            expect(result.hits.length).toBe(1);
-            expect(result.hits[0].id).toBe("npm:test-stash");
-            expect(result.hits[0].registryName).toBe("test-reg");
-        }
-        finally {
-            srv.close();
-        }
-    });
-    test("multi-registry search merges results from multiple URLs", async () => {
-        const index1 = {
-            version: 3,
-            updatedAt: "2026-01-01T00:00:00Z",
-            stashes: [
-                {
-                    id: "npm:stash-one",
-                    name: "Stash One",
-                    description: "First stash for build",
-                    ref: "stash-one",
-                    source: "npm",
-                    tags: ["build"],
-                },
-            ],
-        };
-        const index2 = {
-            version: 3,
-            updatedAt: "2026-01-01T00:00:00Z",
-            stashes: [
-                {
-                    id: "github:org/stash-two",
-                    name: "Stash Two",
-                    description: "Second stash for build automation",
-                    ref: "org/stash-two",
-                    source: "github",
-                    tags: ["build"],
-                },
-            ],
-        };
-        const srv1 = serveIndex(index1);
-        const srv2 = serveIndex(index2);
-        try {
-            const result = await searchRegistry("build", {
-                registries: [
-                    { url: srv1.url, name: "primary" },
-                    { url: srv2.url, name: "secondary" },
-                ],
-            });
-            expect(result.hits.length).toBe(2);
-            const ids = result.hits.map((h) => h.id);
-            expect(ids).toContain("npm:stash-one");
-            expect(ids).toContain("github:org/stash-two");
-            // Verify provenance
-            const stash1Hit = result.hits.find((h) => h.id === "npm:stash-one");
-            const stash2Hit = result.hits.find((h) => h.id === "github:org/stash-two");
-            expect(stash1Hit?.registryName).toBe("primary");
-            expect(stash2Hit?.registryName).toBe("secondary");
-        }
-        finally {
-            srv1.close();
-            srv2.close();
-        }
-    });
-    test("disabled registries are skipped via resolveRegistries before search", () => {
-        const entries = [
-            { url: "https://enabled.com/index.json", name: "enabled", enabled: true },
-            { url: "https://disabled.com/index.json", name: "disabled", enabled: false },
-        ];
-        const resolved = resolveRegistries(entries);
-        expect(resolved.length).toBe(1);
-        expect(resolved[0].name).toBe("enabled");
-    });
-});
-// ── Config roundtrip for registries ─────────────────────────────────────────
-describe("config roundtrip", () => {
-    test("registries persist through save/load cycle", () => {
-        const registries = [
-            { url: "https://a.com/index.json", name: "alpha" },
-            { url: "https://b.com/index.json", name: "beta", enabled: false },
-        ];
-        saveConfig({ semanticSearchMode: "auto", registries });
-        const loaded = loadConfig();
-        expect(loaded.registries?.length).toBe(2);
-        expect(loaded.registries?.[0]).toEqual({ url: "https://a.com/index.json", name: "alpha" });
-        expect(loaded.registries?.[1]).toEqual({ url: "https://b.com/index.json", name: "beta", enabled: false });
-    });
-    test("invalid registry entries are filtered during load", () => {
-        const configPath = getConfigPath();
-        writeConfig(configPath, {
-            semanticSearchMode: "auto",
-            registries: [
-                { url: "https://valid.com/index.json", name: "valid" },
-                { url: "", name: "empty-url" },
-                { name: "no-url" },
-                42,
-                null,
-            ],
-        });
-        const loaded = loadConfig();
-        expect(loaded.registries?.length).toBe(1);
-        expect(loaded.registries?.[0].url).toBe("https://valid.com/index.json");
-    });
-});