akm-cli 0.6.0 → 0.7.0-rc1

package/dist/tests/proposals.test.js

@@ -0,0 +1,279 @@
+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

@@ -0,0 +1,271 @@
+/**
+ * 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

@@ -0,0 +1,32 @@
+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();
+    });
+});