agentikit 0.0.12 → 0.0.14

package/dist/index.js

@@ -1,15 +0,0 @@
-export { agentikitAdd, agentikitClone, agentikitList, agentikitRemove, agentikitReinstall, agentikitSearch, agentikitShow, agentikitUpdate, resolveStashSources, resolveAllStashDirs, findSourceForPath, } from "./src/stash";
-export { agentikitInit } from "./src/init";
-export { agentikitIndex } from "./src/indexer";
-export { resolveRg, isRgAvailable, ensureRg } from "./src/ripgrep";
-export { parseMarkdownToc, extractSection, extractLineRange, extractFrontmatterOnly, formatToc } from "./src/markdown";
-export { parseFrontmatter } from "./src/frontmatter";
-export { loadConfig, saveConfig, updateConfig } from "./src/config";
-export { parseRegistryRef, resolveRegistryArtifact } from "./src/registry-resolve";
-export { searchRegistry } from "./src/registry-search";
-export { installRegistryRef, upsertInstalledRegistryEntry, removeInstalledRegistryEntry, getRegistryCacheRootDir, detectStashRoot, } from "./src/registry-install";
-export { enhanceMetadata, isLlmAvailable } from "./src/llm";
-export { embed, cosineSimilarity, isEmbeddingAvailable } from "./src/embedder";
-export { registerAssetType, getHandler, tryGetHandler, getAllHandlers, getRegisteredTypeNames } from "./src/asset-type-handler";
-export { parseAssetRef, makeAssetRef } from "./src/stash-ref";
-export { resolveSourcesForOrigin, isRemoteOrigin } from "./src/origin-resolve";

package/dist/src/asset-spec.d.ts

@@ -1,16 +0,0 @@
-import type { AgentikitAssetType } from "./common";
-export declare const SCRIPT_EXTENSIONS: Set<string>;
-export interface AssetSpec {
-    stashDir: string;
-    isRelevantFile: (fileName: string) => boolean;
-    toCanonicalName: (typeRoot: string, filePath: string) => string | undefined;
-    toAssetPath: (typeRoot: string, name: string) => string;
-}
-/** Extended set of script extensions for the script asset type */
-export declare const SCRIPT_EXTENSIONS_BROAD: Set<string>;
-export declare const ASSET_SPECS: Record<AgentikitAssetType, AssetSpec>;
-export declare const ASSET_TYPES: AgentikitAssetType[];
-export declare const TYPE_DIRS: Record<AgentikitAssetType, string>;
-export declare function isRelevantAssetFile(assetType: AgentikitAssetType, fileName: string): boolean;
-export declare function deriveCanonicalAssetName(assetType: AgentikitAssetType, typeRoot: string, filePath: string): string | undefined;
-export declare function resolveAssetPathFromName(assetType: AgentikitAssetType, typeRoot: string, name: string): string;

package/dist/src/asset-type-handler.d.ts

@@ -1,27 +0,0 @@
-import type { StashEntry } from "./metadata";
-import type { LocalSearchHit, ShowResponse, KnowledgeView } from "./stash-types";
-export interface ShowInput {
-    name: string;
-    path: string;
-    content: string;
-    view?: KnowledgeView;
-    stashDirs?: string[];
-}
-export interface AssetTypeHandler {
-    /** The type name, e.g. "tool", "script" */
-    readonly typeName: string;
-    /** Directory inside the stash root, e.g. "tools", "scripts" */
-    readonly stashDir: string;
-    isRelevantFile(fileName: string): boolean;
-    toCanonicalName(typeRoot: string, filePath: string): string | undefined;
-    toAssetPath(typeRoot: string, name: string): string;
-    buildShowResponse(input: ShowInput): ShowResponse;
-    enrichSearchHit?(hit: LocalSearchHit, stashDir: string): void;
-    readonly defaultUsageGuide: string[];
-    extractTypeMetadata?(entry: StashEntry, file: string, ext: string): void;
-}
-export declare function registerAssetType(handler: AssetTypeHandler): void;
-export declare function getHandler(type: string): AssetTypeHandler;
-export declare function tryGetHandler(type: string): AssetTypeHandler | undefined;
-export declare function getAllHandlers(): AssetTypeHandler[];
-export declare function getRegisteredTypeNames(): string[];

package/dist/src/cli.d.ts

@@ -1,2 +0,0 @@
-#!/usr/bin/env node
-export {};

package/dist/src/cli.js

@@ -1,399 +0,0 @@
-#!/usr/bin/env node
-import { defineCommand, runMain } from "citty";
-import { agentikitAdd, agentikitList, agentikitReinstall, agentikitRemove, agentikitSearch, agentikitShow, agentikitUpdate, } from "./stash";
-import { agentikitInit } from "./init";
-import { agentikitIndex } from "./indexer";
-import { agentikitClone } from "./stash-clone";
-import { resolveStashSources } from "./stash-source";
-import { loadConfig, saveConfig } from "./config";
-import { getConfigValue, listConfig, listProviders, parseConfigValue, setConfigValue, unsetConfigValue, useProvider, } from "./config-cli";
-const initCommand = defineCommand({
-    meta: { name: "init", description: "Initialize Agent-i-Kit's working stash directory and set AKM_STASH_DIR" },
-    async run() {
-        await runWithJsonErrors(async () => {
-            const result = await agentikitInit();
-            console.log(JSON.stringify(result, null, 2));
-        });
-    },
-});
-const indexCommand = defineCommand({
-    meta: { name: "index", description: "Build search index (incremental by default; --full forces full reindex)" },
-    args: {
-        full: { type: "boolean", description: "Force full reindex", default: false },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            const result = await agentikitIndex({ full: args.full });
-            console.log(JSON.stringify(result, null, 2));
-        });
-    },
-});
-const searchCommand = defineCommand({
-    meta: { name: "search", description: "Search the stash" },
-    args: {
-        query: { type: "positional", description: "Search query", required: false, default: "" },
-        type: { type: "string", description: "Asset type filter (tool|skill|command|agent|knowledge|script|any)" },
-        limit: { type: "string", description: "Maximum number of results" },
-        usage: { type: "string", description: "Usage metadata mode (none|both|item|guide)", default: "both" },
-        source: { type: "string", description: "Search source (local|registry|both)", default: "local" },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            const type = args.type;
-            const limit = args.limit ? parseInt(args.limit, 10) : undefined;
-            const usage = parseSearchUsageMode(args.usage);
-            const source = parseSearchSource(args.source);
-            console.log(JSON.stringify(await agentikitSearch({ query: args.query, type, limit, usage, source }), null, 2));
-        });
-    },
-});
-const addCommand = defineCommand({
-    meta: { name: "add", description: "Install a registry package or local git directory into the stash" },
-    args: {
-        ref: {
-            type: "positional",
-            description: "Registry ref (npm package, owner/repo, github URL, or local git directory)",
-            required: true,
-        },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            console.log(JSON.stringify(await agentikitAdd({ ref: args.ref }), null, 2));
-        });
-    },
-});
-const listCommand = defineCommand({
-    meta: { name: "list", description: "List installed registry packages from config" },
-    async run() {
-        await runWithJsonErrors(async () => {
-            console.log(JSON.stringify(await agentikitList(), null, 2));
-        });
-    },
-});
-const removeCommand = defineCommand({
-    meta: { name: "remove", description: "Remove an installed registry package by id or ref" },
-    args: {
-        target: { type: "positional", description: "Installed target (id or ref)", required: true },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            console.log(JSON.stringify(await agentikitRemove({ target: args.target }), null, 2));
-        });
-    },
-});
-const updateCommand = defineCommand({
-    meta: { name: "update", description: "Update one or all installed registry packages" },
-    args: {
-        target: { type: "positional", description: "Installed target (id or ref)", required: false },
-        all: { type: "boolean", description: "Update all installed entries", default: false },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            console.log(JSON.stringify(await agentikitUpdate({ target: args.target, all: args.all }), null, 2));
-        });
-    },
-});
-const reinstallCommand = defineCommand({
-    meta: { name: "reinstall", description: "Reinstall one or all installed registry packages" },
-    args: {
-        target: { type: "positional", description: "Installed target (id or ref)", required: false },
-        all: { type: "boolean", description: "Reinstall all installed entries", default: false },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            console.log(JSON.stringify(await agentikitReinstall({ target: args.target, all: args.all }), null, 2));
-        });
-    },
-});
-const showCommand = defineCommand({
-    meta: { name: "show", description: "Show a stash asset by ref (e.g. agent:bunjs-typescript-coder.md)" },
-    args: {
-        ref: { type: "positional", description: "Asset ref (type:name)", required: true },
-        view: { type: "string", description: "Knowledge view mode (full|toc|frontmatter|section|lines)" },
-        heading: { type: "string", description: "Section heading (for --view section)" },
-        start: { type: "string", description: "Start line (for --view lines)" },
-        end: { type: "string", description: "End line (for --view lines)" },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            let view;
-            if (args.view) {
-                switch (args.view) {
-                    case "section":
-                        view = { mode: "section", heading: args.heading ?? "" };
-                        break;
-                    case "lines":
-                        view = {
-                            mode: "lines",
-                            start: Number(args.start ?? "1"),
-                            end: args.end ? parseInt(args.end, 10) : Number.MAX_SAFE_INTEGER,
-                        };
-                        break;
-                    case "toc":
-                    case "frontmatter":
-                    case "full":
-                        view = { mode: args.view };
-                        break;
-                    default:
-                        throw new Error(`Unknown view mode: ${args.view}. Expected one of: full|toc|frontmatter|section|lines`);
-                }
-            }
-            console.log(JSON.stringify(await agentikitShow({ ref: args.ref, view }), null, 2));
-        });
-    },
-});
-const configCommand = defineCommand({
-    meta: { name: "config", description: "Show configuration, get/set keys, and manage embedding/LLM providers" },
-    args: {
-        list: { type: "boolean", description: "List current configuration with effective defaults", default: false },
-        get: { type: "string", description: "Get a configuration value by key" },
-        unset: { type: "string", description: "Unset an optional configuration key or whole embedding/llm section" },
-        set: { type: "string", description: "Back-compat alias for updating a key (key=value format)" },
-    },
-    subCommands: {
-        list: defineCommand({
-            meta: { name: "list", description: "List current configuration with effective embedding/LLM settings" },
-            run() {
-                return runWithJsonErrors(() => {
-                    console.log(JSON.stringify(listConfig(loadConfig()), null, 2));
-                });
-            },
-        }),
-        get: defineCommand({
-            meta: { name: "get", description: "Get a configuration value by key" },
-            args: {
-                key: { type: "positional", required: true, description: "Config key (for example: embedding.provider)" },
-            },
-            run({ args }) {
-                return runWithJsonErrors(() => {
-                    console.log(JSON.stringify(getConfigValue(loadConfig(), args.key), null, 2));
-                });
-            },
-        }),
-        set: defineCommand({
-            meta: { name: "set", description: "Set a configuration value by key" },
-            args: {
-                key: { type: "positional", required: true, description: "Config key (for example: llm.temperature)" },
-                value: { type: "positional", required: true, description: "Config value" },
-            },
-            run({ args }) {
-                return runWithJsonErrors(() => {
-                    const updated = setConfigValue(loadConfig(), args.key, args.value);
-                    saveConfig(updated);
-                    console.log(JSON.stringify(listConfig(updated), null, 2));
-                });
-            },
-        }),
-        unset: defineCommand({
-            meta: { name: "unset", description: "Unset an optional configuration key or whole embedding/llm section" },
-            args: {
-                key: { type: "positional", required: true, description: "Config key to unset" },
-            },
-            run({ args }) {
-                return runWithJsonErrors(() => {
-                    const updated = unsetConfigValue(loadConfig(), args.key);
-                    saveConfig(updated);
-                    console.log(JSON.stringify(listConfig(updated), null, 2));
-                });
-            },
-        }),
-        providers: defineCommand({
-            meta: { name: "providers", description: "List available embedding or LLM providers" },
-            args: {
-                scope: { type: "positional", required: true, description: "Provider scope: embedding or llm" },
-            },
-            run({ args }) {
-                return runWithJsonErrors(() => {
-                    const scope = parseProviderScope(args.scope);
-                    console.log(JSON.stringify(listProviders(scope, loadConfig()), null, 2));
-                });
-            },
-        }),
-        use: defineCommand({
-            meta: { name: "use", description: "Switch the default embedding or LLM provider" },
-            args: {
-                scope: { type: "positional", required: true, description: "Provider scope: embedding or llm" },
-                provider: { type: "positional", required: true, description: "Provider name" },
-            },
-            run({ args }) {
-                return runWithJsonErrors(() => {
-                    const scope = parseProviderScope(args.scope);
-                    const updated = useProvider(loadConfig(), scope, args.provider);
-                    saveConfig(updated);
-                    console.log(JSON.stringify(listConfig(updated), null, 2));
-                });
-            },
-        }),
-    },
-    run({ args }) {
-        return runWithJsonErrors(() => {
-            if (hasConfigSubcommand(args))
-                return;
-            if (args.list) {
-                console.log(JSON.stringify(listConfig(loadConfig()), null, 2));
-                return;
-            }
-            if (args.get) {
-                console.log(JSON.stringify(getConfigValue(loadConfig(), args.get), null, 2));
-                return;
-            }
-            if (args.unset) {
-                const updated = unsetConfigValue(loadConfig(), args.unset);
-                saveConfig(updated);
-                console.log(JSON.stringify(listConfig(updated), null, 2));
-                return;
-            }
-            if (args.set) {
-                const eqIndex = args.set.indexOf("=");
-                if (eqIndex === -1) {
-                    throw new Error("--set expects key=value format");
-                }
-                const key = args.set.slice(0, eqIndex);
-                const value = args.set.slice(eqIndex + 1);
-                const partial = parseConfigValue(key, value);
-                const config = { ...loadConfig(), ...partial };
-                saveConfig(config);
-                console.log(JSON.stringify(listConfig(config), null, 2));
-            }
-            else {
-                console.log(JSON.stringify(listConfig(loadConfig()), null, 2));
-            }
-        });
-    },
-});
-const cloneCommand = defineCommand({
-    meta: { name: "clone", description: "Clone an asset from any stash source into the working stash" },
-    args: {
-        ref: { type: "positional", description: "Asset ref (e.g. @installed:pkg/tool:script.sh)", required: true },
-        name: { type: "string", description: "New name for the cloned asset" },
-        force: { type: "boolean", description: "Overwrite if asset already exists in working stash", default: false },
-    },
-    async run({ args }) {
-        await runWithJsonErrors(async () => {
-            const result = await agentikitClone({
-                sourceRef: args.ref,
-                newName: args.name,
-                force: args.force,
-            });
-            console.log(JSON.stringify(result, null, 2));
-        });
-    },
-});
-const sourcesCommand = defineCommand({
-    meta: { name: "sources", description: "List all stash sources with their kind, path, and status" },
-    run() {
-        return runWithJsonErrors(() => {
-            const sources = resolveStashSources();
-            console.log(JSON.stringify({ sources }, null, 2));
-        });
-    },
-});
-const main = defineCommand({
-    meta: {
-        name: "akm",
-        description: "CLI tool to search, open, and manage assets from Agent-i-Kit stash.",
-    },
-    subCommands: {
-        init: initCommand,
-        index: indexCommand,
-        add: addCommand,
-        list: listCommand,
-        remove: removeCommand,
-        update: updateCommand,
-        reinstall: reinstallCommand,
-        search: searchCommand,
-        show: showCommand,
-        clone: cloneCommand,
-        sources: sourcesCommand,
-        config: configCommand,
-    },
-});
-const SEARCH_USAGE_MODES = ["none", "both", "item", "guide"];
-const SEARCH_SOURCES = ["local", "registry", "both"];
-const CONFIG_SUBCOMMAND_SET = new Set(["list", "get", "set", "unset", "providers", "use"]);
-// Note: citty reads process.argv directly, so we must normalize it in-place.
-// This is done once at startup before runMain.
-normalizeConfigArgv(process.argv);
-runMain(main);
-function parseSearchUsageMode(value) {
-    if (SEARCH_USAGE_MODES.includes(value))
-        return value;
-    throw new Error(`Invalid value for --usage: ${value}. Expected one of: ${SEARCH_USAGE_MODES.join("|")}`);
-}
-function parseSearchSource(value) {
-    if (SEARCH_SOURCES.includes(value))
-        return value;
-    throw new Error(`Invalid value for --source: ${value}. Expected one of: ${SEARCH_SOURCES.join("|")}`);
-}
-async function runWithJsonErrors(fn) {
-    try {
-        await fn();
-    }
-    catch (error) {
-        const message = error instanceof Error ? error.message : String(error);
-        const hint = buildHint(message);
-        console.error(JSON.stringify({ ok: false, error: message, hint }, null, 2));
-        process.exit(1);
-    }
-}
-function buildHint(message) {
-    if (message.includes("AKM_STASH_DIR"))
-        return "Run `akm init` or set AKM_STASH_DIR to a valid directory.";
-    if (message.includes("Either <target> or --all is required"))
-        return "Use `akm update --all` or pass a target like `akm update npm:@scope/pkg`.";
-    if (message.includes("Specify either <target> or --all"))
-        return "Use only one: a positional target or `--all`.";
-    if (message.includes("No installed registry entry matched target"))
-        return "Run `akm list` to view installed ids/refs, then retry with one of those values.";
-    if (message.includes("Invalid value for --source"))
-        return "Pick one of: local, registry, both.";
-    if (message.includes("Invalid value for --usage"))
-        return "Pick one of: none, both, item, guide.";
-    if (message.includes("expected JSON object with endpoint and model")) {
-        return "Quote JSON values in your shell, for example: akm config set embedding '{\"endpoint\":\"http://localhost:11434/v1/embeddings\",\"model\":\"nomic-embed-text\"}'.";
-    }
-    return undefined;
-}
-function parseProviderScope(value) {
-    if (value === "embedding" || value === "llm")
-        return value;
-    throw new Error(`Invalid provider scope: ${value}. Expected one of: embedding|llm`);
-}
-function hasConfigSubcommand(args) {
-    const command = Array.isArray(args._) ? args._[0] : undefined;
-    return typeof command === "string" && CONFIG_SUBCOMMAND_SET.has(command);
-}
-/**
- * Mutate argv before citty parses it so git-style config forms like
- * `akm config llm.maxTokens 512` and `akm config --get llm.maxTokens`
- * are normalized into the existing config subcommands.
- */
-function normalizeConfigArgv(argv) {
-    const [, , command, argAfterCommand, argAfterKey, ...rest] = argv;
-    if (command !== "config")
-        return;
-    if (!argAfterCommand)
-        return;
-    if (argAfterCommand === "--list") {
-        argv.splice(3, argv.length - 3, "list");
-        return;
-    }
-    if (argAfterCommand === "--get" && argAfterKey) {
-        argv.splice(3, argv.length - 3, "get", argAfterKey, ...rest);
-        return;
-    }
-    if (argAfterCommand === "--unset" && argAfterKey) {
-        argv.splice(3, argv.length - 3, "unset", argAfterKey, ...rest);
-        return;
-    }
-    if (argAfterCommand.startsWith("-"))
-        return;
-    if (CONFIG_SUBCOMMAND_SET.has(argAfterCommand))
-        return;
-    // A single arg after `config` behaves like `git config <key>` and reads the value.
-    if (argAfterKey === undefined) {
-        argv.splice(3, argv.length - 3, "get", argAfterCommand);
-        return;
-    }
-    argv.splice(3, argv.length - 3, "set", argAfterCommand, argAfterKey, ...rest);
-}

package/dist/src/common.d.ts

@@ -1,13 +0,0 @@
-export type AgentikitAssetType = "tool" | "skill" | "command" | "agent" | "knowledge" | "script";
-export declare const IS_WINDOWS: boolean;
-export { SCRIPT_EXTENSIONS, TYPE_DIRS } from "./asset-spec";
-export declare function isAssetType(type: string): type is AgentikitAssetType;
-export declare function resolveStashDir(): string;
-export declare function toPosix(input: string): string;
-export declare function hasErrnoCode(error: unknown, code: string): boolean;
-export declare function isWithin(candidate: string, root: string): boolean;
-/**
- * Fetch with an AbortController timeout.
- * Defaults to 30 seconds if no timeout is specified.
- */
-export declare function fetchWithTimeout(url: string, opts?: RequestInit, timeoutMs?: number): Promise<Response>;

package/dist/src/common.js

@@ -1,60 +0,0 @@
-import fs from "node:fs";
-import path from "node:path";
-import { TYPE_DIRS } from "./asset-spec";
-// ── Constants ───────────────────────────────────────────────────────────────
-export const IS_WINDOWS = process.platform === "win32";
-export { SCRIPT_EXTENSIONS, TYPE_DIRS } from "./asset-spec";
-// ── Validators ──────────────────────────────────────────────────────────────
-export function isAssetType(type) {
-    return type in TYPE_DIRS;
-}
-// ── Utilities ───────────────────────────────────────────────────────────────
-export function resolveStashDir() {
-    const raw = process.env.AKM_STASH_DIR?.trim();
-    if (!raw) {
-        throw new Error("AKM_STASH_DIR is not set. Set it to your Agentikit stash path.");
-    }
-    const stashDir = path.resolve(raw);
-    let stat;
-    try {
-        stat = fs.statSync(stashDir);
-    }
-    catch {
-        throw new Error(`Unable to read AKM_STASH_DIR at "${stashDir}".`);
-    }
-    if (!stat.isDirectory()) {
-        throw new Error(`AKM_STASH_DIR must point to a directory: "${stashDir}".`);
-    }
-    return stashDir;
-}
-export function toPosix(input) {
-    return input.replace(/\\/g, "/");
-}
-export function hasErrnoCode(error, code) {
-    if (typeof error !== "object" || error === null || !("code" in error))
-        return false;
-    return error.code === code;
-}
-export function isWithin(candidate, root) {
-    const normalizedRoot = normalizeFsPathForComparison(path.resolve(root));
-    const normalizedCandidate = normalizeFsPathForComparison(path.resolve(candidate));
-    const rel = path.relative(normalizedRoot, normalizedCandidate);
-    return rel === "" || (!rel.startsWith("..") && !path.isAbsolute(rel));
-}
-function normalizeFsPathForComparison(value) {
-    return process.platform === "win32" ? value.toLowerCase() : value;
-}
-/**
- * Fetch with an AbortController timeout.
- * Defaults to 30 seconds if no timeout is specified.
- */
-export async function fetchWithTimeout(url, opts, timeoutMs = 30_000) {
-    const controller = new AbortController();
-    const timer = setTimeout(() => controller.abort(), timeoutMs);
-    try {
-        return await fetch(url, { ...opts, signal: controller.signal });
-    }
-    finally {
-        clearTimeout(timer);
-    }
-}

package/dist/src/config-cli.d.ts

@@ -1,9 +0,0 @@
-import { type AgentikitConfig } from "./config";
-export type ConfigProviderScope = "embedding" | "llm";
-export declare function parseConfigValue(key: string, value: string): Partial<AgentikitConfig>;
-export declare function getConfigValue(config: AgentikitConfig, key: string): unknown;
-export declare function setConfigValue(config: AgentikitConfig, key: string, rawValue: string): AgentikitConfig;
-export declare function unsetConfigValue(config: AgentikitConfig, key: string): AgentikitConfig;
-export declare function listConfig(config: AgentikitConfig): Record<string, unknown>;
-export declare function listProviders(scope: ConfigProviderScope, config: AgentikitConfig): Array<Record<string, unknown>>;
-export declare function useProvider(config: AgentikitConfig, scope: ConfigProviderScope, providerName: string): AgentikitConfig;

package/dist/src/config.d.ts

@@ -1,50 +0,0 @@
-import type { RegistryInstalledEntry } from "./registry-types";
-export interface EmbeddingConnectionConfig {
-    /** Provider name for display/CLI switching (e.g. "openai", "ollama") */
-    provider?: string;
-    /** OpenAI-compatible embeddings endpoint (e.g. "http://localhost:11434/v1/embeddings") */
-    endpoint: string;
-    /** Model name to use for embeddings (e.g. "nomic-embed-text") */
-    model: string;
-    /** Optional output dimension for providers that support it */
-    dimension?: number;
-    /** Optional API key for authenticated endpoints */
-    apiKey?: string;
-}
-export interface LlmConnectionConfig {
-    /** Provider name for display/CLI switching (e.g. "openai", "ollama") */
-    provider?: string;
-    /** OpenAI-compatible chat completions endpoint (e.g. "http://localhost:11434/v1/chat/completions") */
-    endpoint: string;
-    /** Model name to use (e.g. "llama3.2") */
-    model: string;
-    /** Optional sampling temperature */
-    temperature?: number;
-    /** Optional response token limit */
-    maxTokens?: number;
-    /** Optional API key for authenticated endpoints */
-    apiKey?: string;
-}
-export interface AgentikitConfig {
-    /** Whether semantic search is enabled. Default: true */
-    semanticSearch: boolean;
-    /** User-mounted read-only stash directories */
-    mountedStashDirs: string[];
-    /** OpenAI-compatible embedding endpoint config. If not set, uses local @xenova/transformers */
-    embedding?: EmbeddingConnectionConfig;
-    /** OpenAI-compatible LLM endpoint config for metadata generation. If not set, uses heuristic generation */
-    llm?: LlmConnectionConfig;
-    /** Installed registry sources and local cache metadata */
-    registry?: RegistryConfig;
-    /** Registry index URLs for kit discovery. Default: official agentikit-registry on GitHub */
-    registryUrls?: string[];
-}
-export interface RegistryConfig {
-    installed: RegistryInstalledEntry[];
-}
-export declare const DEFAULT_CONFIG: AgentikitConfig;
-export declare function getConfigDir(env?: NodeJS.ProcessEnv, platform?: NodeJS.Platform): string;
-export declare function getConfigPath(): string;
-export declare function loadConfig(): AgentikitConfig;
-export declare function saveConfig(config: AgentikitConfig): void;
-export declare function updateConfig(partial: Partial<AgentikitConfig>): AgentikitConfig;

package/dist/src/db.d.ts

@@ -1,46 +0,0 @@
-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/embedder.d.ts

@@ -1,10 +0,0 @@
-import type { EmbeddingConnectionConfig } from "./config";
-export type EmbeddingVector = number[];
-/**
- * Generate an embedding for the given text.
- * If embeddingConfig is provided, uses the configured OpenAI-compatible endpoint.
- * Otherwise falls back to local @xenova/transformers.
- */
-export declare function embed(text: string, embeddingConfig?: EmbeddingConnectionConfig): Promise<EmbeddingVector>;
-export declare function cosineSimilarity(a: EmbeddingVector, b: EmbeddingVector): number;
-export declare function isEmbeddingAvailable(embeddingConfig?: EmbeddingConnectionConfig): Promise<boolean>;