agentikit 0.0.14 → 0.0.15

package/dist/self-update.js

@@ -1,7 +1,7 @@
 import { createHash } from "node:crypto";
 import fs from "node:fs";
 import path from "node:path";
-import { IS_WINDOWS, fetchWithRetry } from "./common";
+import { fetchWithRetry, IS_WINDOWS } from "./common";
 import { githubHeaders } from "./github";
 const REPO = "itlackey/agentikit";
 export function detectInstallMethod() {
@@ -43,7 +43,7 @@ export async function checkForUpdate(currentVersion) {
     return {
         currentVersion,
         latestVersion,
-        updateAvailable: latestVersion !== "" && latestVersion !== currentVersion,
+        updateAvailable: latestVersion !== "" && Bun.semver.order(currentVersion, latestVersion) < 0,
         installMethod,
     };
 }
@@ -101,9 +101,7 @@ export async function performUpgrade(check, opts) {
             if (expectedHash) {
                 const actualHash = createHash("sha256").update(binaryData).digest("hex");
                 if (actualHash !== expectedHash) {
-                    throw new Error(`Checksum mismatch for ${binaryName}.\n` +
-                        `Expected: ${expectedHash}\n` +
-                        `Got:      ${actualHash}`);
+                    throw new Error(`Checksum mismatch for ${binaryName}.\n` + `Expected: ${expectedHash}\n` + `Got:      ${actualHash}`);
                 }
                 checksumVerified = true;
             }
@@ -162,7 +160,9 @@ export async function performUpgrade(check, opts) {
             try {
                 fs.unlinkSync(tmpPath);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             const code = err.code;
             if (code === "EACCES" || code === "EPERM") {
                 throw new Error(`Permission denied writing to ${execDir}.\n` +
@@ -181,20 +181,26 @@ export async function performUpgrade(check, opts) {
             try {
                 fs.unlinkSync(tmpPath);
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             try {
                 if (fs.existsSync(bakPath) && !fs.existsSync(execPath)) {
                     fs.renameSync(bakPath, execPath);
                 }
             }
-            catch { /* ignore */ }
+            catch {
+                /* ignore */
+            }
             throw err;
         }
         // Cleanup backup
         try {
             fs.unlinkSync(bakPath);
         }
-        catch { /* ignore */ }
+        catch {
+            /* ignore */
+        }
     }
     return {
         currentVersion,

package/dist/stash-add.js

@@ -1,13 +1,14 @@
-import { agentikitIndex } from "./indexer";
 import fs from "node:fs";
 import { resolveStashDir } from "./common";
 import { loadConfig } from "./config";
+import { UsageError } from "./errors";
+import { agentikitIndex } from "./indexer";
 import { upsertLockEntry } from "./lockfile";
-import { upsertInstalledRegistryEntry, installRegistryRef } from "./registry-install";
+import { installRegistryRef, upsertInstalledRegistryEntry } from "./registry-install";
 export async function agentikitAdd(input) {
     const ref = input.ref.trim();
     if (!ref)
-        throw new Error("Install ref or local directory is required.");
+        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);

package/dist/stash-clone.js

@@ -1,11 +1,11 @@
 import fs from "node:fs";
 import path from "node:path";
 import { TYPE_DIRS } from "./asset-spec";
-import { parseAssetRef, makeAssetRef } from "./stash-ref";
-import { resolveSourcesForOrigin, isRemoteOrigin } from "./origin-resolve";
-import { resolveAssetPath } from "./stash-resolve";
-import { resolveStashSources, findSourceForPath, getPrimarySource } from "./stash-source";
+import { isRemoteOrigin, resolveSourcesForOrigin } from "./origin-resolve";
 import { installRegistryRef } from "./registry-install";
+import { makeAssetRef, parseAssetRef } from "./stash-ref";
+import { resolveAssetPath } from "./stash-resolve";
+import { findSourceForPath, getPrimarySource, resolveStashSources } from "./stash-source";
 export async function agentikitClone(options) {
     const parsed = parseAssetRef(options.sourceRef);
     // When --dest is provided, the working stash is optional

package/dist/stash-ref.js

@@ -1,5 +1,6 @@
 import path from "node:path";
 import { isAssetType } from "./common";
+import { UsageError } from "./errors";
 // ── Construction ────────────────────────────────────────────────────────────
 /**
  * Build a ref string from components.
@@ -29,7 +30,7 @@ export function makeAssetRef(type, name, origin) {
 export function parseAssetRef(ref) {
     const trimmed = ref.trim();
     if (!trimmed)
-        throw new Error("Empty ref.");
+        throw new UsageError("Empty ref.");
     let origin;
     let body = trimmed;
     const boundary = trimmed.indexOf("//");
@@ -37,16 +38,16 @@ export function parseAssetRef(ref) {
         origin = trimmed.slice(0, boundary);
         body = trimmed.slice(boundary + 2);
         if (!origin)
-            throw new Error("Empty origin in ref.");
+            throw new UsageError("Empty origin in ref.");
     }
     const colon = body.indexOf(":");
     if (colon <= 0) {
-        throw new Error(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
+        throw new UsageError(`Invalid ref "${trimmed}". Expected [origin//]type:name`);
     }
     const rawType = body.slice(0, colon);
     const rawName = body.slice(colon + 1);
     if (!isAssetType(rawType)) {
-        throw new Error(`Invalid asset type: "${rawType}".`);
+        throw new UsageError(`Invalid asset type: "${rawType}".`);
     }
     validateName(rawName);
     const name = normalizeName(rawName);
@@ -55,16 +56,16 @@ export function parseAssetRef(ref) {
 // ── Validation ──────────────────────────────────────────────────────────────
 function validateName(name) {
     if (!name)
-        throw new Error("Empty asset name.");
+        throw new UsageError("Empty asset name.");
     if (name.includes("\0"))
-        throw new Error("Null byte in asset name.");
+        throw new UsageError("Null byte in asset name.");
     if (/^[A-Za-z]:/.test(name))
-        throw new Error("Windows drive path in asset name.");
+        throw new UsageError("Windows drive path in asset name.");
     const normalized = path.posix.normalize(name.replace(/\\/g, "/"));
     if (path.posix.isAbsolute(normalized))
-        throw new Error("Absolute path in asset name.");
+        throw new UsageError("Absolute path in asset name.");
     if (normalized === ".." || normalized.startsWith("../")) {
-        throw new Error("Path traversal in asset name.");
+        throw new UsageError("Path traversal in asset name.");
     }
 }
 function normalizeName(name) {

package/dist/stash-registry.js

@@ -1,9 +1,10 @@
 import fs from "node:fs";
 import { resolveStashDir } from "./common";
 import { loadConfig } from "./config";
+import { NotFoundError, UsageError } from "./errors";
 import { agentikitIndex } from "./indexer";
 import { removeLockEntry, upsertLockEntry } from "./lockfile";
-import { installRegistryRef, removeInstalledRegistryEntry, upsertInstalledRegistryEntry, } from "./registry-install";
+import { installRegistryRef, removeInstalledRegistryEntry, upsertInstalledRegistryEntry } from "./registry-install";
 import { parseRegistryRef } from "./registry-resolve";
 export async function agentikitList(input) {
     const stashDir = input?.stashDir ?? resolveStashDir();
@@ -24,7 +25,7 @@ export async function agentikitList(input) {
 export async function agentikitRemove(input) {
     const target = input.target.trim();
     if (!target)
-        throw new Error("Target is required.");
+        throw new UsageError("Target is required.");
     const stashDir = input.stashDir ?? resolveStashDir();
     const config = loadConfig();
     const installed = config.registry?.installed ?? [];
@@ -120,12 +121,12 @@ export async function agentikitUpdate(input) {
 }
 function selectTargets(installed, target, all) {
     if (all && target) {
-        throw new Error("Specify either <target> or --all, not both.");
+        throw new UsageError("Specify either <target> or --all, not both.");
     }
     if (all)
         return installed;
     if (!target) {
-        throw new Error("Either <target> or --all is required.");
+        throw new UsageError("Either <target> or --all is required.");
     }
     return [resolveInstalledTarget(installed, target)];
 }
@@ -148,7 +149,7 @@ function resolveInstalledTarget(installed, target) {
         if (byParsedId)
             return byParsedId;
     }
-    throw new Error(`No installed registry entry matched target: ${target}`);
+    throw new NotFoundError(`No installed registry entry matched target: ${target}`);
 }
 function toInstalledEntry(status) {
     return {

package/dist/stash-resolve.js

@@ -1,37 +1,38 @@
 import fs from "node:fs";
 import path from "node:path";
+import { isRelevantAssetFile, resolveAssetPathFromName, TYPE_DIRS } from "./asset-spec";
 import { hasErrnoCode, isWithin } from "./common";
-import { TYPE_DIRS, isRelevantAssetFile, resolveAssetPathFromName } from "./asset-spec";
+import { NotFoundError, UsageError } from "./errors";
 export function resolveAssetPath(stashDir, type, name) {
     const root = path.join(stashDir, TYPE_DIRS[type]);
     const target = resolveAssetPathFromName(type, root, name);
     const resolvedRoot = resolveAndValidateTypeRoot(root, type, name);
     const resolvedTarget = path.resolve(target);
     if (!isWithin(resolvedTarget, resolvedRoot)) {
-        throw new Error("Ref resolves outside the stash root.");
+        throw new UsageError("Ref resolves outside the stash root.");
     }
     if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
-        throw new Error(`Stash asset not found for ref: ${type}:${name}`);
+        throw new NotFoundError(`Stash asset not found for ref: ${type}:${name}`);
     }
     const realTarget = fs.realpathSync(resolvedTarget);
     if (!isWithin(realTarget, resolvedRoot)) {
-        throw new Error("Ref resolves outside the stash root.");
+        throw new UsageError("Ref resolves outside the stash root.");
     }
     if (!isRelevantAssetFile(type, path.basename(resolvedTarget))) {
         if (type === "tool") {
-            throw new Error("Tool ref must resolve to a .sh, .ts, .js, .ps1, .cmd, or .bat file.");
+            throw new NotFoundError("Tool ref must resolve to a .sh, .ts, .js, .ps1, .cmd, or .bat file.");
         }
         if (type === "script") {
-            throw new Error("Script ref must resolve to a file with a supported script extension. Refer to the Agentikit documentation for the complete list of supported script extensions.");
+            throw new NotFoundError("Script ref must resolve to a file with a supported script extension. Refer to the Agentikit documentation for the complete list of supported script extensions.");
         }
-        throw new Error(`Stash asset not found for ref: ${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 Error(`Stash type root is not a directory for ref: ${type}:${name}`);
+        throw new NotFoundError(`Stash type root is not a directory for ref: ${type}:${name}`);
     }
     return fs.realpathSync(root);
 }
@@ -41,7 +42,7 @@ function readTypeRootStat(root, type, name) {
     }
     catch (error) {
         if (hasErrnoCode(error, "ENOENT")) {
-            throw new Error(`Stash type root not found for ref: ${type}:${name}`);
+            throw new NotFoundError(`Stash type root not found for ref: ${type}:${name}`);
         }
         throw error;
     }

package/dist/stash-search.js

@@ -1,13 +1,16 @@
 import fs from "node:fs";
 import path from "node:path";
-import { ASSET_TYPES, TYPE_DIRS, deriveCanonicalAssetName } from "./asset-spec";
-import { walkStash } from "./walker";
-import { makeAssetRef } from "./stash-ref";
+import { ASSET_TYPES, deriveCanonicalAssetName, TYPE_DIRS } from "./asset-spec";
+import { tryGetHandler } from "./asset-type-handler";
 import { loadConfig } from "./config";
+import { closeDatabase, getAllEntries, getEntryById, getEntryCount, getMeta, openDatabase, searchFts, searchVec, } from "./db";
+import { UsageError } from "./errors";
+import { getDbPath } from "./paths";
 import { searchRegistry } from "./registry-search";
-import { openDatabase, closeDatabase, getDbPath, getMeta, searchFts, searchVec, getAllEntries, getEntryCount, getEntryById, } from "./db";
-import { tryGetHandler } from "./asset-type-handler";
-import { resolveStashSources, findSourceForPath, isEditable, buildEditHint } from "./stash-source";
+import { makeAssetRef } from "./stash-ref";
+import { buildEditHint, findSourceForPath, isEditable, resolveStashSources } from "./stash-source";
+import { walkStash } from "./walker";
+import { warn } from "./warn";
 const DEFAULT_LIMIT = 20;
 export async function agentikitSearch(input) {
     const t0 = Date.now();
@@ -17,7 +20,8 @@ export async function agentikitSearch(input) {
     const limit = normalizeLimit(input.limit);
     const usageMode = parseSearchUsageMode(input.usage);
     const source = parseSearchSource(input.source);
-    const sources = resolveStashSources();
+    const config = loadConfig();
+    const sources = resolveStashSources(undefined, config);
     if (sources.length === 0) {
         return {
             stashDir: "",
@@ -37,11 +41,9 @@ export async function agentikitSearch(input) {
             usageMode,
             stashDir,
             sources,
+            config,
         });
-    const config = loadConfig();
-    const registryResult = source === "local"
-        ? undefined
-        : await searchRegistry(query, { limit, registryUrls: config.registryUrls });
+    const registryResult = source === "local" ? undefined : await searchRegistry(query, { limit, registryUrls: config.registryUrls });
     if (source === "local") {
         return {
             stashDir,
@@ -83,21 +85,19 @@ export async function agentikitSearch(input) {
         };
     }
     const mergedHits = mergeSearchHits(localResult?.hits ?? [], registryHits, limit);
+    const warnings = [...(localResult?.warnings ?? []), ...(registryResult?.warnings ?? [])];
     return {
         stashDir,
         source,
         hits: mergedHits,
         usageGuide: localResult?.usageGuide,
         tip: mergedHits.length === 0 ? "No matching stash assets or registry entries were found." : undefined,
-        warnings: [...(localResult?.warnings ?? []), ...(registryResult?.warnings ?? [])].length
-            ? [...(localResult?.warnings ?? []), ...(registryResult?.warnings ?? [])]
-            : undefined,
+        warnings: warnings.length ? warnings : undefined,
         timing: { totalMs: Date.now() - t0 },
     };
 }
 async function searchLocal(input) {
-    const { query, searchType, limit, usageMode, stashDir, sources } = input;
-    const config = loadConfig();
+    const { query, searchType, limit, usageMode, stashDir, sources, config } = input;
     const allStashDirs = sources.map((s) => s.path);
     // Try to open the database
     const dbPath = getDbPath();
@@ -113,7 +113,9 @@ async function searchLocal(input) {
                     return {
                         hits,
                         usageGuide,
-                        tip: hits.length === 0 ? "No matching stash assets were found. Try running 'akm index' to rebuild." : undefined,
+                        tip: hits.length === 0
+                            ? "No matching stash assets were found. Try running 'akm index' to rebuild."
+                            : undefined,
                         embedMs,
                         rankMs,
                     };
@@ -125,12 +127,14 @@ async function searchLocal(input) {
         }
     }
     catch (error) {
-        console.warn("Search index unavailable, falling back to substring search:", error instanceof Error ? error.message : String(error));
+        warn("Search index unavailable, falling back to substring search:", error instanceof Error ? error.message : String(error));
     }
     const hits = allStashDirs
         .flatMap((dir) => substringSearch(query, searchType, limit, dir, sources, config))
         .slice(0, limit);
-    const usageGuide = shouldIncludeUsageGuide(usageMode) ? buildUsageGuide(hits.map((hit) => hit.type), searchType) : undefined;
+    const usageGuide = shouldIncludeUsageGuide(usageMode)
+        ? buildUsageGuide(hits.map((hit) => hit.type), searchType)
+        : undefined;
     return {
         hits,
         usageGuide,
@@ -297,7 +301,7 @@ async function tryVecScores(db, query, k, config) {
         return scores;
     }
     catch (error) {
-        console.warn("Vector search failed, skipping:", error instanceof Error ? error.message : String(error));
+        warn("Vector search failed, skipping:", error instanceof Error ? error.message : String(error));
         return null;
     }
 }
@@ -314,8 +318,7 @@ function substringSearch(query, searchType, limit, stashDir, sources, config) {
 function buildDbHit(input) {
     const entryStashDir = findSourceForPath(input.path, input.sources)?.path ?? input.defaultStashDir;
     const typeRoot = path.join(entryStashDir, TYPE_DIRS[input.entry.type]);
-    const openRefName = deriveCanonicalAssetName(input.entry.type, typeRoot, input.path)
-        ?? input.entry.name;
+    const openRefName = deriveCanonicalAssetName(input.entry.type, typeRoot, input.path) ?? input.entry.name;
     const qualityBoost = input.entry.generated === true ? 0 : 0.05;
     const confidenceBoost = typeof input.entry.confidence === "number" ? Math.min(0.05, Math.max(0, input.entry.confidence) * 0.05) : 0;
     const score = Math.round(input.score * (1 + qualityBoost + confidenceBoost) * 1000) / 1000;
@@ -398,14 +401,14 @@ function parseSearchUsageMode(mode) {
     }
     if (typeof mode === "undefined")
         return "both";
-    throw new Error(`Invalid usage mode: ${String(mode)}. Expected one of: none|both|item|guide`);
+    throw new UsageError(`Invalid usage mode: ${String(mode)}. Expected one of: none|both|item|guide`);
 }
 function parseSearchSource(source) {
     if (source === "local" || source === "registry" || source === "both")
         return source;
     if (typeof source === "undefined")
         return "local";
-    throw new Error(`Invalid search source: ${String(source)}. Expected one of: local|registry|both`);
+    throw new UsageError(`Invalid search source: ${String(source)}. Expected one of: local|registry|both`);
 }
 function mergeSearchHits(localHits, registryHits, limit) {
     const all = [...localHits, ...registryHits];

package/dist/stash-show.js

@@ -1,11 +1,12 @@
 import fs from "node:fs";
-import { parseAssetRef } from "./stash-ref";
-import { resolveSourcesForOrigin } from "./origin-resolve";
-import { resolveAssetPath } from "./stash-resolve";
 import { getHandler } from "./asset-type-handler";
-import { resolveStashSources, findSourceForPath, isEditable, buildEditHint } from "./stash-source";
-import { buildFileContext, runMatchers, getRenderer, buildRenderContext } from "./file-context";
 import { loadConfig } from "./config";
+import { NotFoundError } from "./errors";
+import { buildFileContext, buildRenderContext, getRenderer, runMatchers } from "./file-context";
+import { resolveSourcesForOrigin } from "./origin-resolve";
+import { parseAssetRef } from "./stash-ref";
+import { resolveAssetPath } from "./stash-resolve";
+import { buildEditHint, findSourceForPath, isEditable, resolveStashSources } from "./stash-source";
 export async function agentikitShow(input) {
     const parsed = parseAssetRef(input.ref);
     const config = loadConfig();
@@ -25,11 +26,11 @@ export async function agentikitShow(input) {
     }
     if (!assetPath && parsed.origin && searchSources.length === 0) {
         const installCmd = `akm add ${parsed.origin}`;
-        throw new Error(`Stash asset not found for ref: ${parsed.type}:${parsed.name}. ` +
+        throw new NotFoundError(`Stash asset not found for ref: ${parsed.type}:${parsed.name}. ` +
             `Kit "${parsed.origin}" is not installed. Run: ${installCmd}`);
     }
     if (!assetPath) {
-        throw lastError ?? new Error(`Stash asset not found for ref: ${parsed.type}:${parsed.name}`);
+        throw lastError ?? new NotFoundError(`Stash asset not found for ref: ${parsed.type}:${parsed.name}`);
     }
     const source = findSourceForPath(assetPath, allSources);
     const sourceStashDir = source?.path ?? allStashDirs[0];

package/dist/stash-source.js

@@ -2,6 +2,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { resolveStashDir } from "./common";
 import { loadConfig } from "./config";
+import { warn } from "./warn";
 // ── Resolution ──────────────────────────────────────────────────────────────
 /**
  * Build the ordered list of stash sources (search paths):
@@ -12,15 +13,13 @@ import { loadConfig } from "./config";
  * The first entry is always the primary stash. Additional entries come
  * from `searchPaths` config and `registry.installed` entries.
  */
-export function resolveStashSources(overrideStashDir) {
+export function resolveStashSources(overrideStashDir, existingConfig) {
     const stashDir = overrideStashDir ?? resolveStashDir();
-    const config = loadConfig();
-    const sources = [
-        { path: stashDir },
-    ];
+    const config = existingConfig ?? loadConfig();
+    const sources = [{ path: stashDir }];
     for (const dir of config.searchPaths) {
         if (isSuspiciousStashRoot(dir)) {
-            console.warn(`Warning: stash root "${dir}" appears to be a system directory. This may be unintentional.`);
+            warn(`Warning: stash root "${dir}" appears to be a system directory. This may be unintentional.`);
         }
         if (isValidDirectory(dir)) {
             sources.push({ path: dir });
@@ -28,7 +27,7 @@ export function resolveStashSources(overrideStashDir) {
     }
     for (const entry of config.registry?.installed ?? []) {
         if (isSuspiciousStashRoot(entry.stashRoot)) {
-            console.warn(`Warning: stash root "${entry.stashRoot}" appears to be a system directory. This may be unintentional.`);
+            warn(`Warning: stash root "${entry.stashRoot}" appears to be a system directory. This may be unintentional.`);
         }
         if (isValidDirectory(entry.stashRoot)) {
             sources.push({
@@ -103,15 +102,15 @@ export function buildEditHint(filePath, assetType, assetName, origin) {
     return `This asset is managed by akm and may be overwritten on update. To edit, run: akm clone ${ref}`;
 }
 // ── Validation ──────────────────────────────────────────────────────────────
-const SUSPICIOUS_ROOTS = new Set(['/', '/etc', '/bin', '/sbin', '/usr', '/var', '/tmp', '/dev', '/proc', '/sys']);
+const SUSPICIOUS_ROOTS = new Set(["/", "/etc", "/bin", "/sbin", "/usr", "/var", "/tmp", "/dev", "/proc", "/sys"]);
 function isSuspiciousStashRoot(dir) {
     const resolved = path.resolve(dir);
-    const normalized = process.platform === 'win32' ? resolved.toLowerCase() : resolved;
+    const normalized = process.platform === "win32" ? resolved.toLowerCase() : resolved;
     if (SUSPICIOUS_ROOTS.has(normalized))
         return true;
-    if (process.platform === 'win32') {
+    if (process.platform === "win32") {
         // Check for Windows system directories
-        const winDir = (process.env.SystemRoot || 'C:\\Windows').toLowerCase();
+        const winDir = (process.env.SystemRoot || "C:\\Windows").toLowerCase();
         if (normalized === winDir || normalized.startsWith(winDir + path.sep))
             return true;
     }

package/dist/submit.js

@@ -4,7 +4,7 @@ import os from "node:os";
 import path from "node:path";
 import { createInterface } from "node:readline/promises";
 import { fetchWithRetry, isAssetType } from "./common";
-import { GITHUB_API_BASE, asRecord, asString, githubHeaders } from "./github";
+import { asRecord, asString, GITHUB_API_BASE, githubHeaders } from "./github";
 import { parseRegistryRef } from "./registry-resolve";
 const REGISTRY_OWNER = "itlackey";
 const REGISTRY_REPO = "agentikit-registry";
@@ -66,7 +66,9 @@ export async function agentikitSubmit(options = {}) {
     let forkCreated = false;
     try {
         progress("Forking and cloning agentikit-registry");
-        runCommand(runtime, "gh", ["repo", "fork", `${REGISTRY_OWNER}/${REGISTRY_REPO}`, "--clone", "--remote"], { cwd: tempRoot });
+        runCommand(runtime, "gh", ["repo", "fork", `${REGISTRY_OWNER}/${REGISTRY_REPO}`, "--clone", "--remote"], {
+            cwd: tempRoot,
+        });
         forkCreated = true;
         progress(`Creating branch ${branchName}`);
         runCommand(runtime, "git", ["checkout", "-b", branchName], { cwd: cloneDir });
@@ -112,20 +114,13 @@ export async function agentikitSubmit(options = {}) {
 export async function buildSubmitEntry(options) {
     const packageJson = options.packageJson;
     const interactive = options.interactive === true;
-    const defaultName = options.name?.trim()
-        || packageJson?.name
-        || inferNameFromParsedRef(options.parsed);
-    const defaultDescription = options.description?.trim()
-        || packageJson?.description;
+    const defaultName = options.name?.trim() || packageJson?.name || inferNameFromParsedRef(options.parsed);
+    const defaultDescription = options.description?.trim() || packageJson?.description;
     const defaultTags = normalizeTags(options.tags ?? packageJson?.keywords ?? []);
     const defaultAssetTypes = normalizeAssetTypes(options.assetTypes ?? packageJson?.agentikitAssetTypes ?? []);
-    const defaultAuthor = options.author?.trim()
-        || packageJson?.author;
-    const defaultLicense = options.license?.trim()
-        || packageJson?.license;
-    const defaultHomepage = options.homepage?.trim()
-        || packageJson?.homepage
-        || inferHomepage(options.parsed);
+    const defaultAuthor = options.author?.trim() || packageJson?.author;
+    const defaultLicense = options.license?.trim() || packageJson?.license;
+    const defaultHomepage = options.homepage?.trim() || packageJson?.homepage || inferHomepage(options.parsed);
     const rl = interactive ? createInterface({ input: process.stdin, output: process.stdout }) : undefined;
     try {
         const promptedName = await promptWithDefault("Name", defaultName, rl);
@@ -209,8 +204,7 @@ async function inferSubmitTargetFromDir(dir) {
     if (packageJson.name) {
         candidates.push(parseSubmitRef(packageJson.name));
     }
-    const githubRef = extractGithubRepoRef(packageJson.repositoryUrl)
-        ?? extractGithubRepoRef(packageJson.homepage);
+    const githubRef = extractGithubRepoRef(packageJson.repositoryUrl) ?? extractGithubRepoRef(packageJson.homepage);
     if (githubRef) {
         candidates.push(parseSubmitRef(githubRef));
     }
@@ -277,7 +271,9 @@ function inferNameFromParsedRef(parsed) {
 function canonicalSubmitRef(parsed) {
     if (parsed.source === "npm")
         return parsed.packageName;
-    return parsed.requestedRef ? `${parsed.owner}/${parsed.repo}#${parsed.requestedRef}` : `${parsed.owner}/${parsed.repo}`;
+    return parsed.requestedRef
+        ? `${parsed.owner}/${parsed.repo}#${parsed.requestedRef}`
+        : `${parsed.owner}/${parsed.repo}`;
 }
 function inferHomepage(parsed) {
     if (parsed.source === "npm") {
@@ -394,7 +390,7 @@ async function fetchRegistryManualEntries() {
     if (!entriesResponse.ok) {
         throw new Error(`Failed to load ${MANUAL_ENTRIES_FILE} from ${REGISTRY_OWNER}/${REGISTRY_REPO} (${entriesResponse.status}).`);
     }
-    const parsed = await entriesResponse.json();
+    const parsed = (await entriesResponse.json());
     if (!Array.isArray(parsed)) {
         throw new Error(`${MANUAL_ENTRIES_FILE} is not a JSON array.`);
     }
@@ -424,7 +420,10 @@ function readManualEntriesFile(filePath) {
 }
 function createPullRequest(options) {
     const output = runCommand(options.runtime, "gh", buildPullRequestArgs(options.entry, options.username, options.branchName, options.pullRequestBody), { cwd: options.cloneDir });
-    const url = output.stdout.trim().split(/\r?\n/).find((line) => /^https:\/\/github\.com\//.test(line));
+    const url = output.stdout
+        .trim()
+        .split(/\r?\n/)
+        .find((line) => /^https:\/\/github\.com\//.test(line));
     if (!url) {
         throw new Error("gh pr create did not return a pull request URL.");
     }
@@ -460,7 +459,10 @@ function buildPlannedCommands(options) {
         formatCommand(["git", "add", MANUAL_ENTRIES_FILE]),
         formatCommand(["git", "commit", "-m", `feat: add ${options.entry.name} to registry`]),
         formatCommand(["git", "push", "origin", options.branchName]),
-        formatCommand(["gh", ...buildPullRequestArgs(options.entry, options.username, options.branchName, options.pullRequestBody)]),
+        formatCommand([
+            "gh",
+            ...buildPullRequestArgs(options.entry, options.username, options.branchName, options.pullRequestBody),
+        ]),
     ];
     if (options.cleanupFork) {
         commands.push(`# After PR is merged: ${formatCommand(["gh", "repo", "delete", `${options.username}/${REGISTRY_REPO}`, "--yes"])}`);
@@ -512,7 +514,10 @@ function ensureGhAvailable(runtime) {
     }
 }
 function ensureGhAuthenticated(runtime) {
-    const result = spawnSync(runtime.ghBin, ["auth", "status", "--hostname", "github.com"], { encoding: "utf8", timeout: 10_000 });
+    const result = spawnSync(runtime.ghBin, ["auth", "status", "--hostname", "github.com"], {
+        encoding: "utf8",
+        timeout: 10_000,
+    });
     if (result.status !== 0) {
         throw new Error("gh CLI is not authenticated for github.com.");
     }

package/dist/tool-runner.js

@@ -88,11 +88,7 @@ export function shellQuote(input) {
             .replace(/"/g, '""');
         return `"${escaped}"`;
     }
-    const escaped = input
-        .replace(/\\/g, "\\\\")
-        .replace(/"/g, '\\"')
-        .replace(/\$/g, "\\$")
-        .replace(/`/g, "\\`");
+    const escaped = input.replace(/\\/g, "\\\\").replace(/"/g, '\\"').replace(/\$/g, "\\$").replace(/`/g, "\\`");
     return `"${escaped}"`;
 }
 /**

package/dist/warn.js

@@ -0,0 +1,20 @@
+/**
+ * Module-level quiet flag for suppressing stderr warnings.
+ * Controlled by the CLI --quiet / -q flag.
+ */
+let quiet = false;
+export function setQuiet(value) {
+    quiet = value;
+}
+export function isQuiet() {
+    return quiet;
+}
+/**
+ * Emit a warning to stderr unless --quiet is active.
+ * Drop-in replacement for console.warn() across the codebase.
+ */
+export function warn(...args) {
+    if (!quiet) {
+        console.warn(...args);
+    }
+}