akm-cli 0.7.0-rc1 → 0.7.1

package/dist/tests/asset-ref.test.js

@@ -1,192 +0,0 @@
-import { describe, expect, test } from "bun:test";
-import { makeAssetRef, parseAssetRef } from "../src/core/asset-ref";
-// ── makeAssetRef ────────────────────────────────────────────────────────────
-describe("makeAssetRef", () => {
-    test("script ref", () => {
-        expect(makeAssetRef("script", "deploy.sh")).toBe("script:deploy.sh");
-    });
-    test("skill ref", () => {
-        expect(makeAssetRef("skill", "code-review")).toBe("skill:code-review");
-    });
-    test("nested path — slashes stay literal", () => {
-        expect(makeAssetRef("script", "azure/container-apps/scale.sh")).toBe("script:azure/container-apps/scale.sh");
-    });
-    test("name with spaces — no encoding", () => {
-        expect(makeAssetRef("script", "my script.sh")).toBe("script:my script.sh");
-    });
-    test("with local origin", () => {
-        expect(makeAssetRef("script", "deploy.sh", "local")).toBe("local//script:deploy.sh");
-    });
-    test("with npm origin — colons and @ stay literal", () => {
-        expect(makeAssetRef("script", "deploy.sh", "npm:@itlackey/openkit")).toBe("npm:@itlackey/openkit//script:deploy.sh");
-    });
-    test("with github shorthand origin", () => {
-        expect(makeAssetRef("skill", "code-review", "itlackey/dimm-city-stash")).toBe("itlackey/dimm-city-stash//skill:code-review");
-    });
-    test("with github prefixed origin", () => {
-        expect(makeAssetRef("script", "lint.sh", "github:owner/repo#v1.2")).toBe("github:owner/repo#v1.2//script:lint.sh");
-    });
-    test("nested name with origin", () => {
-        expect(makeAssetRef("script", "db/migrate/run.sh", "npm:@corp/db-tools")).toBe("npm:@corp/db-tools//script:db/migrate/run.sh");
-    });
-    test("normalizes backslashes", () => {
-        expect(makeAssetRef("script", "dir\\file.sh")).toBe("script:dir/file.sh");
-    });
-    test("no origin produces plain ref", () => {
-        expect(makeAssetRef("agent", "architect.md")).toBe("agent:architect.md");
-        expect(makeAssetRef("agent", "architect.md", undefined)).toBe("agent:architect.md");
-    });
-    test("rejects empty name", () => {
-        expect(() => makeAssetRef("script", "")).toThrow("Empty asset name");
-    });
-    test("rejects null byte", () => {
-        expect(() => makeAssetRef("script", "foo\0bar")).toThrow("Null byte");
-    });
-    test("rejects absolute path", () => {
-        expect(() => makeAssetRef("script", "/etc/passwd")).toThrow("Absolute path");
-    });
-    test("rejects path traversal", () => {
-        expect(() => makeAssetRef("script", "../outside.sh")).toThrow("Path traversal");
-    });
-    test("rejects Windows drive path", () => {
-        expect(() => makeAssetRef("script", "C:\\foo")).toThrow("Windows drive");
-    });
-});
-// ── parseAssetRef ───────────────────────────────────────────────────────────
-describe("parseAssetRef", () => {
-    test("simple script ref", () => {
-        const ref = parseAssetRef("script:deploy.sh");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("deploy.sh");
-        expect(ref.origin).toBeUndefined();
-    });
-    test("nested path stays literal", () => {
-        const ref = parseAssetRef("script:azure/container-apps/scale.sh");
-        expect(ref.name).toBe("azure/container-apps/scale.sh");
-    });
-    test("name with spaces", () => {
-        const ref = parseAssetRef("script:my script.sh");
-        expect(ref.name).toBe("my script.sh");
-    });
-    test("local origin", () => {
-        const ref = parseAssetRef("local//script:deploy.sh");
-        expect(ref.origin).toBe("local");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("deploy.sh");
-    });
-    test("npm origin with scope", () => {
-        const ref = parseAssetRef("npm:@itlackey/openkit//script:deploy.sh");
-        expect(ref.origin).toBe("npm:@itlackey/openkit");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("deploy.sh");
-    });
-    test("github shorthand origin", () => {
-        const ref = parseAssetRef("itlackey/dimm-city-stash//skill:code-review");
-        expect(ref.origin).toBe("itlackey/dimm-city-stash");
-        expect(ref.type).toBe("skill");
-        expect(ref.name).toBe("code-review");
-    });
-    test("github origin with tag", () => {
-        const ref = parseAssetRef("github:owner/repo#v1.2//script:lint.sh");
-        expect(ref.origin).toBe("github:owner/repo#v1.2");
-        expect(ref.type).toBe("script");
-        expect(ref.name).toBe("lint.sh");
-    });
-    test("nested name with origin", () => {
-        const ref = parseAssetRef("npm:@corp/db-tools//script:db/migrate/run.sh");
-        expect(ref.origin).toBe("npm:@corp/db-tools");
-        expect(ref.name).toBe("db/migrate/run.sh");
-    });
-    test("path-based origin", () => {
-        const ref = parseAssetRef("/mnt/shared-stash//skill:code-review");
-        expect(ref.origin).toBe("/mnt/shared-stash");
-        expect(ref.type).toBe("skill");
-        expect(ref.name).toBe("code-review");
-    });
-    test("all asset types parse", () => {
-        for (const type of ["skill", "command", "agent", "knowledge", "script"]) {
-            const ref = parseAssetRef(`${type}:test`);
-            expect(ref.type).toBe(type);
-        }
-    });
-    test("normalizes backslashes in name", () => {
-        const ref = parseAssetRef("script:dir\\file.sh");
-        expect(ref.name).toBe("dir/file.sh");
-    });
-    test("throws for invalid type", () => {
-        expect(() => parseAssetRef("widget:foo")).toThrow("Invalid asset type");
-    });
-    test("throws for removed tool type", () => {
-        expect(() => parseAssetRef("tool:deploy.sh")).toThrow("Invalid asset type");
-    });
-    test("throws for missing colon", () => {
-        expect(() => parseAssetRef("scriptname")).toThrow("Invalid ref");
-    });
-    test("throws for empty origin", () => {
-        expect(() => parseAssetRef("//script:deploy.sh")).toThrow("Empty origin");
-    });
-    test("throws for empty name", () => {
-        expect(() => parseAssetRef("script:")).toThrow("Empty asset name");
-    });
-    test("throws for path traversal in name", () => {
-        expect(() => parseAssetRef("script:../outside.sh")).toThrow("Path traversal");
-    });
-    test("throws for absolute name", () => {
-        expect(() => parseAssetRef("script:/etc/passwd")).toThrow("Absolute path");
-    });
-    test("throws for null byte in name", () => {
-        expect(() => parseAssetRef("script:foo\0bar")).toThrow("Null byte");
-    });
-    test("throws for Windows drive in name", () => {
-        expect(() => parseAssetRef("script:C:\\foo")).toThrow("Windows drive");
-    });
-    test("throws for empty string", () => {
-        expect(() => parseAssetRef("")).toThrow("Empty ref");
-    });
-    test("throws for whitespace-only string", () => {
-        expect(() => parseAssetRef("   ")).toThrow("Empty ref");
-    });
-});
-// ── Round-trips ─────────────────────────────────────────────────────────────
-describe("round-trip", () => {
-    test("script round-trips", () => {
-        const str = makeAssetRef("script", "deploy.sh");
-        expect(str).toBe("script:deploy.sh");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "deploy.sh", origin: undefined });
-    });
-    test("with npm origin", () => {
-        const str = makeAssetRef("script", "deploy.sh", "npm:@scope/pkg");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "deploy.sh", origin: "npm:@scope/pkg" });
-    });
-    test("nested path with origin", () => {
-        const str = makeAssetRef("script", "db/migrate/run.sh", "npm:@corp/tools");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "db/migrate/run.sh", origin: "npm:@corp/tools" });
-    });
-    test("local origin", () => {
-        const str = makeAssetRef("skill", "review", "local");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "skill", name: "review", origin: "local" });
-    });
-    test("github origin with tag", () => {
-        const str = makeAssetRef("script", "lint.sh", "github:owner/repo#v2.0");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "script", name: "lint.sh", origin: "github:owner/repo#v2.0" });
-    });
-    test("name with spaces", () => {
-        const str = makeAssetRef("command", "my command.md");
-        const parsed = parseAssetRef(str);
-        expect(parsed).toEqual({ type: "command", name: "my command.md", origin: undefined });
-    });
-    test("every asset type round-trips", () => {
-        for (const type of ["skill", "command", "agent", "knowledge", "script"]) {
-            const str = makeAssetRef(type, "test-asset", "owner/repo");
-            const parsed = parseAssetRef(str);
-            expect(parsed.type).toBe(type);
-            expect(parsed.name).toBe("test-asset");
-            expect(parsed.origin).toBe("owner/repo");
-        }
-    });
-});

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

@@ -1,103 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import path from "node:path";
-import { ACTION_BUILDERS, TYPE_TO_RENDERER } from "../src/core/asset-registry";
-import { deregisterAssetType, registerAssetType } from "../src/core/asset-spec";
-// ── Test helpers ────────────────────────────────────────────────────────────
-const TEST_TYPE = "registry-test-widget";
-function makeWidgetSpec(overrides = {}) {
-    return {
-        stashDir: "widgets",
-        isRelevantFile: (f) => f.endsWith(".widget"),
-        toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-        toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-        ...overrides,
-    };
-}
-// ── Tests ───────────────────────────────────────────────────────────────────
-describe("asset-registry singleton", () => {
-    afterEach(() => {
-        // Clean up the test type to avoid polluting other tests
-        deregisterAssetType(TEST_TYPE);
-        delete TYPE_TO_RENDERER[TEST_TYPE];
-        delete ACTION_BUILDERS[TEST_TYPE];
-    });
-    test("registerAssetType populates TYPE_TO_RENDERER when rendererName is set", () => {
-        registerAssetType(TEST_TYPE, makeWidgetSpec({ rendererName: "widget-md" }));
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBe("widget-md");
-    });
-    test("registerAssetType populates ACTION_BUILDERS when actionBuilder is set", () => {
-        const builder = (ref) => `akm show ${ref} -> use widget`;
-        registerAssetType(TEST_TYPE, makeWidgetSpec({ actionBuilder: builder }));
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBe(builder);
-        expect(ACTION_BUILDERS[TEST_TYPE]("widget:foo")).toBe("akm show widget:foo -> use widget");
-    });
-    test("registration works regardless of import order (no deferred hooks needed)", () => {
-        // The key property: TYPE_TO_RENDERER and ACTION_BUILDERS are populated
-        // directly, not through deferred hooks. Importing asset-registry.ts
-        // before or after asset-spec.ts doesn't matter because they share the
-        // same singleton maps.
-        const builder = (ref) => `akm show ${ref} -> render widget`;
-        registerAssetType(TEST_TYPE, makeWidgetSpec({
-            rendererName: "widget-md",
-            actionBuilder: builder,
-        }));
-        // Both maps should be populated after a single registerAssetType call
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBe("widget-md");
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBe(builder);
-    });
-    test("multiple registrations don't clobber each other", () => {
-        const type1 = `${TEST_TYPE}-1`;
-        const type2 = `${TEST_TYPE}-2`;
-        try {
-            registerAssetType(type1, makeWidgetSpec({
-                stashDir: "widgets1",
-                rendererName: "widget1-md",
-                actionBuilder: (ref) => `action1 ${ref}`,
-            }));
-            registerAssetType(type2, makeWidgetSpec({
-                stashDir: "widgets2",
-                rendererName: "widget2-md",
-                actionBuilder: (ref) => `action2 ${ref}`,
-            }));
-            expect(TYPE_TO_RENDERER[type1]).toBe("widget1-md");
-            expect(TYPE_TO_RENDERER[type2]).toBe("widget2-md");
-            expect(ACTION_BUILDERS[type1]("r")).toBe("action1 r");
-            expect(ACTION_BUILDERS[type2]("r")).toBe("action2 r");
-        }
-        finally {
-            for (const t of [type1, type2]) {
-                deregisterAssetType(t);
-                delete TYPE_TO_RENDERER[t];
-                delete ACTION_BUILDERS[t];
-            }
-        }
-    });
-    test("_setAssetTypeHooks no longer exists in asset-spec", async () => {
-        const assetSpec = await import("../src/core/asset-spec");
-        expect("_setAssetTypeHooks" in assetSpec).toBe(false);
-    });
-    test("TYPE_TO_RENDERER contains built-in types", () => {
-        expect(TYPE_TO_RENDERER.script).toBe("script-source");
-        expect(TYPE_TO_RENDERER.skill).toBe("skill-md");
-        expect(TYPE_TO_RENDERER.command).toBe("command-md");
-        expect(TYPE_TO_RENDERER.agent).toBe("agent-md");
-        expect(TYPE_TO_RENDERER.knowledge).toBe("knowledge-md");
-        expect(TYPE_TO_RENDERER.memory).toBe("memory-md");
-    });
-    test("ACTION_BUILDERS contains built-in types", () => {
-        expect(typeof ACTION_BUILDERS.script).toBe("function");
-        expect(typeof ACTION_BUILDERS.skill).toBe("function");
-        expect(typeof ACTION_BUILDERS.command).toBe("function");
-        expect(typeof ACTION_BUILDERS.agent).toBe("function");
-        expect(typeof ACTION_BUILDERS.knowledge).toBe("function");
-        expect(typeof ACTION_BUILDERS.memory).toBe("function");
-    });
-    test("spec without rendererName leaves TYPE_TO_RENDERER unchanged for that type", () => {
-        registerAssetType(TEST_TYPE, makeWidgetSpec());
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBeUndefined();
-    });
-    test("spec without actionBuilder leaves ACTION_BUILDERS unchanged for that type", () => {
-        registerAssetType(TEST_TYPE, makeWidgetSpec());
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBeUndefined();
-    });
-});

package/dist/tests/asset-spec.test.js

@@ -1,241 +0,0 @@
-import { afterEach, describe, expect, test } from "bun:test";
-import path from "node:path";
-import { ACTION_BUILDERS, TYPE_TO_RENDERER } from "../src/core/asset-registry";
-import { ASSET_SPECS, deregisterAssetType, deriveCanonicalAssetName, getAssetTypes, isRelevantAssetFile, registerAssetType, resolveAssetPathFromName, SCRIPT_EXTENSIONS, TYPE_DIRS, } from "../src/core/asset-spec";
-// ── Constants ───────────────────────────────────────────────────────────────
-describe("SCRIPT_EXTENSIONS", () => {
-    test("contains all expected extensions", () => {
-        for (const ext of [".sh", ".ts", ".js", ".ps1", ".cmd", ".bat", ".py", ".rb", ".go"]) {
-            expect(SCRIPT_EXTENSIONS.has(ext)).toBe(true);
-        }
-    });
-    test("does not contain non-script extensions", () => {
-        for (const ext of [".md", ".json", ".txt"]) {
-            expect(SCRIPT_EXTENSIONS.has(ext)).toBe(false);
-        }
-    });
-});
-describe("getAssetTypes", () => {
-    test("contains all built-in types", () => {
-        const types = getAssetTypes();
-        expect(types).toContain("skill");
-        expect(types).toContain("command");
-        expect(types).toContain("agent");
-        expect(types).toContain("knowledge");
-        expect(types).toContain("workflow");
-        expect(types).toContain("script");
-        expect(types).toContain("memory");
-        expect(types).toContain("vault");
-        expect(types).toContain("wiki");
-        expect(types).toContain("lesson");
-        expect(types).toHaveLength(10);
-    });
-});
-describe("TYPE_DIRS", () => {
-    test("maps types to directory names", () => {
-        expect(TYPE_DIRS.skill).toBe("skills");
-        expect(TYPE_DIRS.command).toBe("commands");
-        expect(TYPE_DIRS.agent).toBe("agents");
-        expect(TYPE_DIRS.knowledge).toBe("knowledge");
-        expect(TYPE_DIRS.workflow).toBe("workflows");
-        expect(TYPE_DIRS.script).toBe("scripts");
-        expect(TYPE_DIRS.memory).toBe("memories");
-        expect(TYPE_DIRS.vault).toBe("vaults");
-        expect(TYPE_DIRS.lesson).toBe("lessons");
-    });
-});
-// ── isRelevantAssetFile ─────────────────────────────────────────────────────
-describe("isRelevantAssetFile", () => {
-    test("script: accepts all script extensions", () => {
-        expect(isRelevantAssetFile("script", "deploy.sh")).toBe(true);
-        expect(isRelevantAssetFile("script", "run.ts")).toBe(true);
-        expect(isRelevantAssetFile("script", "script.js")).toBe(true);
-        expect(isRelevantAssetFile("script", "run.ps1")).toBe(true);
-        expect(isRelevantAssetFile("script", "run.cmd")).toBe(true);
-        expect(isRelevantAssetFile("script", "run.bat")).toBe(true);
-        expect(isRelevantAssetFile("script", "run.py")).toBe(true);
-        expect(isRelevantAssetFile("script", "main.go")).toBe(true);
-        expect(isRelevantAssetFile("script", "run.lua")).toBe(true);
-    });
-    test("script: rejects non-script files", () => {
-        expect(isRelevantAssetFile("script", "README.md")).toBe(false);
-        expect(isRelevantAssetFile("script", "package.json")).toBe(false);
-        expect(isRelevantAssetFile("script", "data.txt")).toBe(false);
-    });
-    test("skill: only accepts SKILL.md", () => {
-        expect(isRelevantAssetFile("skill", "SKILL.md")).toBe(true);
-        expect(isRelevantAssetFile("skill", "skill.md")).toBe(false);
-        expect(isRelevantAssetFile("skill", "README.md")).toBe(false);
-        expect(isRelevantAssetFile("skill", "deploy.sh")).toBe(false);
-    });
-    test("command: accepts .md files", () => {
-        expect(isRelevantAssetFile("command", "release.md")).toBe(true);
-        expect(isRelevantAssetFile("command", "SETUP.MD")).toBe(true);
-        expect(isRelevantAssetFile("command", "script.sh")).toBe(false);
-    });
-    test("agent: accepts .md files", () => {
-        expect(isRelevantAssetFile("agent", "architect.md")).toBe(true);
-        expect(isRelevantAssetFile("agent", "coach.MD")).toBe(true);
-        expect(isRelevantAssetFile("agent", "script.ts")).toBe(false);
-    });
-    test("knowledge: accepts .md files", () => {
-        expect(isRelevantAssetFile("knowledge", "guide.md")).toBe(true);
-        expect(isRelevantAssetFile("knowledge", "data.json")).toBe(false);
-    });
-    test("workflow: accepts .md files", () => {
-        expect(isRelevantAssetFile("workflow", "release.md")).toBe(true);
-        expect(isRelevantAssetFile("workflow", "release.txt")).toBe(false);
-    });
-});
-// ── deriveCanonicalAssetName ────────────────────────────────────────────────
-describe("deriveCanonicalAssetName", () => {
-    test("script: returns relative path from type root", () => {
-        const root = "/stash/scripts";
-        const file = path.join(root, "docker", "build.sh");
-        expect(deriveCanonicalAssetName("script", root, file)).toBe("docker/build.sh");
-    });
-    test("script: returns file name for flat structure", () => {
-        const root = "/stash/scripts";
-        const file = path.join(root, "deploy.sh");
-        expect(deriveCanonicalAssetName("script", root, file)).toBe("deploy.sh");
-    });
-    test("skill: returns directory name for SKILL.md", () => {
-        const root = "/stash/skills";
-        const file = path.join(root, "code-review", "SKILL.md");
-        expect(deriveCanonicalAssetName("skill", root, file)).toBe("code-review");
-    });
-    test("skill: returns undefined for SKILL.md at root", () => {
-        const root = "/stash/skills";
-        const file = path.join(root, "SKILL.md");
-        expect(deriveCanonicalAssetName("skill", root, file)).toBeUndefined();
-    });
-    test("command: returns relative path without .md extension", () => {
-        const root = "/stash/commands";
-        const file = path.join(root, "release.md");
-        expect(deriveCanonicalAssetName("command", root, file)).toBe("release");
-    });
-    test("agent: returns relative path without .md extension", () => {
-        const root = "/stash/agents";
-        const file = path.join(root, "architect.md");
-        expect(deriveCanonicalAssetName("agent", root, file)).toBe("architect");
-    });
-    test("knowledge: returns relative path without .md extension", () => {
-        const root = "/stash/knowledge";
-        const file = path.join(root, "guide.md");
-        expect(deriveCanonicalAssetName("knowledge", root, file)).toBe("guide");
-    });
-    test("workflow: returns relative path without .md extension", () => {
-        const root = "/stash/workflows";
-        const file = path.join(root, "release", "ship.md");
-        expect(deriveCanonicalAssetName("workflow", root, file)).toBe("release/ship");
-    });
-    test("script: returns relative path including subdirectory", () => {
-        const root = "/stash/scripts";
-        const file = path.join(root, "utils", "cleanup.py");
-        expect(deriveCanonicalAssetName("script", root, file)).toBe("utils/cleanup.py");
-    });
-    test("vault: top-level <name>.env → <name>", () => {
-        const root = "/stash/vaults";
-        expect(deriveCanonicalAssetName("vault", root, path.join(root, "prod.env"))).toBe("prod");
-    });
-    test("vault: top-level `.env` → `default`", () => {
-        const root = "/stash/vaults";
-        expect(deriveCanonicalAssetName("vault", root, path.join(root, ".env"))).toBe("default");
-    });
-    test("vault: nested <dir>/<name>.env → <dir>/<name>", () => {
-        const root = "/stash/vaults";
-        expect(deriveCanonicalAssetName("vault", root, path.join(root, "team", "prod.env"))).toBe("team/prod");
-    });
-    test("vault: nested <dir>/.env → <dir>/default", () => {
-        const root = "/stash/vaults";
-        expect(deriveCanonicalAssetName("vault", root, path.join(root, "team", ".env"))).toBe("team/default");
-    });
-});
-// ── resolveAssetPathFromName ────────────────────────────────────────────────
-describe("resolveAssetPathFromName", () => {
-    test("script: joins type root with name", () => {
-        expect(resolveAssetPathFromName("script", "/stash/scripts", "deploy.sh")).toBe(path.join("/stash/scripts", "deploy.sh"));
-    });
-    test("skill: appends SKILL.md to name directory", () => {
-        expect(resolveAssetPathFromName("skill", "/stash/skills", "code-review")).toBe(path.join("/stash/skills", "code-review", "SKILL.md"));
-    });
-    test("command: joins type root with name", () => {
-        expect(resolveAssetPathFromName("command", "/stash/commands", "release.md")).toBe(path.join("/stash/commands", "release.md"));
-    });
-    test("workflow: joins type root with name", () => {
-        expect(resolveAssetPathFromName("workflow", "/stash/workflows", "release/ship")).toBe(path.join("/stash/workflows", "release/ship.md"));
-    });
-});
-// ── R3.17: registerAssetType — single-call full registration ────────────────
-//
-// When `registerAssetType` is called with `rendererName` and `actionBuilder`
-// in the spec, it should automatically populate TYPE_TO_RENDERER and
-// ACTION_BUILDERS via the asset-registry singleton.
-// This means callers need only one `registerAssetType` call to fully integrate
-// a new asset type with the search and renderer systems.
-describe("registerAssetType", () => {
-    const TEST_TYPE = "widget-test-r317";
-    afterEach(() => {
-        // Clean up the test type to avoid polluting other tests
-        deregisterAssetType(TEST_TYPE);
-        delete TYPE_TO_RENDERER[TEST_TYPE];
-        delete ACTION_BUILDERS[TEST_TYPE];
-    });
-    test("adds the new type to ASSET_SPECS and TYPE_DIRS", () => {
-        registerAssetType(TEST_TYPE, {
-            stashDir: "widgets",
-            isRelevantFile: (f) => f.endsWith(".widget"),
-            toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-            toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-        });
-        expect(ASSET_SPECS[TEST_TYPE]).toBeDefined();
-        expect(TYPE_DIRS[TEST_TYPE]).toBe("widgets");
-        expect(getAssetTypes()).toContain(TEST_TYPE);
-    });
-    test("automatically registers rendererName into TYPE_TO_RENDERER", () => {
-        registerAssetType(TEST_TYPE, {
-            stashDir: "widgets",
-            isRelevantFile: (f) => f.endsWith(".widget"),
-            toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-            toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-            rendererName: "widget-md",
-        });
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBe("widget-md");
-    });
-    test("automatically registers actionBuilder into ACTION_BUILDERS", () => {
-        const builder = (ref) => `akm show ${ref} -> use widget`;
-        registerAssetType(TEST_TYPE, {
-            stashDir: "widgets",
-            isRelevantFile: (f) => f.endsWith(".widget"),
-            toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-            toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-            actionBuilder: builder,
-        });
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBe(builder);
-        expect(ACTION_BUILDERS[TEST_TYPE]?.("widget:my-widget")).toBe("akm show widget:my-widget -> use widget");
-    });
-    test("registers both rendererName and actionBuilder in a single call", () => {
-        const builder = (ref) => `akm show ${ref} -> render widget`;
-        registerAssetType(TEST_TYPE, {
-            stashDir: "widgets",
-            isRelevantFile: (f) => f.endsWith(".widget"),
-            toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-            toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-            rendererName: "widget-md",
-            actionBuilder: builder,
-        });
-        // Both search-system hooks should be populated after the single call
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBe("widget-md");
-        expect(ACTION_BUILDERS[TEST_TYPE]).toBe(builder);
-    });
-    test("spec without rendererName leaves TYPE_TO_RENDERER unchanged for that type", () => {
-        registerAssetType(TEST_TYPE, {
-            stashDir: "widgets",
-            isRelevantFile: (f) => f.endsWith(".widget"),
-            toCanonicalName: (_root, fp) => path.basename(fp, ".widget"),
-            toAssetPath: (root, name) => path.join(root, `${name}.widget`),
-            // intentionally no rendererName
-        });
-        expect(TYPE_TO_RENDERER[TEST_TYPE]).toBeUndefined();
-    });
-});