akm-cli 0.0.16 → 0.0.17

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);

package/dist/stash-source.js

@@ -1,6 +1,6 @@
 import fs from "node:fs";
 import path from "node:path";
-import { normalizeAssetType, resolveStashDir } from "./common";
+import { resolveStashDir } from "./common";
 import { loadConfig } from "./config";
 import { warn } from "./warn";
 // ── Resolution ──────────────────────────────────────────────────────────────
@@ -11,7 +11,7 @@ import { warn } from "./warn";
  *   3. Installed kit paths (cache-managed, from registry)
  *
  * The first entry is always the primary stash. Additional entries come
- * from `searchPaths` config and `registry.installed` entries.
+ * from `searchPaths` config and `installed` kit entries.
  */
 export function resolveStashSources(overrideStashDir, existingConfig) {
     const stashDir = overrideStashDir ?? resolveStashDir();
@@ -25,7 +25,7 @@ export function resolveStashSources(overrideStashDir, existingConfig) {
             sources.push({ path: dir });
         }
     }
-    for (const entry of config.registry?.installed ?? []) {
+    for (const entry of config.installed ?? []) {
         if (isSuspiciousStashRoot(entry.stashRoot)) {
             warn(`Warning: stash root "${entry.stashRoot}" appears to be a system directory. This may be unintentional.`);
         }
@@ -67,7 +67,7 @@ export function getPrimarySource(sources) {
  * Determine whether a file is safe to edit in place.
  *
  * The only files that are NOT editable are those inside a cache directory
- * managed by the package manager (`registry.installed[].cacheDir`). These
+ * managed by the package manager (`installed[].cacheDir`). These
  * will be overwritten by `akm update` without warning.
  *
  * Everything else — working stash, search paths, local project dirs — is
@@ -76,7 +76,7 @@ export function getPrimarySource(sources) {
 export function isEditable(filePath, config) {
     const cfg = config ?? loadConfig();
     const resolved = path.resolve(filePath);
-    const cacheManaged = cfg.registry?.installed ?? [];
+    const cacheManaged = cfg.installed ?? [];
     const isWin = process.platform === "win32";
     for (const entry of cacheManaged) {
         // Local sources reference original paths — always editable
@@ -101,8 +101,7 @@ export function isEditable(filePath, config) {
  * unconditionally returns the hint string.
  */
 export function buildEditHint(_filePath, assetType, assetName, origin) {
-    const normalizedType = normalizeAssetType(assetType);
-    const ref = origin ? `${origin}//${normalizedType}:${assetName}` : `${normalizedType}:${assetName}`;
+    const ref = origin ? `${origin}//${assetType}:${assetName}` : `${assetType}:${assetName}`;
     return `This asset is managed by akm and may be overwritten on update. To edit, run: akm clone ${ref}`;
 }
 // ── Validation ──────────────────────────────────────────────────────────────

package/dist/walker.js

@@ -14,7 +14,7 @@ import { buildFileContext } from "./file-context";
  * Walk a type root directory and return files grouped by their parent directory.
  *
  * Only files relevant to the given `assetType` are included (e.g. `.md` for
- * commands, script extensions for tools, `SKILL.md` for skills).
+ * commands, script extensions for scripts, `SKILL.md` for skills).
  */
 export function walkStash(typeRoot, assetType) {
     if (!fs.existsSync(typeRoot))

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "akm-cli",
-  "version": "0.0.16",
+  "version": "0.0.17",
   "type": "module",
   "description": "CLI tool to search, open, and run extension assets from an akm stash directory.",
   "keywords": [