akm-cli 0.0.16 → 0.0.18

package/dist/registry-search.js

@@ -1,14 +1,8 @@
-import fs from "node:fs";
-import path from "node:path";
-import { fetchWithRetry } from "./common";
-import { getRegistryIndexCacheDir } from "./paths";
-// ── Constants ───────────────────────────────────────────────────────────────
-/** Default registry index URL. Override via config or AKM_REGISTRY_URL env var. */
-const DEFAULT_REGISTRY_URL = "https://raw.githubusercontent.com/itlackey/akm-registry/main/index.json";
-/** Cache TTL in milliseconds (1 hour). */
-const CACHE_TTL_MS = 60 * 60 * 1000;
-/** Maximum age before cache is considered stale but still usable as fallback (7 days). */
-const CACHE_STALE_MS = 7 * 24 * 60 * 60 * 1000;
+import { DEFAULT_CONFIG, loadConfig } from "./config";
+import { resolveProviderFactory } from "./provider-registry";
+// ── Eagerly import providers to trigger self-registration ───────────────────
+import "./providers/static-index";
+import "./providers/skills-sh";
 // ── Public API ──────────────────────────────────────────────────────────────
 export async function searchRegistry(query, options) {
     const trimmed = query.trim();
@@ -16,219 +10,78 @@ export async function searchRegistry(query, options) {
         return { query: "", hits: [], warnings: [] };
     }
     const limit = clampLimit(options?.limit);
-    const urls = resolveRegistryUrls(options?.registryUrls);
+    // resolveRegistries() already filters by enabled; explicit registries are filtered here
+    const raw = options?.registries ?? resolveRegistries();
+    const entries = options?.registries ? raw.filter((r) => r.enabled !== false) : raw;
     const warnings = [];
-    // Load index from all configured registries, merge kits
-    const allKits = [];
-    for (const url of urls) {
-        try {
-            const index = await loadIndex(url);
-            if (index) {
-                allKits.push(...index.kits);
-            }
-        }
-        catch (err) {
-            warnings.push(`Registry ${url}: ${toErrorMessage(err)}`);
-        }
-    }
-    // Score and rank
-    const hits = scoreKits(allKits, trimmed, limit);
-    return { query: trimmed, hits, warnings };
-}
-// ── Index loading with cache ────────────────────────────────────────────────
-async function loadIndex(url) {
-    const cachePath = indexCachePath(url);
-    const cached = readCachedIndex(cachePath);
-    // Fresh cache: return immediately
-    if (cached && !isCacheExpired(cached.mtime)) {
-        return cached.index;
-    }
-    // Try to fetch fresh index
-    try {
-        const response = await fetchWithRetry(url, undefined, { timeout: 10_000 });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}`);
-        }
-        const data = (await response.json());
-        const index = parseRegistryIndex(data);
-        if (index) {
-            writeCachedIndex(cachePath, index);
-            return index;
-        }
-        throw new Error("Invalid registry index format");
-    }
-    catch (err) {
-        // Fetch failed — use stale cache if available
-        if (cached && !isCacheStale(cached.mtime)) {
-            return cached.index;
-        }
-        throw err;
-    }
-}
-function readCachedIndex(cachePath) {
-    try {
-        const stat = fs.statSync(cachePath);
-        const raw = JSON.parse(fs.readFileSync(cachePath, "utf8"));
-        const index = parseRegistryIndex(raw);
-        if (!index)
-            return null;
-        return { index, mtime: stat.mtimeMs };
-    }
-    catch {
-        return null;
-    }
-}
-function writeCachedIndex(cachePath, index) {
-    try {
-        const dir = path.dirname(cachePath);
-        fs.mkdirSync(dir, { recursive: true });
-        const tmpPath = `${cachePath}.tmp.${process.pid}`;
-        fs.writeFileSync(tmpPath, JSON.stringify(index), "utf8");
-        fs.renameSync(tmpPath, cachePath);
-    }
-    catch {
-        // Best-effort caching — don't fail the search if we can't write
-    }
-}
-function indexCachePath(url) {
-    const indexDir = getRegistryIndexCacheDir();
-    // Deterministic filename from URL
-    const slug = url
-        .replace(/[^a-zA-Z0-9]+/g, "-")
-        .replace(/^-+|-+$/g, "")
-        .slice(0, 120);
-    return path.join(indexDir, `${slug}.json`);
-}
-function isCacheExpired(mtimeMs) {
-    return Date.now() - mtimeMs > CACHE_TTL_MS;
-}
-function isCacheStale(mtimeMs) {
-    return Date.now() - mtimeMs > CACHE_STALE_MS;
-}
-// ── Index parsing ───────────────────────────────────────────────────────────
-function parseRegistryIndex(data) {
-    if (typeof data !== "object" || data === null || Array.isArray(data))
-        return null;
-    const obj = data;
-    if (typeof obj.version !== "number" || obj.version !== 1)
-        return null;
-    if (typeof obj.updatedAt !== "string")
-        return null;
-    if (!Array.isArray(obj.kits))
-        return null;
-    const kits = obj.kits.flatMap((raw) => {
-        const kit = parseKitEntry(raw);
-        return kit ? [kit] : [];
-    });
-    return { version: 1, updatedAt: obj.updatedAt, kits };
-}
-function parseKitEntry(raw) {
-    if (typeof raw !== "object" || raw === null || Array.isArray(raw))
-        return null;
-    const obj = raw;
-    const id = asString(obj.id);
-    const name = asString(obj.name);
-    const ref = asString(obj.ref);
-    const source = asSource(obj.source);
-    if (!id || !name || !ref || !source)
-        return null;
-    return {
-        id,
-        name,
-        ref,
-        source,
-        description: asString(obj.description),
-        homepage: asString(obj.homepage),
-        tags: asStringArray(obj.tags),
-        assetTypes: asStringArray(obj.assetTypes),
-        author: asString(obj.author),
-        license: asString(obj.license),
-        latestVersion: asString(obj.latestVersion),
-        curated: obj.curated === true ? true : undefined,
-    };
-}
-// ── Scoring ─────────────────────────────────────────────────────────────────
-function scoreKits(kits, query, limit) {
-    const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
-    const scored = [];
-    for (const kit of kits) {
-        const score = scoreKit(kit, tokens);
-        if (score > 0) {
-            scored.push({ kit, score });
+    // Resolve and search all providers concurrently
+    const results = await Promise.allSettled(entries.map((entry) => {
+        const provider = createProvider(entry, warnings);
+        if (!provider)
+            return Promise.resolve(null);
+        return provider.search({ query: trimmed, limit, includeAssets: options?.includeAssets });
+    }));
+    // Merge results grouped by provider
+    const allHits = [];
+    const allAssetHits = [];
+    for (const result of results) {
+        if (result.status === "rejected") {
+            warnings.push(toErrorMessage(result.reason));
+            continue;
         }
+        const value = result.value;
+        if (!value)
+            continue;
+        allHits.push(...value.hits);
+        if (value.assetHits)
+            allAssetHits.push(...value.assetHits);
+        if (value.warnings)
+            warnings.push(...value.warnings);
     }
-    scored.sort((a, b) => b.score - a.score);
-    return scored.slice(0, limit).map(({ kit, score }) => toSearchHit(kit, score));
-}
-function scoreKit(kit, tokens) {
-    let score = 0;
-    const nameLower = kit.name.toLowerCase();
-    const descLower = (kit.description ?? "").toLowerCase();
-    const tagsLower = (kit.tags ?? []).map((t) => t.toLowerCase());
-    for (const token of tokens) {
-        // Exact name match is strongest signal
-        if (nameLower === token) {
-            score += 1.0;
-        }
-        else if (nameLower.includes(token)) {
-            score += 0.6;
-        }
-        // Tag matches are high-signal (curated keywords)
-        if (tagsLower.some((tag) => tag === token)) {
-            score += 0.5;
-        }
-        else if (tagsLower.some((tag) => tag.includes(token))) {
-            score += 0.25;
-        }
-        // Description substring
-        if (descLower.includes(token)) {
-            score += 0.2;
-        }
-        // Author match
-        if (kit.author?.toLowerCase().includes(token)) {
-            score += 0.15;
-        }
-    }
-    // Normalize by token count so multi-word queries don't inflate scores
-    return tokens.length > 0 ? score / tokens.length : 0;
-}
-function toSearchHit(kit, score) {
-    const metadata = {};
-    if (kit.latestVersion)
-        metadata.version = kit.latestVersion;
-    if (kit.author)
-        metadata.author = kit.author;
-    if (kit.license)
-        metadata.license = kit.license;
-    if (kit.assetTypes?.length)
-        metadata.assetTypes = kit.assetTypes.join(", ");
+    // Sort merged hits by score descending, apply limit
+    allHits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    const limitedHits = allHits.slice(0, limit);
+    allAssetHits.sort((a, b) => (b.score ?? 0) - (a.score ?? 0));
+    const limitedAssetHits = allAssetHits.slice(0, limit);
     return {
-        source: kit.source,
-        id: kit.id,
-        title: kit.name,
-        description: kit.description,
-        ref: kit.ref,
-        homepage: kit.homepage,
-        score: Math.round(score * 1000) / 1000,
-        metadata,
-        curated: kit.curated,
+        query: trimmed,
+        hits: limitedHits,
+        warnings,
+        assetHits: limitedAssetHits.length > 0 ? limitedAssetHits : undefined,
     };
 }
-// ── Registry URL resolution ─────────────────────────────────────────────────
-function resolveRegistryUrls(override) {
-    if (override) {
-        const urls = Array.isArray(override) ? override : [override];
-        return urls.filter(Boolean);
-    }
-    // Allow env var override (comma-separated)
+// ── Registry resolution ─────────────────────────────────────────────────────
+/**
+ * Resolve the list of enabled registries.
+ *
+ * Priority:
+ * 1. AKM_REGISTRY_URL env var (CI override, comma-separated)
+ * 2. config.registries (filtered by enabled !== false)
+ * 3. Default registries from DEFAULT_CONFIG
+ */
+export function resolveRegistries(configRegistries) {
+    // Allow env var override (comma-separated URLs) — CI escape hatch
     const envUrls = process.env.AKM_REGISTRY_URL?.trim();
     if (envUrls) {
         return envUrls
             .split(",")
             .map((u) => u.trim())
-            .filter(Boolean);
+            .filter(Boolean)
+            .map((url) => ({ url }));
     }
-    return [DEFAULT_REGISTRY_URL];
+    const registries = configRegistries ?? loadConfig().registries ?? DEFAULT_CONFIG.registries ?? [];
+    return registries.filter((r) => r.enabled !== false);
+}
+// ── Provider resolution ─────────────────────────────────────────────────────
+function createProvider(entry, warnings) {
+    const providerType = entry.provider ?? "static-index";
+    const factory = resolveProviderFactory(providerType);
+    if (!factory) {
+        const label = entry.name ? `${entry.name} (${entry.url})` : entry.url;
+        warnings.push(`Registry ${label}: unknown provider type "${providerType}"`);
+        return null;
+    }
+    return factory(entry);
 }
 // ── Utilities ───────────────────────────────────────────────────────────────
 function clampLimit(limit) {
@@ -236,20 +89,6 @@ function clampLimit(limit) {
         return 20;
     return Math.min(100, Math.max(1, Math.trunc(limit)));
 }
-function asString(value) {
-    return typeof value === "string" && value ? value : undefined;
-}
-function asSource(value) {
-    if (value === "npm" || value === "github" || value === "git" || value === "local")
-        return value;
-    return undefined;
-}
-function asStringArray(value) {
-    if (!Array.isArray(value))
-        return undefined;
-    const filtered = value.filter((v) => typeof v === "string");
-    return filtered.length > 0 ? filtered : undefined;
-}
 function toErrorMessage(error) {
     return error instanceof Error ? error.message : String(error);
 }

package/dist/renderers.js

@@ -112,7 +112,7 @@ export function detectExecHints(filePath) {
 }
 // ── Resolution ───────────────────────────────────────────────────────────────
 /**
- * Resolve execution hints for a script/tool asset.
+ * Resolve execution hints for a script asset.
  *
  * Resolution order (first non-empty value wins for each field):
  * 1. `.stash.json` fields (`run`/`setup`/`cwd`) take priority

package/dist/stash-add.js

@@ -11,7 +11,7 @@ export async function agentikitAdd(input) {
         throw new UsageError("Install ref or local directory is required.");
     const stashDir = resolveStashDir();
     const installed = await installRegistryRef(ref);
-    const replaced = loadConfig().registry?.installed.find((entry) => entry.id === installed.id);
+    const replaced = (loadConfig().installed ?? []).find((entry) => entry.id === installed.id);
     const config = upsertInstalledRegistryEntry({
         id: installed.id,
         source: installed.source,
@@ -59,7 +59,7 @@ export async function agentikitAdd(input) {
         },
         config: {
             searchPaths: config.searchPaths,
-            installedRegistryCount: config.registry?.installed.length ?? 0,
+            installedKitCount: config.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,

package/dist/stash-ref.js

@@ -6,21 +6,19 @@ import { UsageError } from "./errors";
  * Build a ref string from components.
  *
  * Examples:
- *   makeAssetRef("tool", "deploy.sh")
- *     → "tool:deploy.sh"
- *   makeAssetRef("tool", "deploy.sh", "npm:@scope/pkg")
- *     → "npm:@scope/pkg//tool:deploy.sh"
+ *   makeAssetRef("script", "deploy.sh")
+ *     → "script:deploy.sh"
+ *   makeAssetRef("script", "deploy.sh", "npm:@scope/pkg")
+ *     → "npm:@scope/pkg//script:deploy.sh"
  *   makeAssetRef("skill", "code-review", "local")
  *     → "local//skill:code-review"
- *   makeAssetRef("tool", "db/migrate/run.sh", "owner/repo")
- *     → "owner/repo//tool:db/migrate/run.sh"
+ *   makeAssetRef("script", "db/migrate/run.sh", "owner/repo")
+ *     → "owner/repo//script:db/migrate/run.sh"
  */
 export function makeAssetRef(type, name, origin) {
     validateName(name);
     const normalized = normalizeName(name);
-    // "tool" is a transparent alias for "script" -- normalize to "script" in refs
-    const resolvedType = type === "tool" ? "script" : type;
-    const asset = `${resolvedType}:${normalized}`;
+    const asset = `${type}:${normalized}`;
     if (!origin)
         return asset;
     return `${origin}//${asset}`;

package/dist/stash-registry.js

@@ -9,7 +9,7 @@ import { parseRegistryRef } from "./registry-resolve";
 export async function agentikitList(input) {
     const stashDir = input?.stashDir ?? resolveStashDir();
     const config = loadConfig();
-    const installed = config.registry?.installed ?? [];
+    const installed = config.installed ?? [];
     return {
         schemaVersion: 1,
         stashDir,
@@ -29,7 +29,7 @@ export async function agentikitRemove(input) {
         throw new UsageError("Target is required.");
     const stashDir = input.stashDir ?? resolveStashDir();
     const config = loadConfig();
-    const installed = config.registry?.installed ?? [];
+    const installed = config.installed ?? [];
     const entry = resolveInstalledTarget(installed, target);
     const updatedConfig = removeInstalledRegistryEntry(entry.id);
     removeLockEntry(entry.id);
@@ -52,7 +52,7 @@ export async function agentikitRemove(input) {
         },
         config: {
             searchPaths: updatedConfig.searchPaths,
-            installedRegistryCount: updatedConfig.registry?.installed.length ?? 0,
+            installedKitCount: updatedConfig.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,
@@ -67,7 +67,7 @@ export async function agentikitUpdate(input) {
     const target = input?.target?.trim();
     const all = input?.all === true;
     const force = input?.force === true;
-    const installedEntries = loadConfig().registry?.installed ?? [];
+    const installedEntries = loadConfig().installed ?? [];
     const selectedEntries = selectTargets(installedEntries, target, all);
     const processed = [];
     for (const entry of selectedEntries) {
@@ -116,7 +116,7 @@ export async function agentikitUpdate(input) {
         processed,
         config: {
             searchPaths: config.searchPaths,
-            installedRegistryCount: config.registry?.installed.length ?? 0,
+            installedKitCount: config.installed?.length ?? 0,
         },
         index: {
             mode: index.mode,
@@ -156,7 +156,7 @@ function resolveInstalledTarget(installed, target) {
         if (byParsedId)
             return byParsedId;
     }
-    throw new NotFoundError(`No installed registry entry matched target: ${target}`);
+    throw new NotFoundError(`No installed kit matched target: ${target}`);
 }
 function toInstalledEntry(status) {
     return {

package/dist/stash-resolve.js

@@ -1,47 +1,12 @@
 import fs from "node:fs";
 import path from "node:path";
 import { isRelevantAssetFile, resolveAssetPathFromName, TYPE_DIRS } from "./asset-spec";
-import { hasErrnoCode, isWithin, normalizeAssetType } from "./common";
+import { hasErrnoCode, isWithin } from "./common";
 import { NotFoundError, UsageError } from "./errors";
 /**
  * Resolve an asset path from a stash directory, type, and name.
- *
- * When `type` is "script" or "tool" (which is a transparent alias for "script"),
- * resolution tries both the primary type directory and the alias directory:
- *   - script → tries scripts/ then tools/
- *   - tool   → tries tools/ then scripts/
- * This ensures that `script:deploy.sh` can find files in either `scripts/` or `tools/`.
  */
 export function resolveAssetPath(stashDir, type, name) {
-    // For script/tool, try the primary directory first, then the alias directory.
-    if (type === "script" || type === "tool") {
-        const primaryDir = TYPE_DIRS[type];
-        const aliasDir = type === "script" ? "tools" : "scripts";
-        const dirsToTry = [primaryDir, aliasDir];
-        let primaryError;
-        let lastError;
-        for (let i = 0; i < dirsToTry.length; i++) {
-            try {
-                return resolveInTypeDir(stashDir, dirsToTry[i], type, name);
-            }
-            catch (err) {
-                const error = err instanceof Error ? err : new Error(String(err));
-                if (i === 0)
-                    primaryError = error;
-                lastError = error;
-                // Only fall through on NotFoundError -- rethrow security/usage errors immediately
-                if (err instanceof UsageError)
-                    throw err;
-            }
-        }
-        // Prefer the primary directory's error when it's about extension validation
-        // (i.e., the file was found but had the wrong extension) over a generic
-        // "not found" from the alias directory.
-        const errorToThrow = primaryError?.message.includes("supported script extension")
-            ? primaryError
-            : (lastError ?? new NotFoundError(`Stash asset not found for ref: ${normalizeAssetType(type)}:${name}`));
-        throw errorToThrow;
-    }
     return resolveInTypeDir(stashDir, TYPE_DIRS[type], type, name);
 }
 /**
@@ -56,26 +21,24 @@ function resolveInTypeDir(stashDir, typeDir, type, name) {
         throw new UsageError("Ref resolves outside the stash root.");
     }
     if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
-        throw new NotFoundError(`Stash asset not found for ref: ${normalizeAssetType(type)}:${name}`);
+        throw new NotFoundError(`Stash asset not found for ref: ${type}:${name}`);
     }
     const realTarget = fs.realpathSync(resolvedTarget);
     if (!isWithin(realTarget, resolvedRoot)) {
         throw new UsageError("Ref resolves outside the stash root.");
     }
-    // Use "script" for relevance check since tool is an alias for script
-    const relevanceType = type === "tool" ? "script" : type;
-    if (!isRelevantAssetFile(relevanceType, path.basename(resolvedTarget))) {
-        if (type === "tool" || type === "script") {
+    if (!isRelevantAssetFile(type, path.basename(resolvedTarget))) {
+        if (type === "script") {
             throw new NotFoundError("Script ref must resolve to a file with a supported script extension. Refer to the akm documentation for the complete list of supported script extensions.");
         }
-        throw new NotFoundError(`Stash asset not found for ref: ${normalizeAssetType(type)}:${name}`);
+        throw new NotFoundError(`Stash asset not found for ref: ${type}:${name}`);
     }
     return realTarget;
 }
 function resolveAndValidateTypeRoot(root, type, name) {
     const rootStat = readTypeRootStat(root, type, name);
     if (!rootStat.isDirectory()) {
-        throw new NotFoundError(`Stash type root is not a directory for ref: ${normalizeAssetType(type)}:${name}`);
+        throw new NotFoundError(`Stash type root is not a directory for ref: ${type}:${name}`);
     }
     return fs.realpathSync(root);
 }
@@ -85,7 +48,7 @@ function readTypeRootStat(root, type, name) {
     }
     catch (error) {
         if (hasErrnoCode(error, "ENOENT")) {
-            throw new NotFoundError(`Stash type root not found for ref: ${normalizeAssetType(type)}:${name}`);
+            throw new NotFoundError(`Stash type root not found for ref: ${type}:${name}`);
         }
         throw error;
     }

package/dist/stash-search.js

@@ -1,7 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
 import { deriveCanonicalAssetName, TYPE_DIRS } from "./asset-spec";
-import { normalizeAssetType } from "./common";
 import { loadConfig } from "./config";
 import { closeDatabase, getAllEntries, getEntryById, getEntryCount, getMeta, openDatabase, searchFts, searchVec, } from "./db";
 import { UsageError } from "./errors";
@@ -45,7 +44,7 @@ export async function agentikitSearch(input) {
             sources,
             config,
         });
-    const registryResult = source === "local" ? undefined : await searchRegistry(query, { limit, registryUrls: config.registryUrls });
+    const registryResult = source === "local" ? undefined : await searchRegistry(query, { limit, registries: config.registries });
     if (source === "local") {
         return {
             schemaVersion: 1,
@@ -67,6 +66,7 @@ export async function agentikitSearch(input) {
             action: `akm add ${installRef} -> then search again`,
             score: hit.score,
             curated: hit.curated,
+            registryName: hit.registryName,
         };
     });
     if (source === "registry") {
@@ -315,7 +315,7 @@ function buildDbHit(input) {
     const source = findSourceForPath(input.path, input.sources);
     const editable = isEditable(input.path, input.config);
     const hit = {
-        type: normalizeAssetType(input.entry.type),
+        type: input.entry.type,
         name: input.entry.name,
         path: input.path,
         ref: makeAssetRef(input.entry.type, refName, source?.registryId),
@@ -325,7 +325,7 @@ function buildDbHit(input) {
         description: input.entry.description,
         tags: input.entry.tags,
         size: deriveSize(input.entry.fileSize),
-        action: buildLocalAction(normalizeAssetType(input.entry.type), makeAssetRef(input.entry.type, refName, source?.registryId)),
+        action: buildLocalAction(input.entry.type, makeAssetRef(input.entry.type, refName, source?.registryId)),
         score,
         whyMatched,
     };
@@ -364,7 +364,7 @@ function assetToSearchHit(asset, stashDir, sources, config) {
     const fileSize = readFileSize(asset.path);
     const size = deriveSize(fileSize);
     const hit = {
-        type: normalizeAssetType(asset.entry.type),
+        type: asset.entry.type,
         name: asset.entry.name,
         path: asset.path,
         ref,
@@ -376,7 +376,7 @@ function assetToSearchHit(asset, stashDir, sources, config) {
         description: asset.entry.description,
         tags: asset.entry.tags,
         ...(size ? { size } : {}),
-        action: buildLocalAction(normalizeAssetType(asset.entry.type), ref),
+        action: buildLocalAction(asset.entry.type, ref),
     };
     const renderer = rendererForType(asset.entry.type);
     if (renderer?.enrichSearchHit) {
@@ -404,7 +404,6 @@ function mergeSearchHits(localHits, registryHits, limit) {
 }
 /** Map asset types to their primary renderer names. */
 const TYPE_TO_RENDERER = {
-    tool: "script-source",
     script: "script-source",
     skill: "skill-md",
     command: "command-md",
@@ -426,8 +425,6 @@ function buildLocalAction(type, ref) {
             return `akm show ${ref} -> dispatch with full prompt`;
         case "knowledge":
             return `akm show ${ref} -> read reference material`;
-        case "tool":
-            return `akm show ${ref} -> execute the run command`;
     }
 }
 function deriveSize(bytes) {
@@ -449,7 +446,7 @@ function readFileSize(filePath) {
 }
 function indexAssets(stashDir, type) {
     const assets = [];
-    const filterType = type === "any" ? undefined : normalizeAssetType(type);
+    const filterType = type === "any" ? undefined : type;
     const fileContexts = walkStashFlat(stashDir);
     const dirGroups = new Map();
     for (const ctx of fileContexts) {
@@ -478,8 +475,7 @@ function indexAssets(stashDir, type) {
             stash = generated;
         }
         for (const entry of stash.entries) {
-            const normalizedType = normalizeAssetType(entry.type);
-            if (filterType && normalizedType !== filterType)
+            if (filterType && entry.type !== filterType)
                 continue;
             const entryPath = entry.filename ? path.join(dirPath, entry.filename) : files[0] || dirPath;
             assets.push({ entry, path: entryPath });

package/dist/stash-show.js

@@ -1,4 +1,3 @@
-import { normalizeAssetType } from "./common";
 import { loadConfig } from "./config";
 import { NotFoundError, UsageError } from "./errors";
 import { buildFileContext, buildRenderContext, getRenderer, runMatchers } from "./file-context";
@@ -8,7 +7,7 @@ import { resolveAssetPath } from "./stash-resolve";
 import { buildEditHint, findSourceForPath, isEditable, resolveStashSources } from "./stash-source";
 export async function agentikitShow(input) {
     const parsed = parseAssetRef(input.ref);
-    const displayType = normalizeAssetType(parsed.type);
+    const displayType = parsed.type;
     const config = loadConfig();
     const allSources = resolveStashSources();
     const searchSources = resolveSourcesForOrigin(parsed.origin, allSources);