agentikit 0.0.9 → 0.0.12

package/dist/src/config.js

@@ -1,41 +1,93 @@
 import fs from "node:fs";
 import path from "node:path";
-import { resolveStashDir } from "./common";
 // ── Defaults ────────────────────────────────────────────────────────────────
 export const DEFAULT_CONFIG = {
     semanticSearch: true,
-    additionalStashDirs: [],
+    mountedStashDirs: [],
 };
 // ── Paths ───────────────────────────────────────────────────────────────────
-export function getConfigPath(stashDir) {
-    return path.join(stashDir, "config.json");
+export function getConfigDir(env = process.env, platform = process.platform) {
+    if (platform === "win32") {
+        const appData = env.APPDATA?.trim();
+        if (appData)
+            return path.join(appData, "agentikit");
+        const userProfile = env.USERPROFILE?.trim();
+        if (!userProfile) {
+            throw new Error("Unable to determine config directory. Set APPDATA or USERPROFILE.");
+        }
+        return path.join(userProfile, "AppData", "Roaming", "agentikit");
+    }
+    const xdgConfigHome = env.XDG_CONFIG_HOME?.trim();
+    if (xdgConfigHome)
+        return path.join(xdgConfigHome, "agentikit");
+    const home = env.HOME?.trim();
+    if (!home) {
+        throw new Error("Unable to determine config directory. Set XDG_CONFIG_HOME or HOME.");
+    }
+    return path.join(home, ".config", "agentikit");
+}
+export function getConfigPath() {
+    return path.join(getConfigDir(), "config.json");
 }
 // ── Load / Save / Update ────────────────────────────────────────────────────
-export function loadConfig(stashDir) {
-    const dir = stashDir ?? resolveStashDir();
-    const configPath = getConfigPath(dir);
-    let raw;
+export function loadConfig() {
+    const configPath = getConfigPath();
+    const raw = readConfigObject(configPath);
+    const config = raw ? pickKnownKeys(raw) : { ...DEFAULT_CONFIG };
+    // Inject API keys from environment variables.
+    // API keys should be provided via AKM_EMBED_API_KEY and AKM_LLM_API_KEY
+    // rather than stored in the config file.
+    if (config.embedding && !config.embedding.apiKey) {
+        const envKey = process.env.AKM_EMBED_API_KEY?.trim();
+        if (envKey)
+            config.embedding.apiKey = envKey;
+    }
+    if (config.llm && !config.llm.apiKey) {
+        const envKey = process.env.AKM_LLM_API_KEY?.trim();
+        if (envKey)
+            config.llm.apiKey = envKey;
+    }
+    return config;
+}
+export function saveConfig(config) {
+    const configPath = getConfigPath();
+    const dir = path.dirname(configPath);
+    fs.mkdirSync(dir, { recursive: true });
+    const sanitized = sanitizeConfigForWrite(config);
+    const tmpPath = configPath + `.tmp.${process.pid}`;
     try {
-        raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
-        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
-            return { ...DEFAULT_CONFIG };
-        }
+        fs.writeFileSync(tmpPath, JSON.stringify(sanitized, null, 2) + "\n", "utf8");
+        fs.renameSync(tmpPath, configPath);
     }
-    catch {
-        return { ...DEFAULT_CONFIG };
+    catch (err) {
+        try {
+            fs.unlinkSync(tmpPath);
+        }
+        catch { /* ignore cleanup failure */ }
+        throw err;
     }
-    return pickKnownKeys(raw);
 }
-export function saveConfig(config, stashDir) {
-    const dir = stashDir ?? resolveStashDir();
-    const configPath = getConfigPath(dir);
-    fs.writeFileSync(configPath, JSON.stringify(config, null, 2) + "\n", "utf8");
+/**
+ * Strip apiKey fields before writing config to disk.
+ * API keys should be provided via environment variables
+ * AKM_EMBED_API_KEY and AKM_LLM_API_KEY.
+ */
+function sanitizeConfigForWrite(config) {
+    const sanitized = { ...config };
+    if (sanitized.embedding) {
+        const { apiKey, ...rest } = sanitized.embedding;
+        sanitized.embedding = rest;
+    }
+    if (sanitized.llm) {
+        const { apiKey, ...rest } = sanitized.llm;
+        sanitized.llm = rest;
+    }
+    return sanitized;
 }
-export function updateConfig(partial, stashDir) {
-    const dir = stashDir ?? resolveStashDir();
-    const current = loadConfig(dir);
+export function updateConfig(partial) {
+    const current = loadConfig();
     const merged = { ...current, ...partial };
-    saveConfig(merged, dir);
+    saveConfig(merged);
     return merged;
 }
 // ── Helpers ─────────────────────────────────────────────────────────────────
@@ -44,21 +96,35 @@ function pickKnownKeys(raw) {
     if (typeof raw.semanticSearch === "boolean") {
         config.semanticSearch = raw.semanticSearch;
     }
-    if (Array.isArray(raw.additionalStashDirs)) {
-        config.additionalStashDirs = raw.additionalStashDirs.filter((d) => typeof d === "string");
+    if (Array.isArray(raw.mountedStashDirs)) {
+        config.mountedStashDirs = raw.mountedStashDirs.filter((d) => typeof d === "string");
     }
-    const embedding = parseConnectionConfig(raw.embedding);
+    const embedding = parseEmbeddingConfig(raw.embedding);
     if (embedding)
         config.embedding = embedding;
-    const llm = parseConnectionConfig(raw.llm);
+    const llm = parseLlmConfig(raw.llm);
     if (llm)
         config.llm = llm;
     const registry = parseRegistryConfig(raw.registry);
     if (registry)
         config.registry = registry;
+    if (Array.isArray(raw.registryUrls)) {
+        config.registryUrls = raw.registryUrls.filter((u) => typeof u === "string" && u.startsWith("http"));
+    }
     return config;
 }
-function parseConnectionConfig(value) {
+function readConfigObject(configPath) {
+    try {
+        const raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw))
+            return undefined;
+        return raw;
+    }
+    catch {
+        return undefined;
+    }
+}
+function parseEmbeddingConfig(value) {
     if (typeof value !== "object" || value === null || Array.isArray(value))
         return undefined;
     const obj = value;
@@ -70,6 +136,50 @@ function parseConnectionConfig(value) {
         endpoint: obj.endpoint,
         model: obj.model,
     };
+    if (typeof obj.provider === "string" && obj.provider) {
+        result.provider = obj.provider;
+    }
+    if ("dimension" in obj) {
+        if (typeof obj.dimension !== "number" ||
+            !Number.isFinite(obj.dimension) ||
+            !Number.isInteger(obj.dimension) ||
+            obj.dimension <= 0) {
+            return undefined;
+        }
+        result.dimension = obj.dimension;
+    }
+    if (typeof obj.apiKey === "string" && obj.apiKey) {
+        result.apiKey = obj.apiKey;
+    }
+    return result;
+}
+function parseLlmConfig(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    if (typeof obj.endpoint !== "string" || !obj.endpoint)
+        return undefined;
+    if (typeof obj.model !== "string" || !obj.model)
+        return undefined;
+    const result = {
+        endpoint: obj.endpoint,
+        model: obj.model,
+    };
+    if (typeof obj.provider === "string" && obj.provider) {
+        result.provider = obj.provider;
+    }
+    if (typeof obj.temperature === "number" && Number.isFinite(obj.temperature)) {
+        result.temperature = obj.temperature;
+    }
+    if ("maxTokens" in obj) {
+        if (typeof obj.maxTokens !== "number" ||
+            !Number.isFinite(obj.maxTokens) ||
+            !Number.isInteger(obj.maxTokens) ||
+            obj.maxTokens <= 0) {
+            return undefined;
+        }
+        result.maxTokens = obj.maxTokens;
+    }
     if (typeof obj.apiKey === "string" && obj.apiKey) {
         result.apiKey = obj.apiKey;
     }
@@ -120,5 +230,5 @@ function asNonEmptyString(value) {
     return typeof value === "string" && value ? value : undefined;
 }
 function asRegistrySource(value) {
-    return value === "npm" || value === "github" ? value : undefined;
+    return value === "npm" || value === "github" || value === "git" ? value : undefined;
 }

package/dist/src/db.d.ts

@@ -0,0 +1,46 @@
+import { Database } from "bun:sqlite";
+import type { StashEntry } from "./metadata";
+import type { EmbeddingVector } from "./embedder";
+export interface DbIndexedEntry {
+    id: number;
+    entryKey: string;
+    dirPath: string;
+    filePath: string;
+    stashDir: string;
+    entry: StashEntry;
+    searchText: string;
+}
+export interface DbSearchResult {
+    id: number;
+    filePath: string;
+    entry: StashEntry;
+    searchText: string;
+    bm25Score: number;
+}
+export interface DbVecResult {
+    id: number;
+    distance: number;
+}
+export declare const DB_VERSION = 5;
+export declare const EMBEDDING_DIM = 384;
+export declare function getDbPath(): string;
+export declare function openDatabase(dbPath?: string, options?: {
+    embeddingDim?: number;
+}): Database;
+export declare function closeDatabase(db: Database): void;
+export declare function isVecAvailable(): boolean;
+export declare function getMeta(db: Database, key: string): string | undefined;
+export declare function setMeta(db: Database, key: string, value: string): void;
+export declare function upsertEntry(db: Database, entryKey: string, dirPath: string, filePath: string, stashDir: string, entry: StashEntry, searchText: string): number;
+export declare function deleteEntriesByDir(db: Database, dirPath: string): void;
+export declare function rebuildFts(db: Database): void;
+export declare function upsertEmbedding(db: Database, entryId: number, embedding: EmbeddingVector): void;
+export declare function searchVec(db: Database, queryEmbedding: EmbeddingVector, k: number): DbVecResult[];
+export declare function searchFts(db: Database, query: string, limit: number, entryType?: string): DbSearchResult[];
+export declare function getAllEntries(db: Database, entryType?: string): DbIndexedEntry[];
+export declare function getEntryCount(db: Database): number;
+export declare function getEntryById(db: Database, id: number): {
+    filePath: string;
+    entry: StashEntry;
+} | undefined;
+export declare function getEntriesByDir(db: Database, dirPath: string): DbIndexedEntry[];

package/dist/src/db.js

@@ -0,0 +1,299 @@
+import fs from "node:fs";
+import path from "node:path";
+import { Database } from "bun:sqlite";
+// ── Constants ───────────────────────────────────────────────────────────────
+export const DB_VERSION = 5;
+export const EMBEDDING_DIM = 384;
+// ── Path ────────────────────────────────────────────────────────────────────
+export function getDbPath() {
+    const cacheDir = process.env.XDG_CACHE_HOME ||
+        path.join(process.env.HOME || process.env.USERPROFILE || "", ".cache");
+    return path.join(cacheDir, "agentikit", "index.db");
+}
+// ── Database lifecycle ──────────────────────────────────────────────────────
+export function openDatabase(dbPath, options) {
+    const resolvedPath = dbPath ?? getDbPath();
+    const dir = path.dirname(resolvedPath);
+    if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+    }
+    const db = new Database(resolvedPath);
+    db.exec("PRAGMA journal_mode = WAL");
+    db.exec("PRAGMA foreign_keys = ON");
+    // Try to load sqlite-vec extension
+    loadVecExtension(db);
+    ensureSchema(db, options?.embeddingDim ?? EMBEDDING_DIM);
+    return db;
+}
+export function closeDatabase(db) {
+    db.close();
+}
+// ── sqlite-vec extension ────────────────────────────────────────────────────
+let vecAvailable = false;
+function loadVecExtension(db) {
+    try {
+        const sqliteVec = require("sqlite-vec");
+        sqliteVec.load(db);
+        vecAvailable = true;
+    }
+    catch {
+        console.warn("sqlite-vec extension not available, embeddings will be skipped");
+        vecAvailable = false;
+    }
+}
+export function isVecAvailable() {
+    return vecAvailable;
+}
+// ── Schema ──────────────────────────────────────────────────────────────────
+function ensureSchema(db, embeddingDim) {
+    // Create meta table first so we can check version
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS index_meta (
+      key   TEXT PRIMARY KEY,
+      value TEXT NOT NULL
+    );
+  `);
+    // Check stored version — if it differs from DB_VERSION, drop and recreate all tables
+    const storedVersion = getMeta(db, "version");
+    if (storedVersion && storedVersion !== String(DB_VERSION)) {
+        db.exec("DROP TABLE IF EXISTS entries_vec");
+        db.exec("DROP TABLE IF EXISTS entries_fts");
+        db.exec("DROP INDEX IF EXISTS idx_entries_dir");
+        db.exec("DROP INDEX IF EXISTS idx_entries_type");
+        db.exec("DROP TABLE IF EXISTS entries");
+        db.exec("DELETE FROM index_meta");
+    }
+    db.exec(`
+    CREATE TABLE IF NOT EXISTS entries (
+      id          INTEGER PRIMARY KEY AUTOINCREMENT,
+      entry_key   TEXT NOT NULL UNIQUE,
+      dir_path    TEXT NOT NULL,
+      file_path   TEXT NOT NULL,
+      stash_dir   TEXT NOT NULL,
+      entry_json  TEXT NOT NULL,
+      search_text TEXT NOT NULL,
+      entry_type  TEXT NOT NULL
+    );
+
+    CREATE INDEX IF NOT EXISTS idx_entries_dir ON entries(dir_path);
+    CREATE INDEX IF NOT EXISTS idx_entries_type ON entries(entry_type);
+  `);
+    // FTS5 table — standalone with explicit entry_id for joining
+    const ftsExists = db
+        .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_fts'")
+        .get();
+    if (!ftsExists) {
+        db.exec(`
+      CREATE VIRTUAL TABLE entries_fts USING fts5(
+        entry_id UNINDEXED,
+        search_text,
+        tokenize='porter unicode61'
+      );
+    `);
+    }
+    // sqlite-vec table
+    if (vecAvailable) {
+        // Check if stored embedding dimension differs from configured one
+        const storedDim = getMeta(db, "embeddingDim");
+        if (storedDim && storedDim !== String(embeddingDim)) {
+            try {
+                db.exec("DROP TABLE IF EXISTS entries_vec");
+            }
+            catch { /* ignore */ }
+        }
+        const vecExists = db
+            .prepare("SELECT name FROM sqlite_master WHERE type='table' AND name='entries_vec'")
+            .get();
+        if (!vecExists) {
+            db.exec(`
+        CREATE VIRTUAL TABLE entries_vec USING vec0(
+          id       INTEGER PRIMARY KEY,
+          embedding FLOAT[${embeddingDim}]
+        );
+      `);
+        }
+        setMeta(db, "embeddingDim", String(embeddingDim));
+    }
+    // Set version if not present
+    const version = getMeta(db, "version");
+    if (!version) {
+        setMeta(db, "version", String(DB_VERSION));
+    }
+}
+// ── Meta helpers ────────────────────────────────────────────────────────────
+export function getMeta(db, key) {
+    const row = db.prepare("SELECT value FROM index_meta WHERE key = ?").get(key);
+    return row?.value;
+}
+export function setMeta(db, key, value) {
+    db.prepare("INSERT OR REPLACE INTO index_meta (key, value) VALUES (?, ?)").run(key, value);
+}
+// ── Entry operations ────────────────────────────────────────────────────────
+export function upsertEntry(db, entryKey, dirPath, filePath, stashDir, entry, searchText) {
+    const stmt = db.prepare(`
+    INSERT INTO entries (entry_key, dir_path, file_path, stash_dir, entry_json, search_text, entry_type)
+    VALUES (?, ?, ?, ?, ?, ?, ?)
+    ON CONFLICT(entry_key) DO UPDATE SET
+      dir_path = excluded.dir_path,
+      file_path = excluded.file_path,
+      stash_dir = excluded.stash_dir,
+      entry_json = excluded.entry_json,
+      search_text = excluded.search_text,
+      entry_type = excluded.entry_type
+  `);
+    stmt.run(entryKey, dirPath, filePath, stashDir, JSON.stringify(entry), searchText, entry.type);
+    // Fetch the row id explicitly since last_insert_rowid() is unreliable for ON CONFLICT DO UPDATE
+    const row = db.prepare("SELECT id FROM entries WHERE entry_key = ?").get(entryKey);
+    return row.id;
+}
+export function deleteEntriesByDir(db, dirPath) {
+    if (vecAvailable) {
+        const ids = db
+            .prepare("SELECT id FROM entries WHERE dir_path = ?")
+            .all(dirPath);
+        for (const { id } of ids) {
+            try {
+                db.prepare("DELETE FROM entries_vec WHERE id = ?").run(id);
+            }
+            catch { /* ignore if vec table missing */ }
+        }
+    }
+    db.prepare("DELETE FROM entries WHERE dir_path = ?").run(dirPath);
+}
+export function rebuildFts(db) {
+    db.exec("DELETE FROM entries_fts");
+    db.exec("INSERT INTO entries_fts (entry_id, search_text) SELECT CAST(id AS TEXT), search_text FROM entries");
+}
+// ── Vector operations ───────────────────────────────────────────────────────
+export function upsertEmbedding(db, entryId, embedding) {
+    if (!vecAvailable)
+        return;
+    const buf = float32Buffer(embedding);
+    try {
+        db.prepare("DELETE FROM entries_vec WHERE id = ?").run(entryId);
+    }
+    catch { /* ignore */ }
+    db.prepare("INSERT INTO entries_vec (id, embedding) VALUES (?, ?)").run(entryId, buf);
+}
+export function searchVec(db, queryEmbedding, k) {
+    if (!vecAvailable)
+        return [];
+    const buf = float32Buffer(queryEmbedding);
+    try {
+        return db
+            .prepare("SELECT id, distance FROM entries_vec WHERE embedding MATCH ? AND k = ?")
+            .all(buf, k);
+    }
+    catch {
+        return [];
+    }
+}
+function float32Buffer(vec) {
+    const f32 = new Float32Array(vec);
+    return Buffer.from(f32.buffer);
+}
+// ── FTS5 search ─────────────────────────────────────────────────────────────
+export function searchFts(db, query, limit, entryType) {
+    const ftsQuery = sanitizeFtsQuery(query);
+    if (!ftsQuery)
+        return [];
+    let sql;
+    let params;
+    if (entryType && entryType !== "any") {
+        sql = `
+      SELECT e.id, e.file_path AS filePath, e.entry_json, e.search_text AS searchText,
+             bm25(entries_fts) AS bm25Score
+      FROM entries_fts f
+      JOIN entries e ON e.id = CAST(f.entry_id AS INTEGER)
+      WHERE entries_fts MATCH ?
+        AND e.entry_type = ?
+      ORDER BY bm25Score
+      LIMIT ?
+    `;
+        params = [ftsQuery, entryType, limit];
+    }
+    else {
+        sql = `
+      SELECT e.id, e.file_path AS filePath, e.entry_json, e.search_text AS searchText,
+             bm25(entries_fts) AS bm25Score
+      FROM entries_fts f
+      JOIN entries e ON e.id = CAST(f.entry_id AS INTEGER)
+      WHERE entries_fts MATCH ?
+      ORDER BY bm25Score
+      LIMIT ?
+    `;
+        params = [ftsQuery, limit];
+    }
+    try {
+        const rows = db.prepare(sql).all(...params);
+        return rows.map((row) => ({
+            id: row.id,
+            filePath: row.filePath,
+            entry: JSON.parse(row.entry_json),
+            searchText: row.searchText,
+            bm25Score: row.bm25Score,
+        }));
+    }
+    catch {
+        return [];
+    }
+}
+function sanitizeFtsQuery(query) {
+    const tokens = query
+        .replace(/[^a-zA-Z0-9\s]/g, " ")
+        .split(/\s+/)
+        .filter((t) => t.length > 1);
+    if (tokens.length === 0)
+        return "";
+    // Use unquoted tokens so the porter stemmer can normalize word forms
+    return tokens.join(" OR ");
+}
+// ── All entries ─────────────────────────────────────────────────────────────
+export function getAllEntries(db, entryType) {
+    let sql;
+    let params;
+    if (entryType && entryType !== "any") {
+        sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE entry_type = ?";
+        params = [entryType];
+    }
+    else {
+        sql = "SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries";
+        params = [];
+    }
+    const rows = db.prepare(sql).all(...params);
+    return rows.map((row) => ({
+        id: row.id,
+        entryKey: row.entry_key,
+        dirPath: row.dir_path,
+        filePath: row.file_path,
+        stashDir: row.stash_dir,
+        entry: JSON.parse(row.entry_json),
+        searchText: row.search_text,
+    }));
+}
+export function getEntryCount(db) {
+    const row = db.prepare("SELECT COUNT(*) AS cnt FROM entries").get();
+    return row.cnt;
+}
+export function getEntryById(db, id) {
+    const row = db
+        .prepare("SELECT file_path, entry_json FROM entries WHERE id = ?")
+        .get(id);
+    if (!row)
+        return undefined;
+    return { filePath: row.file_path, entry: JSON.parse(row.entry_json) };
+}
+export function getEntriesByDir(db, dirPath) {
+    const rows = db
+        .prepare("SELECT id, entry_key, dir_path, file_path, stash_dir, entry_json, search_text FROM entries WHERE dir_path = ?")
+        .all(dirPath);
+    return rows.map((row) => ({
+        id: row.id,
+        entryKey: row.entry_key,
+        dirPath: row.dir_path,
+        filePath: row.file_path,
+        stashDir: row.stash_dir,
+        entry: JSON.parse(row.entry_json),
+        searchText: row.search_text,
+    }));
+}

package/dist/src/embedder.js

@@ -1,4 +1,4 @@
-// ── Singleton local embedder ────────────────────────────────────────────────
+import { fetchWithTimeout } from "./common";
 let localEmbedder;
 async function getLocalEmbedder() {
     if (!localEmbedder) {
@@ -10,7 +10,8 @@ async function getLocalEmbedder() {
         catch {
             throw new Error("Semantic search requires @xenova/transformers. Install it with: npm install @xenova/transformers");
         }
-        localEmbedder = await pipeline("feature-extraction", "Xenova/all-MiniLM-L6-v2");
+        const pipelineFn = pipeline;
+        localEmbedder = await pipelineFn("feature-extraction", "Xenova/all-MiniLM-L6-v2");
     }
     return localEmbedder;
 }
@@ -25,13 +26,17 @@ async function embedRemote(text, config) {
     if (config.apiKey) {
         headers["Authorization"] = `Bearer ${config.apiKey}`;
     }
-    const response = await fetch(config.endpoint, {
+    const body = {
+        input: text,
+        model: config.model,
+    };
+    if (config.dimension) {
+        body.dimensions = config.dimension;
+    }
+    const response = await fetchWithTimeout(config.endpoint, {
         method: "POST",
         headers,
-        body: JSON.stringify({
-            input: text,
-            model: config.model,
-        }),
+        body: JSON.stringify(body),
     });
     if (!response.ok) {
         const body = await response.text().catch(() => "");

package/dist/src/github.d.ts

@@ -0,0 +1,4 @@
+export declare const GITHUB_API_BASE = "https://api.github.com";
+export declare function githubHeaders(): HeadersInit;
+export declare function asRecord(value: unknown): Record<string, unknown>;
+export declare function asString(value: unknown): string | undefined;

package/dist/src/github.js

@@ -0,0 +1,19 @@
+export const GITHUB_API_BASE = "https://api.github.com";
+export function githubHeaders() {
+    const token = process.env.GITHUB_TOKEN?.trim();
+    const headers = {
+        Accept: "application/vnd.github+json",
+        "User-Agent": "agentikit-registry",
+    };
+    if (token)
+        headers.Authorization = `Bearer ${token}`;
+    return headers;
+}
+export function asRecord(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value)
+        ? value
+        : {};
+}
+export function asString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}

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

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

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

@@ -0,0 +1,26 @@
+import { parseFrontmatter, toStringOrUndefined } from "../frontmatter";
+import { isMarkdownFile, markdownCanonicalName, markdownAssetPath } from "./markdown-helpers";
+export const agentHandler = {
+    typeName: "agent",
+    stashDir: "agents",
+    isRelevantFile: isMarkdownFile,
+    toCanonicalName: markdownCanonicalName,
+    toAssetPath: markdownAssetPath,
+    buildShowResponse(input) {
+        const parsedMd = parseFrontmatter(input.content);
+        return {
+            type: "agent",
+            name: input.name,
+            path: input.path,
+            description: toStringOrUndefined(parsedMd.data.description),
+            prompt: "Dispatching prompt must include the agent's full prompt content verbatim; summaries are non-compliant. \n\n"
+                + parsedMd.content,
+            toolPolicy: parsedMd.data.tools,
+            modelHint: parsedMd.data.model,
+        };
+    },
+    defaultUsageGuide: [
+        "Read the .md file and dispatch an agent using the content of the file. Use modelHint/toolPolicy when present to run the agent with compatible settings.",
+        "Use with `akm show <openRef>` to get the full prompt payload.",
+    ],
+};

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

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