agentikit 0.0.7 → 0.0.8

package/dist/src/ripgrep.js

@@ -1,262 +1,2 @@
-import { spawnSync } from "node:child_process";
-import fs from "node:fs";
-import path from "node:path";
-// ── ripgrep Resolution ──────────────────────────────────────────────────────
-const IS_WINDOWS = process.platform === "win32";
-const RG_BINARY = IS_WINDOWS ? "rg.exe" : "rg";
-function canExecute(filePath) {
-    if (!fs.existsSync(filePath))
-        return false;
-    if (IS_WINDOWS)
-        return true;
-    try {
-        fs.accessSync(filePath, fs.constants.X_OK);
-        return true;
-    }
-    catch {
-        return false;
-    }
-}
-function resolveFromPath() {
-    const rawPath = process.env.PATH;
-    if (!rawPath)
-        return null;
-    const pathEntries = rawPath.split(path.delimiter).filter(Boolean);
-    if (IS_WINDOWS) {
-        const pathext = (process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM")
-            .split(";")
-            .filter(Boolean)
-            .map((ext) => ext.toLowerCase());
-        for (const entry of pathEntries) {
-            const directCandidate = path.join(entry, "rg");
-            if (canExecute(directCandidate))
-                return directCandidate;
-            for (const ext of pathext) {
-                const candidate = path.join(entry, `rg${ext}`);
-                if (canExecute(candidate))
-                    return candidate;
-            }
-        }
-        return null;
-    }
-    for (const entry of pathEntries) {
-        const candidate = path.join(entry, "rg");
-        if (canExecute(candidate))
-            return candidate;
-    }
-    return null;
-}
-/**
- * Resolve the path to a usable ripgrep binary.
- * Checks in order:
- *   1. stashDir/bin/rg
- *   2. system PATH (rg)
- * Returns null if ripgrep is not available.
- */
-export function resolveRg(stashDir) {
-    // Check stash bin directory first
-    if (stashDir) {
-        const stashRg = path.join(stashDir, "bin", RG_BINARY);
-        if (canExecute(stashRg))
-            return stashRg;
-    }
-    return resolveFromPath();
-}
-/**
- * Check if ripgrep is available (either in stash/bin or system PATH).
- */
-export function isRgAvailable(stashDir) {
-    return resolveRg(stashDir) !== null;
-}
-/**
- * Use ripgrep to find .stash.json files that match query tokens.
- * Returns paths to matching .stash.json files.
- *
- * If ripgrep is not available or the query is empty, returns null
- * to signal that the caller should skip pre-filtering.
- */
-export function rgFilterCandidates(query, searchDir, stashDir) {
-    if (!query.trim())
-        return null;
-    const rgPath = resolveRg(stashDir);
-    if (!rgPath)
-        return null;
-    // Tokenize the query into an OR pattern for ripgrep
-    const tokens = query
-        .toLowerCase()
-        .replace(/[^a-z0-9\s]/g, " ")
-        .split(/\s+/)
-        .filter((t) => t.length > 1);
-    if (tokens.length === 0)
-        return null;
-    const pattern = tokens.join("|");
-    const result = spawnSync(rgPath, [
-        "-i", // case insensitive
-        "-l", // files-with-matches only
-        "--hidden", // include hidden files such as .stash.json
-        "--no-ignore", // include ignored files to ensure metadata is searchable
-        "--glob", ".stash.json", // only search .stash.json files
-        pattern,
-        searchDir,
-    ], {
-        encoding: "utf8",
-        timeout: 10_000,
-    });
-    if (result.status !== 0 && result.status !== 1) {
-        // rg exit code 1 = no matches (normal), anything else = error
-        return null;
-    }
-    const files = (result.stdout || "")
-        .trim()
-        .split(/\r?\n/)
-        .filter((f) => f.length > 0);
-    return { matchedFiles: files, usedRg: true };
-}
-// ── ripgrep Installation ────────────────────────────────────────────────────
-/**
- * Platform and architecture detection for ripgrep binary downloads.
- */
-function getRgPlatformTarget() {
-    const platform = process.platform;
-    const arch = process.arch;
-    if (platform === "linux" && arch === "x64") {
-        return { platform: "x86_64-unknown-linux-musl", arch: "x64", ext: ".tar.gz" };
-    }
-    if (platform === "linux" && arch === "arm64") {
-        return { platform: "aarch64-unknown-linux-gnu", arch: "arm64", ext: ".tar.gz" };
-    }
-    if (platform === "darwin" && arch === "x64") {
-        return { platform: "x86_64-apple-darwin", arch: "x64", ext: ".tar.gz" };
-    }
-    if (platform === "darwin" && arch === "arm64") {
-        return { platform: "aarch64-apple-darwin", arch: "arm64", ext: ".tar.gz" };
-    }
-    if (platform === "win32" && arch === "x64") {
-        return { platform: "x86_64-pc-windows-msvc", arch: "x64", ext: ".zip" };
-    }
-    return null;
-}
-const RG_VERSION = "14.1.1";
-/**
- * Ensure ripgrep is available. If not found on PATH or in stash/bin,
- * download and install it to stash/bin.
- *
- * Returns the path to the ripgrep binary and whether it was newly installed.
- */
-export function ensureRg(stashDir) {
-    // Already available?
-    const existing = resolveRg(stashDir);
-    if (existing) {
-        return { rgPath: existing, installed: false, version: getRgVersion(existing) };
-    }
-    // Determine platform
-    const target = getRgPlatformTarget();
-    if (!target) {
-        throw new Error(`Unsupported platform for ripgrep auto-install: ${process.platform}/${process.arch}. ` +
-            `Install ripgrep manually: https://github.com/BurntSushi/ripgrep#installation`);
-    }
-    const binDir = path.join(stashDir, "bin");
-    if (!fs.existsSync(binDir)) {
-        fs.mkdirSync(binDir, { recursive: true });
-    }
-    const archiveName = `ripgrep-${RG_VERSION}-${target.platform}`;
-    const url = `https://github.com/BurntSushi/ripgrep/releases/download/${RG_VERSION}/${archiveName}${target.ext}`;
-    const destBinary = path.join(binDir, RG_BINARY);
-    if (target.ext === ".tar.gz") {
-        downloadAndExtractTarGz(url, archiveName, destBinary);
-    }
-    else {
-        downloadAndExtractZip(url, archiveName, destBinary);
-    }
-    // Make executable
-    if (!IS_WINDOWS) {
-        fs.chmodSync(destBinary, 0o755);
-    }
-    return { rgPath: destBinary, installed: true, version: RG_VERSION };
-}
-function downloadAndExtractTarGz(url, archiveName, destBinary) {
-    const destDir = path.dirname(destBinary);
-    const tmpTarGz = path.join(destDir, "rg-download.tar.gz");
-    try {
-        // Download archive to a temporary file without using a shell
-        const curlResult = spawnSync("curl", ["-fsSL", "-o", tmpTarGz, url], {
-            encoding: "utf8",
-            timeout: 60_000,
-        });
-        if (curlResult.status !== 0) {
-            const err = curlResult.stderr?.trim() || curlResult.error?.message || "unknown error";
-            throw new Error(`Failed to download ripgrep from ${url}: ${err}`);
-        }
-        // Extract the specific binary from the archive into destDir
-        const tarResult = spawnSync("tar", [
-            "xzf",
-            tmpTarGz,
-            "--strip-components=1",
-            "-C",
-            destDir,
-            `${archiveName}/rg`,
-        ], {
-            encoding: "utf8",
-            timeout: 60_000,
-        });
-        if (tarResult.status !== 0) {
-            const err = tarResult.stderr?.trim() || tarResult.error?.message || "unknown error";
-            throw new Error(`Failed to extract ripgrep from ${url}: ${err}`);
-        }
-        if (!fs.existsSync(destBinary)) {
-            throw new Error(`ripgrep binary not found at ${destBinary} after extraction`);
-        }
-    }
-    finally {
-        // Best-effort cleanup of temporary archive
-        try {
-            if (fs.existsSync(tmpTarGz)) {
-                fs.unlinkSync(tmpTarGz);
-            }
-        }
-        catch {
-            // ignore cleanup errors
-        }
-    }
-}
-function downloadAndExtractZip(url, archiveName, destBinary) {
-    const destDir = path.dirname(destBinary);
-    const tmpZip = path.join(destDir, "rg-download.zip");
-    const expandedDir = path.join(destDir, archiveName);
-    try {
-        // Download
-        const dlResult = spawnSync("curl", ["-fsSL", "-o", tmpZip, url], {
-            encoding: "utf8",
-            timeout: 60_000,
-        });
-        if (dlResult.status !== 0) {
-            throw new Error(dlResult.stderr?.trim() || "download failed");
-        }
-        // Extract just the rg.exe
-        const extractResult = spawnSync("powershell", [
-            "-Command",
-            `Expand-Archive -Path "${tmpZip}" -DestinationPath "${destDir}" -Force; ` +
-                `Move-Item -Force "${path.join(destDir, archiveName, "rg.exe")}" "${destBinary}"`,
-        ], {
-            encoding: "utf8",
-            timeout: 60_000,
-        });
-        if (extractResult.status !== 0) {
-            throw new Error(extractResult.stderr?.trim() || "extraction failed");
-        }
-    }
-    finally {
-        if (fs.existsSync(tmpZip))
-            fs.unlinkSync(tmpZip);
-        if (fs.existsSync(expandedDir))
-            fs.rmSync(expandedDir, { recursive: true, force: true });
-    }
-}
-function getRgVersion(rgPath) {
-    const result = spawnSync(rgPath, ["--version"], { encoding: "utf8", timeout: 5_000 });
-    if (result.status === 0 && result.stdout) {
-        const match = result.stdout.match(/ripgrep\s+([\d.]+)/);
-        return match ? match[1] : "unknown";
-    }
-    return "unknown";
-}
+export { resolveRg, isRgAvailable } from "./ripgrep-resolve";
+export { ensureRg } from "./ripgrep-install";

package/dist/src/similarity.d.ts

@@ -14,7 +14,7 @@ export interface SearchAdapter {
     buildIndex(entries: ScoredEntry[]): void;
     search(query: string, limit: number, typeFilter?: string): ScoredResult[];
 }
-interface SerializedTfIdf {
+export interface SerializedTfIdf {
     idf: Record<string, number>;
     docs: Array<{
         id: string;
@@ -32,4 +32,3 @@ export declare class TfIdfAdapter implements SearchAdapter {
     static deserialize(data: SerializedTfIdf, entries: ScoredEntry[]): TfIdfAdapter;
     private substringFallback;
 }
-export {};

package/dist/src/similarity.js

@@ -94,6 +94,17 @@ export class TfIdfAdapter {
                     score += 0.15;
                 }
             }
+            // Boost: intent phrase contains query token
+            const intents = doc.entry.entry.intents || [];
+            for (const intent of intents) {
+                const intentLower = intent.toLowerCase();
+                for (const token of queryTokens) {
+                    if (intentLower.includes(token)) {
+                        score += 0.12;
+                        break; // one boost per intent phrase
+                    }
+                }
+            }
             // Boost: name contains query token
             const nameLower = doc.entry.entry.name.toLowerCase().replace(/[-_]/g, " ");
             for (const token of queryTokens) {

package/dist/src/stash-ref.d.ts

@@ -0,0 +1,7 @@
+import { type AgentikitAssetType } from "./common";
+export interface OpenRef {
+    type: AgentikitAssetType;
+    name: string;
+}
+export declare function parseOpenRef(ref: string): OpenRef;
+export declare function makeOpenRef(type: AgentikitAssetType, name: string): string;

package/dist/src/stash-ref.js

@@ -0,0 +1,33 @@
+import path from "node:path";
+import { isAssetType } from "./common";
+export function parseOpenRef(ref) {
+    const separator = ref.indexOf(":");
+    if (separator <= 0) {
+        throw new Error("Invalid open ref. Expected format '<type>:<name>'.");
+    }
+    const rawType = ref.slice(0, separator);
+    const rawName = ref.slice(separator + 1);
+    if (!isAssetType(rawType)) {
+        throw new Error(`Invalid open ref type: "${rawType}".`);
+    }
+    let name;
+    try {
+        name = decodeURIComponent(rawName);
+    }
+    catch {
+        throw new Error("Invalid open ref encoding.");
+    }
+    const normalized = path.posix.normalize(name.replace(/\\/g, "/"));
+    if (!name
+        || name.includes("\0")
+        || /^[A-Za-z]:/.test(name)
+        || path.posix.isAbsolute(normalized)
+        || normalized === ".."
+        || normalized.startsWith("../")) {
+        throw new Error("Invalid open ref name.");
+    }
+    return { type: rawType, name: normalized };
+}
+export function makeOpenRef(type, name) {
+    return `${type}:${encodeURIComponent(name)}`;
+}

package/dist/src/stash-resolve.d.ts

@@ -0,0 +1,2 @@
+import { type AgentikitAssetType } from "./common";
+export declare function resolveAssetPath(stashDir: string, type: AgentikitAssetType, name: string): string;

package/dist/src/stash-resolve.js

@@ -0,0 +1,45 @@
+import fs from "node:fs";
+import path from "node:path";
+import { hasErrnoCode, isWithin } from "./common";
+import { TYPE_DIRS, isRelevantAssetFile, resolveAssetPathFromName } from "./asset-spec";
+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.");
+    }
+    if (!fs.existsSync(resolvedTarget) || !fs.statSync(resolvedTarget).isFile()) {
+        throw new Error(`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.");
+    }
+    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 Error(`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}`);
+    }
+    return fs.realpathSync(root);
+}
+function readTypeRootStat(root, type, name) {
+    try {
+        return fs.statSync(root);
+    }
+    catch (error) {
+        if (hasErrnoCode(error, "ENOENT")) {
+            throw new Error(`Stash type root not found for ref: ${type}:${name}`);
+        }
+        throw error;
+    }
+}

package/dist/src/stash-search.d.ts

@@ -0,0 +1,6 @@
+import type { AgentikitSearchType, SearchResponse } from "./stash-types";
+export declare function agentikitSearch(input: {
+    query: string;
+    type?: AgentikitSearchType;
+    limit?: number;
+}): Promise<SearchResponse>;

package/dist/src/stash-search.js

@@ -0,0 +1,269 @@
+import fs from "node:fs";
+import path from "node:path";
+import { hasErrnoCode, resolveStashDir } from "./common";
+import { ASSET_TYPES, TYPE_DIRS, deriveCanonicalAssetName } from "./asset-spec";
+import { loadSearchIndex, buildSearchText } from "./indexer";
+import { TfIdfAdapter } from "./similarity";
+import { buildToolInfo } from "./tool-runner";
+import { walkStash } from "./walker";
+import { makeOpenRef } from "./stash-ref";
+import { loadConfig } from "./config";
+const DEFAULT_LIMIT = 20;
+export async function agentikitSearch(input) {
+    const t0 = Date.now();
+    const query = input.query.trim().toLowerCase();
+    const searchType = input.type ?? "any";
+    const limit = normalizeLimit(input.limit);
+    const stashDir = resolveStashDir();
+    const config = loadConfig(stashDir);
+    const allStashDirs = [
+        stashDir,
+        ...config.additionalStashDirs.filter((d) => {
+            try {
+                return fs.statSync(d).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        }),
+    ];
+    // Try indexed search (single unified pipeline: embedding + TF-IDF as weighted features)
+    const index = loadSearchIndex();
+    if (index && index.entries && index.entries.length > 0 && index.stashDir === stashDir) {
+        const { hits, embedMs, rankMs } = await searchIndex(index, query, searchType, limit, stashDir, allStashDirs, config);
+        return {
+            stashDir,
+            hits,
+            tip: hits.length === 0 ? "No matching stash assets were found. Try running 'akm index' to rebuild." : undefined,
+            timing: { totalMs: Date.now() - t0, rankMs, embedMs },
+        };
+    }
+    // No index: fall back to filesystem walk + substring match across all stash dirs
+    const hits = allStashDirs
+        .flatMap((dir) => substringSearch(query, searchType, limit, dir))
+        .slice(0, limit);
+    return {
+        stashDir,
+        hits,
+        tip: hits.length === 0 ? "No matching stash assets were found. Try running 'akm index' to rebuild." : undefined,
+        timing: { totalMs: Date.now() - t0 },
+    };
+}
+// ── Unified indexed search ──────────────────────────────────────────────────
+async function searchIndex(index, query, searchType, limit, stashDir, allStashDirs, config) {
+    // Filter candidates by type
+    let candidates = index.entries;
+    if (searchType !== "any") {
+        candidates = candidates.filter((ie) => ie.entry.type === searchType);
+    }
+    if (candidates.length === 0)
+        return { hits: [] };
+    // Empty query: return all entries (no scoring needed)
+    if (!query) {
+        return { hits: candidates.slice(0, limit).map((ie) => buildIndexedHit({ entry: ie.entry, path: ie.path, score: 1, query, rankingMode: "tfidf", defaultStashDir: stashDir, allStashDirs })) };
+    }
+    // Score each candidate using available signals
+    const tEmbed0 = Date.now();
+    const embeddingScores = await tryEmbeddingScores(candidates, query, config);
+    const embedMs = Date.now() - tEmbed0;
+    const tRank0 = Date.now();
+    const tfidfScores = computeTfidfScores(index, candidates, query, searchType);
+    const scored = [];
+    for (const ie of candidates) {
+        const key = ie.path;
+        const embScore = embeddingScores?.get(key);
+        const tfidfScore = tfidfScores.get(key) ?? 0;
+        if (embScore !== undefined) {
+            // Weighted blend: embedding dominates when available, TF-IDF boosts lexical matches
+            const blended = embScore * 0.7 + tfidfScore * 0.3;
+            if (blended > 0)
+                scored.push({ ie, score: blended, rankingMode: "semantic" });
+        }
+        else if (tfidfScore > 0) {
+            scored.push({ ie, score: tfidfScore, rankingMode: "tfidf" });
+        }
+    }
+    scored.sort((a, b) => b.score - a.score);
+    const rankMs = Date.now() - tRank0;
+    return { embedMs, rankMs, hits: scored.slice(0, limit).map(({ ie, score, rankingMode }) => buildIndexedHit({
+            entry: ie.entry,
+            path: ie.path,
+            score: Math.round(score * 1000) / 1000,
+            query,
+            rankingMode,
+            defaultStashDir: stashDir,
+            allStashDirs,
+        })) };
+}
+// ── Embedding scorer ────────────────────────────────────────────────────────
+async function tryEmbeddingScores(candidates, query, config) {
+    if (!config.semanticSearch)
+        return null;
+    const withEmbeddings = candidates.filter((ie) => ie.embedding && ie.embedding.length > 0);
+    if (withEmbeddings.length === 0)
+        return null;
+    try {
+        const { embed, cosineSimilarity } = await import("./embedder.js");
+        const queryEmbedding = await embed(query, config.embedding);
+        const scores = new Map();
+        for (const ie of withEmbeddings) {
+            scores.set(ie.path, cosineSimilarity(queryEmbedding, ie.embedding));
+        }
+        return scores;
+    }
+    catch {
+        return null;
+    }
+}
+// ── TF-IDF scorer ───────────────────────────────────────────────────────────
+function computeTfidfScores(index, candidates, query, searchType) {
+    const candidateScoredEntries = toScoredEntries(candidates);
+    let adapter;
+    if (index.tfidf) {
+        const allScored = toScoredEntries(index.entries);
+        adapter = TfIdfAdapter.deserialize(index.tfidf, allScored);
+    }
+    else {
+        adapter = new TfIdfAdapter();
+        adapter.buildIndex(candidateScoredEntries);
+    }
+    const typeFilter = searchType === "any" ? undefined : searchType;
+    const results = adapter.search(query, candidates.length, typeFilter);
+    const scores = new Map();
+    for (const r of results) {
+        scores.set(r.path, r.score);
+    }
+    return scores;
+}
+// ── Substring fallback (no index) ───────────────────────────────────────────
+function substringSearch(query, searchType, limit, stashDir) {
+    const assets = indexAssets(stashDir, searchType);
+    return assets
+        .filter((asset) => asset.name.toLowerCase().includes(query))
+        .sort(compareAssets)
+        .slice(0, limit)
+        .map((asset) => assetToSearchHit(asset, stashDir));
+}
+// ── Hit building ────────────────────────────────────────────────────────────
+function findStashDirForPath(filePath, stashDirs) {
+    const resolved = path.resolve(filePath);
+    for (const dir of stashDirs) {
+        if (resolved.startsWith(path.resolve(dir) + path.sep))
+            return dir;
+    }
+    return undefined;
+}
+function buildIndexedHit(input) {
+    const entryStashDir = findStashDirForPath(input.path, input.allStashDirs) ?? 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 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 + qualityBoost + confidenceBoost) * 1000) / 1000;
+    const whyMatched = buildWhyMatched(input.entry, input.query, input.rankingMode, qualityBoost, confidenceBoost);
+    const hit = {
+        type: input.entry.type,
+        name: input.entry.name,
+        path: input.path,
+        openRef: makeOpenRef(input.entry.type, openRefName),
+        description: input.entry.description,
+        tags: input.entry.tags,
+        score,
+        whyMatched,
+    };
+    if (input.entry.type === "tool") {
+        try {
+            const toolInfo = buildToolInfo(entryStashDir, input.path);
+            hit.runCmd = toolInfo.runCmd;
+            hit.kind = toolInfo.kind;
+        }
+        catch (error) {
+            if (!hasErrnoCode(error, "ENOENT"))
+                throw error;
+        }
+    }
+    return hit;
+}
+function buildWhyMatched(entry, query, rankingMode, qualityBoost, confidenceBoost) {
+    const reasons = [rankingMode === "semantic" ? "semantic similarity" : "tf-idf lexical relevance"];
+    const tokens = query.toLowerCase().split(/\s+/).filter(Boolean);
+    const name = entry.name.toLowerCase();
+    const tags = entry.tags?.join(" ").toLowerCase() ?? "";
+    const intents = entry.intents?.join(" ").toLowerCase() ?? "";
+    const aliases = entry.aliases?.join(" ").toLowerCase() ?? "";
+    if (tokens.some((t) => name.includes(t)))
+        reasons.push("matched name tokens");
+    if (tokens.some((t) => tags.includes(t)))
+        reasons.push("matched tags");
+    if (tokens.some((t) => intents.includes(t)))
+        reasons.push("matched intents");
+    if (tokens.some((t) => aliases.includes(t)))
+        reasons.push("matched aliases");
+    if (qualityBoost > 0)
+        reasons.push("curated metadata boost");
+    if (confidenceBoost > 0)
+        reasons.push("metadata confidence boost");
+    return reasons;
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function toScoredEntries(entries) {
+    return entries.map((ie) => ({
+        id: `${ie.entry.type}:${ie.entry.name}`,
+        text: buildSearchText(ie.entry),
+        entry: ie.entry,
+        path: ie.path,
+    }));
+}
+function assetToSearchHit(asset, stashDir) {
+    if (asset.type !== "tool") {
+        return {
+            type: asset.type,
+            name: asset.name,
+            path: asset.path,
+            openRef: makeOpenRef(asset.type, asset.name),
+        };
+    }
+    const toolInfo = buildToolInfo(stashDir, asset.path);
+    return {
+        type: "tool",
+        name: asset.name,
+        path: asset.path,
+        openRef: makeOpenRef("tool", asset.name),
+        runCmd: toolInfo.runCmd,
+        kind: toolInfo.kind,
+    };
+}
+function normalizeLimit(limit) {
+    if (typeof limit !== "number" || Number.isNaN(limit) || limit <= 0) {
+        return DEFAULT_LIMIT;
+    }
+    return Math.min(Math.floor(limit), 200);
+}
+function fileToAsset(assetType, root, file) {
+    const name = deriveCanonicalAssetName(assetType, root, file);
+    if (!name)
+        return undefined;
+    return { type: assetType, name, path: file };
+}
+function indexAssets(stashDir, type) {
+    const assets = [];
+    const types = type === "any" ? ASSET_TYPES : [type];
+    for (const assetType of types) {
+        const root = path.join(stashDir, TYPE_DIRS[assetType]);
+        const groups = walkStash(root, assetType);
+        for (const { files } of groups) {
+            for (const file of files) {
+                const asset = fileToAsset(assetType, root, file);
+                if (asset)
+                    assets.push(asset);
+            }
+        }
+    }
+    return assets;
+}
+function compareAssets(a, b) {
+    if (a.type !== b.type)
+        return a.type.localeCompare(b.type);
+    return a.name.localeCompare(b.name);
+}

package/dist/src/stash-show.d.ts

@@ -0,0 +1,5 @@
+import type { KnowledgeView, ShowResponse } from "./stash-types";
+export declare function agentikitShow(input: {
+    ref: string;
+    view?: KnowledgeView;
+}): ShowResponse;