agentikit 0.0.9 → 0.0.13

package/dist/src/handlers/command-handler.js

@@ -0,0 +1,23 @@
+import { parseFrontmatter, toStringOrUndefined } from "../frontmatter";
+import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers";
+export const commandHandler = {
+    typeName: "command",
+    stashDir: "commands",
+    isRelevantFile: isMarkdownFile,
+    toCanonicalName: markdownCanonicalName,
+    toAssetPath: markdownAssetPath,
+    buildShowResponse(input) {
+        const parsedMd = parseFrontmatter(input.content);
+        return {
+            type: "command",
+            name: input.name,
+            path: input.path,
+            description: toStringOrUndefined(parsedMd.data.description),
+            template: parsedMd.content,
+        };
+    },
+    defaultUsageGuide: [
+        "Read the .md file, fill placeholders, and run it in the current repo context.",
+        "Use `akm show <openRef>` to retrieve the command template body.",
+    ],
+};

package/dist/src/handlers/index.d.ts

@@ -0,0 +1,6 @@
+export { toolHandler } from "./tool-handler";
+export { skillHandler } from "./skill-handler";
+export { commandHandler } from "./command-handler";
+export { agentHandler } from "./agent-handler";
+export { knowledgeHandler } from "./knowledge-handler";
+export { scriptHandler } from "./script-handler";

package/dist/src/handlers/index.js

@@ -0,0 +1,23 @@
+import { registerAssetType } from "../asset-type-handler";
+import { toolHandler } from "./tool-handler";
+import { skillHandler } from "./skill-handler";
+import { commandHandler } from "./command-handler";
+import { agentHandler } from "./agent-handler";
+import { knowledgeHandler } from "./knowledge-handler";
+import { scriptHandler } from "./script-handler";
+/**
+ * Register all built-in asset type handlers.
+ * This must be called (imported) before any handler lookups.
+ */
+registerAssetType(toolHandler);
+registerAssetType(skillHandler);
+registerAssetType(commandHandler);
+registerAssetType(agentHandler);
+registerAssetType(knowledgeHandler);
+registerAssetType(scriptHandler);
+export { toolHandler } from "./tool-handler";
+export { skillHandler } from "./skill-handler";
+export { commandHandler } from "./command-handler";
+export { agentHandler } from "./agent-handler";
+export { knowledgeHandler } from "./knowledge-handler";
+export { scriptHandler } from "./script-handler";

package/dist/src/handlers/knowledge-handler.d.ts

@@ -0,0 +1,2 @@
+import type { AssetTypeHandler } from "../asset-type-handler";
+export declare const knowledgeHandler: AssetTypeHandler;

package/dist/src/handlers/knowledge-handler.js

@@ -0,0 +1,56 @@
+import fs from "node:fs";
+import { parseMarkdownToc, extractSection, extractLineRange, extractFrontmatterOnly, formatToc } from "../markdown";
+import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers";
+export const knowledgeHandler = {
+    typeName: "knowledge",
+    stashDir: "knowledge",
+    isRelevantFile: isMarkdownFile,
+    toCanonicalName: markdownCanonicalName,
+    toAssetPath: markdownAssetPath,
+    buildShowResponse(input) {
+        const v = input.view ?? { mode: "full" };
+        switch (v.mode) {
+            case "toc": {
+                const toc = parseMarkdownToc(input.content);
+                return { type: "knowledge", name: input.name, path: input.path, content: formatToc(toc) };
+            }
+            case "frontmatter": {
+                const fm = extractFrontmatterOnly(input.content);
+                return { type: "knowledge", name: input.name, path: input.path, content: fm ?? "(no frontmatter)" };
+            }
+            case "section": {
+                const section = extractSection(input.content, v.heading);
+                if (!section) {
+                    return {
+                        type: "knowledge",
+                        name: input.name,
+                        path: input.path,
+                        content: `Section "${v.heading}" not found in ${input.name}. Try --view toc to discover available headings.`,
+                    };
+                }
+                return { type: "knowledge", name: input.name, path: input.path, content: section.content };
+            }
+            case "lines": {
+                return { type: "knowledge", name: input.name, path: input.path, content: extractLineRange(input.content, v.start, v.end) };
+            }
+            default: {
+                return { type: "knowledge", name: input.name, path: input.path, content: input.content };
+            }
+        }
+    },
+    defaultUsageGuide: [
+        "Use `akm show <openRef>` to read the document; start with `--view toc` for large files.",
+        "Use `--view section` or `--view lines` to load only the part you need.",
+    ],
+    extractTypeMetadata(entry, file) {
+        try {
+            const mdContent = fs.readFileSync(file, "utf8");
+            const toc = parseMarkdownToc(mdContent);
+            if (toc.headings.length > 0)
+                entry.toc = toc.headings;
+        }
+        catch {
+            // Non-fatal: skip TOC if file can't be read
+        }
+    },
+};

package/dist/src/handlers/markdown-helpers.d.ts

@@ -0,0 +1,7 @@
+/**
+ * Shared file-system helpers for markdown-based asset types
+ * (command, agent, knowledge).
+ */
+export declare function isMarkdownFile(fileName: string): boolean;
+export declare function markdownCanonicalName(typeRoot: string, filePath: string): string | undefined;
+export declare function markdownAssetPath(typeRoot: string, name: string): string;

package/dist/src/handlers/markdown-helpers.js

@@ -0,0 +1,15 @@
+import path from "node:path";
+import { toPosix } from "../common";
+/**
+ * Shared file-system helpers for markdown-based asset types
+ * (command, agent, knowledge).
+ */
+export function isMarkdownFile(fileName) {
+    return path.extname(fileName).toLowerCase() === ".md";
+}
+export function markdownCanonicalName(typeRoot, filePath) {
+    return toPosix(path.relative(typeRoot, filePath));
+}
+export function markdownAssetPath(typeRoot, name) {
+    return path.join(typeRoot, name);
+}

package/dist/src/handlers/script-handler.d.ts

@@ -0,0 +1,2 @@
+import type { AssetTypeHandler } from "../asset-type-handler";
+export declare const scriptHandler: AssetTypeHandler;

package/dist/src/handlers/script-handler.js

@@ -0,0 +1,78 @@
+import path from "node:path";
+import { SCRIPT_EXTENSIONS, SCRIPT_EXTENSIONS_BROAD } from "../asset-spec";
+import { hasErrnoCode, toPosix } from "../common";
+import { buildToolInfo } from "../tool-runner";
+import { extractDescriptionFromComments } from "../metadata";
+/** Extensions that buildToolInfo can handle (tool-runner supported) */
+const RUNNABLE_EXTENSIONS = SCRIPT_EXTENSIONS;
+export const scriptHandler = {
+    typeName: "script",
+    stashDir: "scripts",
+    isRelevantFile(fileName) {
+        return SCRIPT_EXTENSIONS_BROAD.has(path.extname(fileName).toLowerCase());
+    },
+    toCanonicalName(typeRoot, filePath) {
+        return toPosix(path.relative(typeRoot, filePath));
+    },
+    toAssetPath(typeRoot, name) {
+        return path.join(typeRoot, name);
+    },
+    buildShowResponse(input) {
+        const ext = path.extname(input.path).toLowerCase();
+        // For extensions supported by tool-runner, show runCmd
+        if (RUNNABLE_EXTENSIONS.has(ext)) {
+            const stashDirs = input.stashDirs ?? [];
+            const assetStashDir = stashDirs.find((d) => path.resolve(input.path).startsWith(path.resolve(d) + path.sep)) ?? stashDirs[0];
+            if (assetStashDir) {
+                try {
+                    const toolInfo = buildToolInfo(assetStashDir, input.path);
+                    return {
+                        type: "script",
+                        name: input.name,
+                        path: input.path,
+                        runCmd: toolInfo.runCmd,
+                        kind: toolInfo.kind,
+                    };
+                }
+                catch {
+                    // Fall through to content display
+                }
+            }
+        }
+        // For other extensions or when buildToolInfo fails, show file content
+        return {
+            type: "script",
+            name: input.name,
+            path: input.path,
+            content: input.content,
+        };
+    },
+    enrichSearchHit(hit, stashDir) {
+        const ext = path.extname(hit.path).toLowerCase();
+        if (!RUNNABLE_EXTENSIONS.has(ext))
+            return;
+        try {
+            const toolInfo = buildToolInfo(stashDir, hit.path);
+            hit.runCmd = toolInfo.runCmd;
+            hit.kind = toolInfo.kind;
+        }
+        catch (error) {
+            if (!hasErrnoCode(error, "ENOENT"))
+                throw error;
+        }
+    },
+    defaultUsageGuide: [
+        "Use the hit's runCmd for execution when available, or run the script directly with the appropriate interpreter.",
+        "Use `akm show <openRef>` to inspect the script before running it.",
+    ],
+    extractTypeMetadata(entry, file, ext) {
+        if (ext !== ".md") {
+            const commentDesc = extractDescriptionFromComments(file);
+            if (commentDesc && !entry.description) {
+                entry.description = commentDesc;
+                entry.source = "comments";
+                entry.confidence = 0.7;
+            }
+        }
+    },
+};

package/dist/src/handlers/skill-handler.d.ts

@@ -0,0 +1,2 @@
+import type { AssetTypeHandler } from "../asset-type-handler";
+export declare const skillHandler: AssetTypeHandler;

package/dist/src/handlers/skill-handler.js

@@ -0,0 +1,30 @@
+import path from "node:path";
+import { toPosix } from "../common";
+export const skillHandler = {
+    typeName: "skill",
+    stashDir: "skills",
+    isRelevantFile(fileName) {
+        return fileName === "SKILL.md";
+    },
+    toCanonicalName(typeRoot, filePath) {
+        const relDir = toPosix(path.dirname(path.relative(typeRoot, filePath)));
+        if (!relDir || relDir === ".")
+            return undefined;
+        return relDir;
+    },
+    toAssetPath(typeRoot, name) {
+        return path.join(typeRoot, name, "SKILL.md");
+    },
+    buildShowResponse(input) {
+        return {
+            type: "skill",
+            name: input.name,
+            path: input.path,
+            content: input.content,
+        };
+    },
+    defaultUsageGuide: [
+        "Read and apply the skill instructions as written, then adapt examples to your current repo state and task.",
+        "Use `akm show <openRef>` to read the full SKILL.md for required steps and constraints.",
+    ],
+};

package/dist/src/handlers/tool-handler.d.ts

@@ -0,0 +1,2 @@
+import type { AssetTypeHandler } from "../asset-type-handler";
+export declare const toolHandler: AssetTypeHandler;

package/dist/src/handlers/tool-handler.js

@@ -0,0 +1,58 @@
+import path from "node:path";
+import { SCRIPT_EXTENSIONS } from "../asset-spec";
+import { hasErrnoCode, toPosix } from "../common";
+import { buildToolInfo } from "../tool-runner";
+import { extractDescriptionFromComments } from "../metadata";
+export const toolHandler = {
+    typeName: "tool",
+    stashDir: "tools",
+    isRelevantFile(fileName) {
+        return SCRIPT_EXTENSIONS.has(path.extname(fileName).toLowerCase());
+    },
+    toCanonicalName(typeRoot, filePath) {
+        return toPosix(path.relative(typeRoot, filePath));
+    },
+    toAssetPath(typeRoot, name) {
+        return path.join(typeRoot, name);
+    },
+    buildShowResponse(input) {
+        const stashDirs = input.stashDirs ?? [];
+        const assetStashDir = stashDirs.find((d) => path.resolve(input.path).startsWith(path.resolve(d) + path.sep)) ?? stashDirs[0];
+        if (!assetStashDir) {
+            return { type: "tool", name: input.name, path: input.path, content: input.content };
+        }
+        const toolInfo = buildToolInfo(assetStashDir, input.path);
+        return {
+            type: "tool",
+            name: input.name,
+            path: input.path,
+            runCmd: toolInfo.runCmd,
+            kind: toolInfo.kind,
+        };
+    },
+    enrichSearchHit(hit, stashDir) {
+        try {
+            const toolInfo = buildToolInfo(stashDir, hit.path);
+            hit.runCmd = toolInfo.runCmd;
+            hit.kind = toolInfo.kind;
+        }
+        catch (error) {
+            if (!hasErrnoCode(error, "ENOENT"))
+                throw error;
+        }
+    },
+    defaultUsageGuide: [
+        "Use the hit's runCmd for execution so runtime and working directory stay correct.",
+        "Use `akm show <openRef>` to inspect the tool before running it.",
+    ],
+    extractTypeMetadata(entry, file, ext) {
+        if (SCRIPT_EXTENSIONS.has(ext) && ext !== ".md") {
+            const commentDesc = extractDescriptionFromComments(file);
+            if (commentDesc && !entry.description) {
+                entry.description = commentDesc;
+                entry.source = "comments";
+                entry.confidence = 0.7;
+            }
+        }
+    },
+};

package/dist/src/indexer.d.ts

@@ -1,24 +1,4 @@
 import { type StashEntry } from "./metadata";
-import { type SerializedTfIdf } from "./similarity";
-import type { EmbeddingVector } from "./embedder";
-export interface IndexedEntry {
-    entry: StashEntry;
-    path: string;
-    dirPath: string;
-    embedding?: EmbeddingVector;
-}
-export interface SearchIndex {
-    version: number;
-    builtAt: string;
-    stashDir: string;
-    /** All stash directories that were indexed (primary + additional) */
-    stashDirs?: string[];
-    entries: IndexedEntry[];
-    /** Serialized TF-IDF state (term frequencies, idf values) */
-    tfidf?: SerializedTfIdf;
-    /** Whether embeddings are included in entries */
-    hasEmbeddings?: boolean;
-}
 export interface IndexResponse {
     stashDir: string;
     totalEntries: number;
@@ -32,11 +12,9 @@ export interface IndexResponse {
         totalMs: number;
         walkMs: number;
         embedMs: number;
-        tfidfMs: number;
+        ftsMs: number;
     };
 }
-export declare function getIndexPath(): string;
-export declare function loadSearchIndex(): SearchIndex | null;
 export declare function agentikitIndex(options?: {
     stashDir?: string;
     full?: boolean;