agentikit 0.0.7 → 0.0.8

package/dist/src/stash-show.js

@@ -0,0 +1,107 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parseFrontmatter, toStringOrUndefined } from "./frontmatter";
+import { resolveStashDir } from "./common";
+import { parseOpenRef } from "./stash-ref";
+import { resolveAssetPath } from "./stash-resolve";
+import { parseMarkdownToc, extractSection, extractLineRange, extractFrontmatterOnly, formatToc } from "./markdown";
+import { buildToolInfo } from "./tool-runner";
+import { loadConfig } from "./config";
+export function agentikitShow(input) {
+    const parsed = parseOpenRef(input.ref);
+    const stashDir = resolveStashDir();
+    const config = loadConfig(stashDir);
+    const allStashDirs = [
+        stashDir,
+        ...config.additionalStashDirs.filter((d) => {
+            try {
+                return fs.statSync(d).isDirectory();
+            }
+            catch {
+                return false;
+            }
+        }),
+    ];
+    let assetPath;
+    let lastError;
+    for (const dir of allStashDirs) {
+        try {
+            assetPath = resolveAssetPath(dir, parsed.type, parsed.name);
+            break;
+        }
+        catch (err) {
+            lastError = err instanceof Error ? err : new Error(String(err));
+        }
+    }
+    if (!assetPath) {
+        throw lastError ?? new Error(`Stash asset not found for ref: ${parsed.type}:${parsed.name}`);
+    }
+    const content = fs.readFileSync(assetPath, "utf8");
+    switch (parsed.type) {
+        case "skill":
+            return {
+                type: "skill",
+                name: parsed.name,
+                path: assetPath,
+                content,
+            };
+        case "command": {
+            const parsedMd = parseFrontmatter(content);
+            return {
+                type: "command",
+                name: parsed.name,
+                path: assetPath,
+                description: toStringOrUndefined(parsedMd.data.description),
+                template: parsedMd.content,
+            };
+        }
+        case "agent": {
+            const parsedMd = parseFrontmatter(content);
+            return {
+                type: "agent",
+                name: parsed.name,
+                path: assetPath,
+                description: toStringOrUndefined(parsedMd.data.description),
+                prompt: parsedMd.content,
+                toolPolicy: parsedMd.data.tools,
+                modelHint: parsedMd.data.model,
+            };
+        }
+        case "tool": {
+            const assetStashDir = allStashDirs.find((d) => path.resolve(assetPath).startsWith(path.resolve(d) + path.sep)) ?? stashDir;
+            const toolInfo = buildToolInfo(assetStashDir, assetPath);
+            return {
+                type: "tool",
+                name: parsed.name,
+                path: assetPath,
+                runCmd: toolInfo.runCmd,
+                kind: toolInfo.kind,
+            };
+        }
+        case "knowledge": {
+            const v = input.view ?? { mode: "full" };
+            switch (v.mode) {
+                case "toc": {
+                    const toc = parseMarkdownToc(content);
+                    return { type: "knowledge", name: parsed.name, path: assetPath, content: formatToc(toc) };
+                }
+                case "frontmatter": {
+                    const fm = extractFrontmatterOnly(content);
+                    return { type: "knowledge", name: parsed.name, path: assetPath, content: fm ?? "(no frontmatter)" };
+                }
+                case "section": {
+                    const section = extractSection(content, v.heading);
+                    if (!section)
+                        throw new Error(`Section "${v.heading}" not found in ${parsed.name}`);
+                    return { type: "knowledge", name: parsed.name, path: assetPath, content: section.content };
+                }
+                case "lines": {
+                    return { type: "knowledge", name: parsed.name, path: assetPath, content: extractLineRange(content, v.start, v.end) };
+                }
+                default: {
+                    return { type: "knowledge", name: parsed.name, path: assetPath, content };
+                }
+            }
+        }
+    }
+}

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

@@ -0,0 +1,53 @@
+import type { AgentikitAssetType } from "./common";
+import type { ToolKind } from "./tool-runner";
+export type AgentikitSearchType = AgentikitAssetType | "any";
+export interface SearchHit {
+    type: AgentikitAssetType;
+    name: string;
+    path: string;
+    openRef: string;
+    description?: string;
+    tags?: string[];
+    score?: number;
+    whyMatched?: string[];
+    runCmd?: string;
+    kind?: ToolKind;
+}
+export interface SearchResponse {
+    stashDir: string;
+    hits: SearchHit[];
+    tip?: string;
+    /** Timing counters in milliseconds */
+    timing?: {
+        totalMs: number;
+        rankMs?: number;
+        embedMs?: number;
+    };
+}
+export interface ShowResponse {
+    type: AgentikitAssetType;
+    name: string;
+    path: string;
+    content?: string;
+    template?: string;
+    prompt?: string;
+    description?: string;
+    toolPolicy?: unknown;
+    modelHint?: unknown;
+    runCmd?: string;
+    kind?: ToolKind;
+}
+export type KnowledgeView = {
+    mode: "full";
+} | {
+    mode: "toc";
+} | {
+    mode: "frontmatter";
+} | {
+    mode: "section";
+    heading: string;
+} | {
+    mode: "lines";
+    start: number;
+    end: number;
+};

package/dist/src/stash-types.js

@@ -0,0 +1 @@
+export {};

package/dist/src/stash.d.ts

@@ -1,63 +1,8 @@
-export type AgentikitAssetType = "tool" | "skill" | "command" | "agent";
-export type AgentikitSearchType = AgentikitAssetType | "any";
-export interface SearchHit {
-    type: AgentikitAssetType;
-    name: string;
-    path: string;
-    openRef: string;
-    summary?: string;
-    description?: string;
-    tags?: string[];
-    score?: number;
-    runCmd?: string;
-    kind?: "bash" | "bun" | "powershell" | "cmd";
-}
-export interface SearchResponse {
-    stashDir: string;
-    hits: SearchHit[];
-    tip?: string;
-}
-export interface OpenResponse {
-    type: AgentikitAssetType;
-    name: string;
-    path: string;
-    content?: string;
-    template?: string;
-    prompt?: string;
-    description?: string;
-    toolPolicy?: unknown;
-    modelHint?: unknown;
-    runCmd?: string;
-    kind?: "bash" | "bun" | "powershell" | "cmd";
-}
-export interface RunResponse {
-    type: "tool";
-    name: string;
-    path: string;
-    output: string;
-    exitCode: number;
-}
-export declare function resolveStashDir(): string;
-export declare function agentikitSearch(input: {
-    query: string;
-    type?: AgentikitSearchType;
-    limit?: number;
-}): SearchResponse;
-export declare function agentikitOpen(input: {
-    ref: string;
-}): OpenResponse;
-export declare function agentikitRun(input: {
-    ref: string;
-}): RunResponse;
-export interface InitResponse {
-    stashDir: string;
-    created: boolean;
-    envSet: boolean;
-    profileUpdated?: string;
-    ripgrep?: {
-        rgPath: string;
-        installed: boolean;
-        version: string;
-    };
-}
-export declare function agentikitInit(): InitResponse;
+export type { AgentikitAssetType } from "./common";
+export { resolveStashDir } from "./common";
+export { agentikitInit } from "./init";
+export type { InitResponse } from "./init";
+export type { ToolKind } from "./tool-runner";
+export { agentikitSearch } from "./stash-search";
+export { agentikitShow } from "./stash-show";
+export type { AgentikitSearchType, SearchHit, SearchResponse, ShowResponse, KnowledgeView, } from "./stash-types";