agentikit 0.0.8 → 0.0.12

package/dist/src/config-cli.js

@@ -0,0 +1,473 @@
+import { DEFAULT_CONFIG, } from "./config";
+import { EMBEDDING_DIM } from "./db";
+const LOCAL_EMBEDDING_MODEL = "Xenova/all-MiniLM-L6-v2";
+const DEFAULT_LLM_TEMPERATURE = 0.3;
+const DEFAULT_LLM_MAX_TOKENS = 512;
+const EMBEDDING_PROVIDER_PRESETS = {
+    local: {
+        name: "local",
+        description: "Built-in local embeddings via @xenova/transformers.",
+    },
+    ollama: {
+        name: "ollama",
+        description: "Local Ollama embedding endpoint.",
+        config: {
+            provider: "ollama",
+            endpoint: "http://localhost:11434/v1/embeddings",
+            model: "nomic-embed-text",
+            dimension: EMBEDDING_DIM,
+        },
+    },
+    openai: {
+        name: "openai",
+        description: "OpenAI-compatible embeddings API.",
+        config: {
+            provider: "openai",
+            endpoint: "https://api.openai.com/v1/embeddings",
+            model: "text-embedding-3-small",
+            dimension: EMBEDDING_DIM,
+        },
+    },
+};
+const LLM_PROVIDER_PRESETS = {
+    disabled: {
+        name: "disabled",
+        description: "Disable LLM metadata enhancement.",
+    },
+    ollama: {
+        name: "ollama",
+        description: "Local Ollama chat completions endpoint.",
+        config: {
+            provider: "ollama",
+            endpoint: "http://localhost:11434/v1/chat/completions",
+            model: "llama3.2",
+            temperature: DEFAULT_LLM_TEMPERATURE,
+            maxTokens: DEFAULT_LLM_MAX_TOKENS,
+        },
+    },
+    openai: {
+        name: "openai",
+        description: "OpenAI-compatible chat completions API.",
+        config: {
+            provider: "openai",
+            endpoint: "https://api.openai.com/v1/chat/completions",
+            model: "gpt-4o-mini",
+            temperature: DEFAULT_LLM_TEMPERATURE,
+            maxTokens: DEFAULT_LLM_MAX_TOKENS,
+        },
+    },
+};
+export function parseConfigValue(key, value) {
+    switch (key) {
+        case "semanticSearch":
+            if (value !== "true" && value !== "false") {
+                throw new Error(`Invalid value for semanticSearch: expected "true" or "false"`);
+            }
+            return { semanticSearch: value === "true" };
+        case "mountedStashDirs":
+            try {
+                const parsed = JSON.parse(value);
+                if (!Array.isArray(parsed))
+                    throw new Error("expected JSON array");
+                return { mountedStashDirs: parsed.filter((d) => typeof d === "string") };
+            }
+            catch {
+                throw new Error(`Invalid value for mountedStashDirs: expected JSON array (e.g. '["/path/a","/path/b"]')`);
+            }
+        case "embedding":
+            return { embedding: parseEmbeddingConnectionValue(value) };
+        case "llm":
+            return { llm: parseLlmConnectionValue(value) };
+        default:
+            throw new Error(`Unknown config key: ${key}`);
+    }
+}
+export function getConfigValue(config, key) {
+    switch (key) {
+        case "semanticSearch":
+            return config.semanticSearch;
+        case "mountedStashDirs":
+            return [...config.mountedStashDirs];
+        case "embedding":
+            return maskSecrets(getEmbeddingDisplayConfig(config));
+        case "embedding.provider":
+            return getEmbeddingProvider(config);
+        case "embedding.endpoint":
+            return getEmbeddingDisplayConfig(config).endpoint ?? null;
+        case "embedding.model":
+            return getEmbeddingDisplayConfig(config).model ?? null;
+        case "embedding.dimension":
+            return getEmbeddingDisplayConfig(config).dimension ?? null;
+        case "embedding.apiKey":
+            return maskSecret(getEmbeddingDisplayConfig(config).apiKey) ?? null;
+        case "llm":
+            return maskSecrets(getLlmDisplayConfig(config));
+        case "llm.provider":
+            return getLlmProvider(config);
+        case "llm.endpoint":
+            return getLlmDisplayConfig(config).endpoint ?? null;
+        case "llm.model":
+            return getLlmDisplayConfig(config).model ?? null;
+        case "llm.temperature":
+            return getLlmDisplayConfig(config).temperature ?? null;
+        case "llm.maxTokens":
+            return getLlmDisplayConfig(config).maxTokens ?? null;
+        case "llm.apiKey":
+            return maskSecret(getLlmDisplayConfig(config).apiKey) ?? null;
+        default:
+            throw new Error(`Unknown config key: ${key}`);
+    }
+}
+export function setConfigValue(config, key, rawValue) {
+    switch (key) {
+        case "semanticSearch":
+        case "mountedStashDirs":
+        case "embedding":
+        case "llm":
+            return { ...config, ...parseConfigValue(key, rawValue) };
+        case "embedding.provider":
+            return useProvider(config, "embedding", rawValue);
+        case "embedding.endpoint":
+            return {
+                ...config,
+                embedding: {
+                    ...requireEmbeddingConfig(config),
+                    endpoint: requireNonEmptyString(rawValue, key),
+                },
+            };
+        case "embedding.model":
+            return {
+                ...config,
+                embedding: {
+                    ...requireEmbeddingConfig(config),
+                    model: requireNonEmptyString(rawValue, key),
+                },
+            };
+        case "embedding.dimension":
+            return {
+                ...config,
+                embedding: {
+                    ...requireEmbeddingConfig(config),
+                    dimension: parsePositiveInteger(rawValue, key),
+                },
+            };
+        case "embedding.apiKey":
+            return {
+                ...config,
+                embedding: {
+                    ...requireEmbeddingConfig(config),
+                    apiKey: requireNonEmptyString(rawValue, key),
+                },
+            };
+        case "llm.provider":
+            return useProvider(config, "llm", rawValue);
+        case "llm.endpoint":
+            return {
+                ...config,
+                llm: {
+                    ...requireLlmConfig(config),
+                    endpoint: requireNonEmptyString(rawValue, key),
+                },
+            };
+        case "llm.model":
+            return {
+                ...config,
+                llm: {
+                    ...requireLlmConfig(config),
+                    model: requireNonEmptyString(rawValue, key),
+                },
+            };
+        case "llm.temperature":
+            return {
+                ...config,
+                llm: {
+                    ...requireLlmConfig(config),
+                    temperature: parseNumber(rawValue, key),
+                },
+            };
+        case "llm.maxTokens":
+            return {
+                ...config,
+                llm: {
+                    ...requireLlmConfig(config),
+                    maxTokens: parsePositiveInteger(rawValue, key),
+                },
+            };
+        case "llm.apiKey":
+            return {
+                ...config,
+                llm: {
+                    ...requireLlmConfig(config),
+                    apiKey: requireNonEmptyString(rawValue, key),
+                },
+            };
+        default:
+            throw new Error(`Unknown config key: ${key}`);
+    }
+}
+export function unsetConfigValue(config, key) {
+    switch (key) {
+        case "embedding":
+            return { ...config, embedding: undefined };
+        case "embedding.apiKey":
+            if (!config.embedding)
+                return config;
+            return { ...config, embedding: omitKey(config.embedding, "apiKey") };
+        case "embedding.dimension":
+            if (!config.embedding)
+                return config;
+            return { ...config, embedding: omitKey(config.embedding, "dimension") };
+        case "embedding.provider":
+            if (!config.embedding)
+                return config;
+            return { ...config, embedding: omitKey(config.embedding, "provider") };
+        case "llm":
+            return { ...config, llm: undefined };
+        case "llm.apiKey":
+            if (!config.llm)
+                return config;
+            return { ...config, llm: omitKey(config.llm, "apiKey") };
+        case "llm.temperature":
+            if (!config.llm)
+                return config;
+            return { ...config, llm: omitKey(config.llm, "temperature") };
+        case "llm.maxTokens":
+            if (!config.llm)
+                return config;
+            return { ...config, llm: omitKey(config.llm, "maxTokens") };
+        case "llm.provider":
+            if (!config.llm)
+                return config;
+            return { ...config, llm: omitKey(config.llm, "provider") };
+        default:
+            throw new Error(`Unknown or unsupported unset key: ${key}`);
+    }
+}
+export function listConfig(config) {
+    return {
+        ...DEFAULT_CONFIG,
+        ...maskSecrets(config),
+        embedding: maskSecrets(getEmbeddingDisplayConfig(config)),
+        llm: maskSecrets(getLlmDisplayConfig(config)),
+    };
+}
+export function listProviders(scope, config) {
+    const currentProvider = scope === "embedding" ? getEmbeddingProvider(config) : getLlmProvider(config);
+    const presets = scope === "embedding" ? EMBEDDING_PROVIDER_PRESETS : LLM_PROVIDER_PRESETS;
+    return Object.values(presets).map((preset) => ({
+        name: preset.name,
+        description: preset.description,
+        current: preset.name === currentProvider,
+        ...(preset.config ? maskSecrets(preset.config) : {}),
+    }));
+}
+export function useProvider(config, scope, providerName) {
+    if (scope === "embedding") {
+        const preset = EMBEDDING_PROVIDER_PRESETS[providerName];
+        if (!preset) {
+            throw new Error(`Unknown embedding provider: ${providerName}`);
+        }
+        if (!preset.config) {
+            return { ...config, embedding: undefined };
+        }
+        return { ...config, embedding: { ...preset.config } };
+    }
+    const preset = LLM_PROVIDER_PRESETS[providerName];
+    if (!preset) {
+        throw new Error(`Unknown llm provider: ${providerName}`);
+    }
+    if (!preset.config) {
+        return { ...config, llm: undefined };
+    }
+    return { ...config, llm: { ...preset.config } };
+}
+function getEmbeddingProvider(config) {
+    if (!config.embedding)
+        return "local";
+    if (config.embedding.provider)
+        return config.embedding.provider;
+    if (matchesPreset(config.embedding, EMBEDDING_PROVIDER_PRESETS.ollama.config))
+        return "ollama";
+    if (matchesPreset(config.embedding, EMBEDDING_PROVIDER_PRESETS.openai.config))
+        return "openai";
+    return "custom";
+}
+function getLlmProvider(config) {
+    if (!config.llm)
+        return "disabled";
+    if (config.llm.provider)
+        return config.llm.provider;
+    if (matchesPreset(config.llm, LLM_PROVIDER_PRESETS.ollama.config))
+        return "ollama";
+    if (matchesPreset(config.llm, LLM_PROVIDER_PRESETS.openai.config))
+        return "openai";
+    return "custom";
+}
+function getEmbeddingDisplayConfig(config) {
+    if (!config.embedding) {
+        return {
+            provider: "local",
+            model: LOCAL_EMBEDDING_MODEL,
+            dimension: EMBEDDING_DIM,
+        };
+    }
+    return {
+        provider: getEmbeddingProvider(config),
+        endpoint: config.embedding.endpoint,
+        model: config.embedding.model,
+        dimension: config.embedding.dimension,
+        apiKey: config.embedding.apiKey,
+    };
+}
+function getLlmDisplayConfig(config) {
+    if (!config.llm) {
+        return {
+            provider: "disabled",
+        };
+    }
+    return {
+        provider: getLlmProvider(config),
+        endpoint: config.llm.endpoint,
+        model: config.llm.model,
+        temperature: config.llm.temperature ?? DEFAULT_LLM_TEMPERATURE,
+        maxTokens: config.llm.maxTokens ?? DEFAULT_LLM_MAX_TOKENS,
+        apiKey: config.llm.apiKey,
+    };
+}
+function parseEmbeddingConnectionValue(value) {
+    if (value === "null" || value === "")
+        return undefined;
+    const parsed = parseJsonObject(value, "embedding", {
+        endpoint: "http://localhost:11434/v1/embeddings",
+        model: "nomic-embed-text",
+    });
+    const result = {
+        endpoint: asRequiredString(parsed.endpoint, "embedding", "endpoint"),
+        model: asRequiredString(parsed.model, "embedding", "model"),
+    };
+    if (typeof parsed.provider === "string" && parsed.provider)
+        result.provider = parsed.provider;
+    if (parsed.dimension !== undefined)
+        result.dimension = parseUnknownPositiveInteger(parsed.dimension, "embedding.dimension");
+    if (typeof parsed.apiKey === "string" && parsed.apiKey)
+        result.apiKey = parsed.apiKey;
+    return result;
+}
+function parseLlmConnectionValue(value) {
+    if (value === "null" || value === "")
+        return undefined;
+    const parsed = parseJsonObject(value, "llm", {
+        endpoint: "http://localhost:11434/v1/chat/completions",
+        model: "llama3.2",
+    });
+    const result = {
+        endpoint: asRequiredString(parsed.endpoint, "llm", "endpoint"),
+        model: asRequiredString(parsed.model, "llm", "model"),
+    };
+    if (typeof parsed.provider === "string" && parsed.provider)
+        result.provider = parsed.provider;
+    if (parsed.temperature !== undefined)
+        result.temperature = parseUnknownNumber(parsed.temperature, "llm.temperature");
+    if (parsed.maxTokens !== undefined)
+        result.maxTokens = parseUnknownPositiveInteger(parsed.maxTokens, "llm.maxTokens");
+    if (typeof parsed.apiKey === "string" && parsed.apiKey)
+        result.apiKey = parsed.apiKey;
+    return result;
+}
+function parseJsonObject(value, key, example) {
+    let parsed;
+    try {
+        parsed = JSON.parse(value);
+    }
+    catch {
+        throw new Error(`Invalid value for ${key}: expected JSON object with endpoint and model`
+            + ` (e.g. '{"endpoint":"${example.endpoint}","model":"${example.model}"}')`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Invalid value for ${key}: expected a JSON object`);
+    }
+    return parsed;
+}
+function asRequiredString(value, key, field) {
+    if (typeof value !== "string" || !value) {
+        throw new Error(`Invalid value for ${key}: "${field}" is a required string field`);
+    }
+    return value;
+}
+function requireEmbeddingConfig(config) {
+    if (!config.embedding) {
+        throw new Error("Embedding provider is using the built-in local default. Run `akm config use embedding <provider>` first.");
+    }
+    return config.embedding;
+}
+function requireLlmConfig(config) {
+    if (!config.llm) {
+        throw new Error("LLM provider is disabled. Run `akm config use llm <provider>` first.");
+    }
+    return config.llm;
+}
+function requireNonEmptyString(value, key) {
+    if (!value) {
+        throw new Error(`Invalid value for ${key}: expected a non-empty string`);
+    }
+    return value;
+}
+function parseNumber(value, key) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed)) {
+        throw new Error(`Invalid value for ${key}: expected a number`);
+    }
+    return parsed;
+}
+function parsePositiveInteger(value, key) {
+    const trimmed = value.trim();
+    if (!/^[1-9]\d*$/.test(trimmed)) {
+        throw new Error(`Invalid value for ${key}: expected a positive integer`);
+    }
+    const parsed = Number(trimmed);
+    if (!Number.isFinite(parsed) || !Number.isInteger(parsed) || parsed <= 0) {
+        throw new Error(`Invalid value for ${key}: expected a positive integer`);
+    }
+    return parsed;
+}
+function parseUnknownNumber(value, key) {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+        throw new Error(`Invalid value for ${key}: expected a number`);
+    }
+    return value;
+}
+function parseUnknownPositiveInteger(value, key) {
+    if (typeof value !== "number" ||
+        !Number.isFinite(value) ||
+        !Number.isInteger(value) ||
+        value <= 0) {
+        throw new Error(`Invalid value for ${key}: expected a positive integer`);
+    }
+    return value;
+}
+function matchesPreset(current, preset) {
+    if (!preset)
+        return false;
+    return current.endpoint === preset.endpoint && current.model === preset.model;
+}
+function omitKey(value, key) {
+    const copy = { ...value };
+    delete copy[key];
+    return copy;
+}
+function maskSecret(value) {
+    return typeof value === "string" && value ? "***" : value;
+}
+function maskSecrets(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => maskSecrets(item));
+    }
+    if (value && typeof value === "object") {
+        const result = {};
+        for (const [key, entry] of Object.entries(value)) {
+            result[key] = key === "apiKey" ? maskSecret(entry) : maskSecrets(entry);
+        }
+        return result;
+    }
+    return value;
+}

package/dist/src/config.d.ts

@@ -1,31 +1,50 @@
+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;
-    /** Additional stash directories to search alongside the primary one */
-    additionalStashDirs: string[];
+    /** 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 getConfigPath(stashDir: string): string;
-export declare function loadConfig(stashDir?: string): AgentikitConfig;
-export declare function saveConfig(config: AgentikitConfig, stashDir?: string): void;
-export declare function updateConfig(partial: Partial<AgentikitConfig>, stashDir?: string): 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;