akm-cli 0.7.0 → 0.7.1

package/dist/tests/proposals.test.js

@@ -1,279 +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 { akmProposalAccept, akmProposalDiff, akmProposalList, akmProposalReject, akmProposalShow, } from "../src/commands/proposal";
-import { readEvents } from "../src/core/events";
-import { createProposal, diffProposal, getProposal, listProposals, validateProposal } from "../src/core/proposals";
-// ── Test setup ──────────────────────────────────────────────────────────────
-const tempDirs = [];
-const savedEnv = {
-    AKM_STASH_DIR: process.env.AKM_STASH_DIR,
-    XDG_CACHE_HOME: process.env.XDG_CACHE_HOME,
-    XDG_CONFIG_HOME: process.env.XDG_CONFIG_HOME,
-};
-function makeTempDir(prefix) {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    tempDirs.push(dir);
-    return dir;
-}
-function makeStashDir() {
-    const stash = makeTempDir("akm-proposals-stash-");
-    // Pre-create the canonical type directories the writer expects.
-    for (const dir of ["lessons", "skills", "memories"]) {
-        fs.mkdirSync(path.join(stash, dir), { recursive: true });
-    }
-    return stash;
-}
-function makeConfig(stashDir) {
-    return {
-        stashDir,
-        sources: [{ type: "filesystem", name: "stash", path: stashDir, writable: true }],
-        defaultWriteTarget: "stash",
-    };
-}
-beforeEach(() => {
-    process.env.XDG_CACHE_HOME = makeTempDir("akm-proposals-cache-");
-    process.env.XDG_CONFIG_HOME = makeTempDir("akm-proposals-config-");
-});
-afterEach(() => {
-    if (savedEnv.AKM_STASH_DIR === undefined)
-        delete process.env.AKM_STASH_DIR;
-    else
-        process.env.AKM_STASH_DIR = savedEnv.AKM_STASH_DIR;
-    if (savedEnv.XDG_CACHE_HOME === undefined)
-        delete process.env.XDG_CACHE_HOME;
-    else
-        process.env.XDG_CACHE_HOME = savedEnv.XDG_CACHE_HOME;
-    if (savedEnv.XDG_CONFIG_HOME === undefined)
-        delete process.env.XDG_CONFIG_HOME;
-    else
-        process.env.XDG_CONFIG_HOME = savedEnv.XDG_CONFIG_HOME;
-    for (const dir of tempDirs.splice(0)) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-// ── Tests ───────────────────────────────────────────────────────────────────
-const VALID_LESSON = `---\ndescription: Use ripgrep before grep\nwhen_to_use: Searching large repos for patterns\n---\n\nPrefer rg over grep when scanning large code repos.\n`;
-describe("createProposal / listProposals / getProposal", () => {
-    test("round-trip: create → list → show → accept materialises asset and emits promoted event", async () => {
-        const stash = makeStashDir();
-        const config = makeConfig(stash);
-        const created = createProposal(stash, {
-            ref: "lesson:rg-over-grep",
-            source: "distill",
-            sourceRun: "run-123",
-            payload: { content: VALID_LESSON },
-        });
-        expect(created.id).toBeDefined();
-        expect(created.status).toBe("pending");
-        // list
-        const listResult = akmProposalList({ stashDir: stash });
-        expect(listResult.totalCount).toBe(1);
-        expect(listResult.proposals[0]?.id).toBe(created.id);
-        // show
-        const showResult = akmProposalShow({ stashDir: stash, id: created.id });
-        expect(showResult.proposal.ref).toBe("lesson:rg-over-grep");
-        expect(showResult.validation.ok).toBe(true);
-        // accept
-        const acceptResult = await akmProposalAccept({ stashDir: stash, id: created.id, config });
-        expect(acceptResult.ok).toBe(true);
-        expect(acceptResult.ref).toBe("lesson:rg-over-grep");
-        expect(fs.existsSync(acceptResult.assetPath)).toBe(true);
-        expect(fs.readFileSync(acceptResult.assetPath, "utf8")).toContain("Prefer rg over grep");
-        // status promoted
-        const promoted = getProposal(stash, created.id);
-        expect(promoted.status).toBe("accepted");
-        expect(promoted.review?.outcome).toBe("accepted");
-        // promoted event emitted
-        const events = readEvents({ type: "promoted" });
-        expect(events.events.length).toBe(1);
-        expect(events.events[0]?.ref).toBe("lesson:rg-over-grep");
-        expect(events.events[0]?.metadata?.proposalId).toBe(created.id);
-    });
-    test("reject path: archive contains entry, status rejected, rejected event emitted", () => {
-        const stash = makeStashDir();
-        const created = createProposal(stash, {
-            ref: "lesson:bad-idea",
-            source: "reflect",
-            payload: { content: VALID_LESSON },
-        });
-        const result = akmProposalReject({ stashDir: stash, id: created.id, reason: "duplicate of existing lesson" });
-        expect(result.ok).toBe(true);
-        expect(result.proposal.status).toBe("rejected");
-        expect(result.proposal.review?.reason).toBe("duplicate of existing lesson");
-        // archive directory contains it
-        const archivePath = path.join(stash, ".akm", "proposals", "archive", created.id, "proposal.json");
-        expect(fs.existsSync(archivePath)).toBe(true);
-        // live queue empty
-        const live = listProposals(stash);
-        expect(live).toHaveLength(0);
-        // rejected event
-        const events = readEvents({ type: "rejected" });
-        expect(events.events.length).toBe(1);
-        expect(events.events[0]?.metadata?.reason).toBe("duplicate of existing lesson");
-    });
-    test("multiple proposals for same ref: distinct ids, no path collision", () => {
-        const stash = makeStashDir();
-        const a = createProposal(stash, { ref: "lesson:dup", source: "reflect", payload: { content: VALID_LESSON } });
-        const b = createProposal(stash, { ref: "lesson:dup", source: "distill", payload: { content: VALID_LESSON } });
-        expect(a.id).not.toBe(b.id);
-        const list = listProposals(stash);
-        expect(list.length).toBe(2);
-        const ids = list.map((p) => p.id).sort();
-        expect(ids).toEqual([a.id, b.id].sort());
-    });
-});
-describe("diff path", () => {
-    test("new asset: shows new-asset diff with /dev/null marker", () => {
-        const stash = makeStashDir();
-        const config = makeConfig(stash);
-        const proposal = createProposal(stash, {
-            ref: "lesson:fresh",
-            source: "reflect",
-            payload: { content: VALID_LESSON },
-        });
-        const diff = diffProposal(stash, config, proposal.id);
-        expect(diff.isNew).toBe(true);
-        expect(diff.unified).toContain("/dev/null");
-        expect(diff.unified).toContain("Prefer rg over grep");
-    });
-    test("existing asset + proposal: produces unified diff", async () => {
-        const stash = makeStashDir();
-        const config = makeConfig(stash);
-        // Pre-write an existing lesson so the diff has a left-hand side.
-        const lessonPath = path.join(stash, "lessons", "rg-over-grep.md");
-        fs.writeFileSync(lessonPath, `---\ndescription: Use ripgrep before grep\nwhen_to_use: Searching repos\n---\n\nOriginal body.\n`, "utf8");
-        const proposal = createProposal(stash, {
-            ref: "lesson:rg-over-grep",
-            source: "reflect",
-            payload: { content: VALID_LESSON },
-        });
-        const diffResult = akmProposalDiff({ stashDir: stash, id: proposal.id, config });
-        expect(diffResult.isNew).toBe(false);
-        expect(diffResult.unified).toContain("---");
-        expect(diffResult.unified).toContain("+++");
-        expect(diffResult.unified).toContain("Prefer rg over grep");
-    });
-});
-describe("validation failure", () => {
-    test("invalid lesson frontmatter → accept fails non-zero with clear error", async () => {
-        const stash = makeStashDir();
-        const config = makeConfig(stash);
-        const proposal = createProposal(stash, {
-            ref: "lesson:no-fields",
-            source: "distill",
-            payload: { content: `---\ndescription: ""\nwhen_to_use: ""\n---\n\nbody\n` },
-        });
-        const report = validateProposal(proposal);
-        expect(report.ok).toBe(false);
-        expect(report.findings.length).toBeGreaterThan(0);
-        let threw = false;
-        try {
-            await akmProposalAccept({ stashDir: stash, id: proposal.id, config });
-        }
-        catch (err) {
-            threw = true;
-            expect(err.message).toContain("validation");
-        }
-        expect(threw).toBe(true);
-        // Proposal still pending; no asset materialised
-        const stillPending = getProposal(stash, proposal.id);
-        expect(stillPending.status).toBe("pending");
-        expect(fs.existsSync(path.join(stash, "lessons", "no-fields.md"))).toBe(false);
-    });
-    test("empty content → validation fails", () => {
-        const stash = makeStashDir();
-        const proposal = createProposal(stash, {
-            ref: "lesson:empty",
-            source: "distill",
-            payload: { content: "" },
-        });
-        const report = validateProposal(proposal);
-        expect(report.ok).toBe(false);
-        expect(report.findings.some((f) => f.kind === "empty-content")).toBe(true);
-    });
-});
-// ── #284 GAP-HIGH backfill ───────────────────────────────────────────────────
-describe("akmProposalReject — non-pending status (#284 HIGH 4)", () => {
-    test("rejecting an already-archived proposal → UsageError with .code INVALID_FLAG_VALUE", async () => {
-        const stash = makeStashDir();
-        const created = createProposal(stash, {
-            ref: "lesson:once",
-            source: "reflect",
-            payload: { content: VALID_LESSON },
-        });
-        // First reject moves it to the archive.
-        akmProposalReject({ stashDir: stash, id: created.id });
-        // Second reject must fail with a typed UsageError (.code load-bearing).
-        let thrown;
-        try {
-            akmProposalReject({ stashDir: stash, id: created.id });
-        }
-        catch (err) {
-            thrown = err;
-        }
-        expect(thrown).toBeInstanceOf(Error);
-        const e = thrown;
-        expect(e.name).toBe("UsageError");
-        expect(e.code).toBe("INVALID_FLAG_VALUE");
-        expect(e.message).toMatch(/not pending|already/i);
-    });
-});
-describe("akmProposalShow / akmProposalDiff — missing id (#284 HIGH 5)", () => {
-    test("akmProposalShow on missing id → NotFoundError with .code FILE_NOT_FOUND", () => {
-        const stash = makeStashDir();
-        let thrown;
-        try {
-            akmProposalShow({ stashDir: stash, id: "deadbeef-0000-0000-0000-000000000000" });
-        }
-        catch (err) {
-            thrown = err;
-        }
-        expect(thrown).toBeInstanceOf(Error);
-        const e = thrown;
-        expect(e.name).toBe("NotFoundError");
-        expect(e.code).toBe("FILE_NOT_FOUND");
-    });
-    test("akmProposalDiff on missing id → NotFoundError with .code FILE_NOT_FOUND", () => {
-        const stash = makeStashDir();
-        const config = makeConfig(stash);
-        let thrown;
-        try {
-            akmProposalDiff({ stashDir: stash, id: "deadbeef-0000-0000-0000-000000000001", config });
-        }
-        catch (err) {
-            thrown = err;
-        }
-        expect(thrown).toBeInstanceOf(Error);
-        const e = thrown;
-        expect(e.name).toBe("NotFoundError");
-        expect(e.code).toBe("FILE_NOT_FOUND");
-    });
-});
-describe("akmProposalAccept — validation failure (#284 HIGH 6)", () => {
-    test("validation failure → no `promoted` event emitted; proposal stays pending", async () => {
-        const stash = makeStashDir();
-        const config = makeConfig(stash);
-        // Empty content — fails the lesson lint.
-        const proposal = createProposal(stash, {
-            ref: "lesson:invalid",
-            source: "distill",
-            payload: { content: "" },
-        });
-        let threw = false;
-        try {
-            await akmProposalAccept({ stashDir: stash, id: proposal.id, config });
-        }
-        catch {
-            threw = true;
-        }
-        expect(threw).toBe(true);
-        // Critical: `promoted` event must NOT be emitted on validation failure.
-        const promoted = readEvents({ type: "promoted" });
-        expect(promoted.events.length).toBe(0);
-        // And the proposal stays pending.
-        const stillPending = getProposal(stash, proposal.id);
-        expect(stillPending.status).toBe("pending");
-    });
-});

package/dist/tests/proposed-quality.test.js

@@ -1,271 +0,0 @@
-/**
- * Issue #224: `quality: "proposed"` is excluded from default search.
- *
- * Covers:
- *  - default search excludes `proposed` entries
- *  - `--include-proposed` (i.e. `akmSearch({ includeProposed: true })`) restores them
- *  - `generated` and `curated` remain on by default
- *  - unknown quality values warn once and remain searchable
- *  - SearchHit projection surfaces optional `quality` when present
- *
- * Mirrors the harness in `tests/parallel-search.test.ts` and
- * `tests/issue-36-repro.test.ts`.
- */
-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 { akmSearch } from "../src/commands/search";
-import { saveConfig } from "../src/core/config";
-import { akmIndex } from "../src/indexer/indexer";
-import { _resetUnknownQualityWarnings, isProposedQuality, validateStashEntry } from "../src/indexer/metadata";
-// ── Temp directory tracking ─────────────────────────────────────────────────
-const createdTmpDirs = [];
-function createTmpDir(prefix = "akm-issue224-") {
-    const dir = fs.mkdtempSync(path.join(os.tmpdir(), prefix));
-    createdTmpDirs.push(dir);
-    return dir;
-}
-afterAll(() => {
-    for (const dir of createdTmpDirs) {
-        fs.rmSync(dir, { recursive: true, force: true });
-    }
-});
-function writeFile(filePath, content = "") {
-    fs.mkdirSync(path.dirname(filePath), { recursive: true });
-    fs.writeFileSync(filePath, content);
-}
-function tmpStash() {
-    const dir = createTmpDir("akm-issue224-stash-");
-    for (const sub of ["skills", "commands", "agents", "knowledge", "scripts"]) {
-        fs.mkdirSync(path.join(dir, sub), { recursive: true });
-    }
-    return dir;
-}
-async function buildTestIndex(stashDir) {
-    process.env.AKM_STASH_DIR = stashDir;
-    saveConfig({ semanticSearchMode: "off" });
-    return akmIndex({ stashDir, full: true });
-}
-// ── Environment isolation ───────────────────────────────────────────────────
-const originalXdgCacheHome = process.env.XDG_CACHE_HOME;
-const originalXdgConfigHome = process.env.XDG_CONFIG_HOME;
-const originalAkmStashDir = process.env.AKM_STASH_DIR;
-let testCacheDir = "";
-let testConfigDir = "";
-beforeEach(() => {
-    testCacheDir = createTmpDir("akm-issue224-cache-");
-    testConfigDir = createTmpDir("akm-issue224-config-");
-    process.env.XDG_CACHE_HOME = testCacheDir;
-    process.env.XDG_CONFIG_HOME = testConfigDir;
-    _resetUnknownQualityWarnings();
-});
-afterEach(() => {
-    if (originalXdgCacheHome === undefined) {
-        delete process.env.XDG_CACHE_HOME;
-    }
-    else {
-        process.env.XDG_CACHE_HOME = originalXdgCacheHome;
-    }
-    if (originalXdgConfigHome === undefined) {
-        delete process.env.XDG_CONFIG_HOME;
-    }
-    else {
-        process.env.XDG_CONFIG_HOME = originalXdgConfigHome;
-    }
-    if (originalAkmStashDir === undefined) {
-        delete process.env.AKM_STASH_DIR;
-    }
-    else {
-        process.env.AKM_STASH_DIR = originalAkmStashDir;
-    }
-    if (testCacheDir) {
-        fs.rmSync(testCacheDir, { recursive: true, force: true });
-        testCacheDir = "";
-    }
-    if (testConfigDir) {
-        fs.rmSync(testConfigDir, { recursive: true, force: true });
-        testConfigDir = "";
-    }
-});
-// ── Helpers ─────────────────────────────────────────────────────────────────
-/**
- * Author three skills with deliberately distinct quality markers under the
- * same query token so default-vs-include-proposed deltas are obvious.
- */
-function seedQualitySpread(stashDir) {
-    // Curated entry
-    writeFile(path.join(stashDir, "skills", "deploy-curated", "SKILL.md"), "---\ndescription: Curated deploy skill\n---\n# Deploy curated\n");
-    writeFile(path.join(stashDir, "skills", "deploy-curated", ".stash.json"), JSON.stringify({
-        entries: [
-            {
-                name: "deploy-curated",
-                type: "skill",
-                description: "Curated deploy skill",
-                tags: ["deploy"],
-                filename: "SKILL.md",
-                quality: "curated",
-            },
-        ],
-    }));
-    // Generated entry
-    writeFile(path.join(stashDir, "skills", "deploy-generated", "SKILL.md"), "---\ndescription: Generated deploy skill\n---\n# Deploy generated\n");
-    writeFile(path.join(stashDir, "skills", "deploy-generated", ".stash.json"), JSON.stringify({
-        entries: [
-            {
-                name: "deploy-generated",
-                type: "skill",
-                description: "Generated deploy skill",
-                tags: ["deploy"],
-                filename: "SKILL.md",
-                quality: "generated",
-            },
-        ],
-    }));
-    // Proposed entry — should be filtered by default
-    writeFile(path.join(stashDir, "skills", "deploy-proposed", "SKILL.md"), "---\ndescription: Proposed deploy skill\n---\n# Deploy proposed\n");
-    writeFile(path.join(stashDir, "skills", "deploy-proposed", ".stash.json"), JSON.stringify({
-        entries: [
-            {
-                name: "deploy-proposed",
-                type: "skill",
-                description: "Proposed deploy skill",
-                tags: ["deploy"],
-                filename: "SKILL.md",
-                quality: "proposed",
-            },
-        ],
-    }));
-}
-// ── Tests ───────────────────────────────────────────────────────────────────
-describe("Issue #224: proposed quality is excluded from default search", () => {
-    test("default search returns curated + generated, excludes proposed", async () => {
-        const stashDir = tmpStash();
-        seedQualitySpread(stashDir);
-        await buildTestIndex(stashDir);
-        const result = await akmSearch({ query: "deploy", source: "stash" });
-        const hits = result.hits.filter((h) => h.type !== "registry");
-        const names = hits.map((h) => h.name);
-        expect(names).toContain("deploy-curated");
-        expect(names).toContain("deploy-generated");
-        expect(names).not.toContain("deploy-proposed");
-    });
-    test("--include-proposed surfaces proposed entries alongside the rest", async () => {
-        const stashDir = tmpStash();
-        seedQualitySpread(stashDir);
-        await buildTestIndex(stashDir);
-        const result = await akmSearch({ query: "deploy", source: "stash", includeProposed: true });
-        const hits = result.hits.filter((h) => h.type !== "registry");
-        const names = hits.map((h) => h.name);
-        expect(names).toContain("deploy-curated");
-        expect(names).toContain("deploy-generated");
-        expect(names).toContain("deploy-proposed");
-    });
-    test("empty-query enumeration also excludes proposed by default", async () => {
-        const stashDir = tmpStash();
-        seedQualitySpread(stashDir);
-        await buildTestIndex(stashDir);
-        // Empty query path goes through getAllEntries — exercise that code path too.
-        const result = await akmSearch({ query: ".", source: "stash", limit: 50 });
-        const hits = result.hits.filter((h) => h.type !== "registry");
-        const names = hits.map((h) => h.name);
-        expect(names).toContain("deploy-curated");
-        expect(names).toContain("deploy-generated");
-        expect(names).not.toContain("deploy-proposed");
-        const opted = await akmSearch({ query: ".", source: "stash", limit: 50, includeProposed: true });
-        const optedNames = opted.hits.filter((h) => h.type !== "registry").map((h) => h.name);
-        expect(optedNames).toContain("deploy-proposed");
-    });
-});
-describe("Issue #224: SearchHit surfaces optional quality field", () => {
-    test("hits carry quality verbatim when present, omit it otherwise", async () => {
-        const stashDir = tmpStash();
-        seedQualitySpread(stashDir);
-        await buildTestIndex(stashDir);
-        const result = await akmSearch({ query: "deploy", source: "stash", includeProposed: true });
-        const hits = result.hits.filter((h) => h.type !== "registry");
-        const curated = hits.find((h) => h.name === "deploy-curated");
-        const generated = hits.find((h) => h.name === "deploy-generated");
-        const proposed = hits.find((h) => h.name === "deploy-proposed");
-        expect(curated?.quality).toBe("curated");
-        expect(generated?.quality).toBe("generated");
-        expect(proposed?.quality).toBe("proposed");
-    });
-});
-describe("Issue #224: unknown quality values warn once and remain searchable", () => {
-    test("validateStashEntry preserves unknown quality and warns once per value", () => {
-        const calls = [];
-        const originalWarn = console.warn;
-        console.warn = (...args) => {
-            calls.push(args.map(String).join(" "));
-        };
-        try {
-            _resetUnknownQualityWarnings();
-            const a = validateStashEntry({ name: "a", type: "skill", quality: "experimental" });
-            const b = validateStashEntry({ name: "b", type: "skill", quality: "experimental" });
-            const c = validateStashEntry({ name: "c", type: "skill", quality: "draft" });
-            expect(a?.quality).toBe("experimental");
-            expect(b?.quality).toBe("experimental");
-            expect(c?.quality).toBe("draft");
-            // One warn per unique unknown value — not per occurrence.
-            const unknownWarns = calls.filter((c) => c.includes("unknown quality value"));
-            expect(unknownWarns.length).toBe(2);
-            expect(unknownWarns.some((m) => m.includes("experimental"))).toBe(true);
-            expect(unknownWarns.some((m) => m.includes("draft"))).toBe(true);
-            // Known values must not warn.
-            const known = validateStashEntry({ name: "d", type: "skill", quality: "curated" });
-            expect(known?.quality).toBe("curated");
-            const knownGen = validateStashEntry({ name: "e", type: "skill", quality: "generated" });
-            expect(knownGen?.quality).toBe("generated");
-            const knownProp = validateStashEntry({ name: "f", type: "skill", quality: "proposed" });
-            expect(knownProp?.quality).toBe("proposed");
-            const stillTwo = calls.filter((c) => c.includes("unknown quality value")).length;
-            expect(stillTwo).toBe(2);
-        }
-        finally {
-            console.warn = originalWarn;
-        }
-    });
-    test("unknown quality entries remain in default search (treated as included-by-default)", async () => {
-        const stashDir = tmpStash();
-        writeFile(path.join(stashDir, "skills", "deploy-experimental", "SKILL.md"), "---\ndescription: Experimental quality marker test\n---\n# deploy\n");
-        writeFile(path.join(stashDir, "skills", "deploy-experimental", ".stash.json"), JSON.stringify({
-            entries: [
-                {
-                    name: "deploy-experimental",
-                    type: "skill",
-                    description: "Experimental quality marker test",
-                    tags: ["deploy"],
-                    filename: "SKILL.md",
-                    quality: "experimental",
-                },
-            ],
-        }));
-        // Suppress warns from the indexer load path so they don't pollute test output.
-        const originalWarn = console.warn;
-        console.warn = () => { };
-        try {
-            await buildTestIndex(stashDir);
-            const result = await akmSearch({ query: "deploy", source: "stash" });
-            const hits = result.hits.filter((h) => h.type !== "registry");
-            const names = hits.map((h) => h.name);
-            expect(names).toContain("deploy-experimental");
-            // Quality field is surfaced verbatim on the hit.
-            const experimental = hits.find((h) => h.name === "deploy-experimental");
-            expect(experimental?.quality).toBe("experimental");
-        }
-        finally {
-            console.warn = originalWarn;
-        }
-    });
-});
-describe("Issue #224: isProposedQuality helper", () => {
-    test("returns true only for the literal 'proposed' marker", () => {
-        expect(isProposedQuality("proposed")).toBe(true);
-        expect(isProposedQuality("curated")).toBe(false);
-        expect(isProposedQuality("generated")).toBe(false);
-        expect(isProposedQuality(undefined)).toBe(false);
-        expect(isProposedQuality("PROPOSED")).toBe(false);
-        expect(isProposedQuality("experimental")).toBe(false);
-    });
-});

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

@@ -1,32 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { registerProvider, resolveProviderFactory } from "../src/registry/factory";
-import { resolveSourceProviderFactory } from "../src/sources/provider-factory";
-describe("provider-registry", () => {
-    test("resolveProviderFactory returns null for unknown type", () => {
-        expect(resolveProviderFactory("nonexistent-provider-xyz")).toBeNull();
-    });
-    test("registerProvider + resolveProviderFactory round-trips", () => {
-        const factory = (() => ({
-            type: "test-provider",
-            search: async () => ({ hits: [] }),
-            searchKits: async () => [],
-            getKit: async () => null,
-            canHandle: () => false,
-        }));
-        registerProvider("test-roundtrip", factory);
-        expect(resolveProviderFactory("test-roundtrip")).toBe(factory);
-    });
-    test("static-index is registered after import", async () => {
-        // Importing triggers self-registration
-        await import("../src/registry/providers/static-index");
-        expect(resolveProviderFactory("static-index")).not.toBeNull();
-    });
-    test("skills-sh is registered after import", async () => {
-        await import("../src/registry/providers/skills-sh");
-        expect(resolveProviderFactory("skills-sh")).not.toBeNull();
-    });
-    test("filesystem stash provider is registered after import", async () => {
-        await import("../src/sources/providers/filesystem");
-        expect(resolveSourceProviderFactory("filesystem")).not.toBeNull();
-    });
-});