agentikit 0.0.7 → 0.0.9

package/dist/src/cli.js

@@ -1,62 +1,273 @@
 #!/usr/bin/env node
-import { agentikitSearch, agentikitOpen, agentikitRun, agentikitInit } from "./stash";
+import { defineCommand, runMain } from "citty";
+import { agentikitAdd, agentikitList, agentikitReinstall, agentikitRemove, agentikitSearch, agentikitShow, agentikitUpdate, } from "./stash";
+import { agentikitInit } from "./init";
 import { agentikitIndex } from "./indexer";
-const args = process.argv.slice(2);
-const command = args[0];
-function flag(name) {
-    const idx = args.indexOf(name);
-    return idx >= 0 && idx + 1 < args.length ? args[idx + 1] : undefined;
+import { loadConfig, updateConfig } from "./config";
+import { resolveStashDir } from "./common";
+const initCommand = defineCommand({
+    meta: { name: "init", description: "Initialize agentikit stash directory and set AGENTIKIT_STASH_DIR" },
+    run() {
+        return runWithJsonErrors(() => {
+            const result = 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|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 into the stash" },
+    args: {
+        ref: { type: "positional", description: "Registry ref (npm package, owner/repo, or github URL)", 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)" },
+    },
+    run({ args }) {
+        return runWithJsonErrors(() => {
+            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(agentikitShow({ ref: args.ref, view }), null, 2));
+        });
+    },
+});
+const configCommand = defineCommand({
+    meta: { name: "config", description: "Show or update configuration" },
+    args: {
+        set: { type: "string", description: "Update a config key (key=value format)" },
+    },
+    run({ args }) {
+        return runWithJsonErrors(() => {
+            const stashDir = resolveStashDir();
+            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 = updateConfig(partial, stashDir);
+                console.log(JSON.stringify(config, null, 2));
+            }
+            else {
+                const config = loadConfig(stashDir);
+                console.log(JSON.stringify(config, null, 2));
+            }
+        });
+    },
+});
+const main = defineCommand({
+    meta: {
+        name: "akm",
+        description: "CLI tool to search, open, and run extension assets from an agentikit stash directory.",
+    },
+    subCommands: {
+        init: initCommand,
+        index: indexCommand,
+        add: addCommand,
+        list: listCommand,
+        remove: removeCommand,
+        update: updateCommand,
+        reinstall: reinstallCommand,
+        search: searchCommand,
+        show: showCommand,
+        config: configCommand,
+    },
+});
+runMain(main);
+const SEARCH_USAGE_MODES = ["none", "both", "item", "guide"];
+const SEARCH_SOURCES = ["local", "registry", "both"];
+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 usage() {
-    console.error("Usage: agentikit <init|search|open|run> [options]");
-    console.error("");
-    console.error("Commands:");
-    console.error("  init                 Initialize agentikit stash directory and set AGENTIKIT_STASH_DIR");
-    console.error("  index                Build search index with metadata generation");
-    console.error("  search [query]       Search the stash (--type tool|skill|command|agent|any) (--limit N)");
-    console.error("  open <type:name>     Open a stash asset by ref");
-    console.error("  run <type:name>      Run a tool by ref");
-    process.exit(1);
+function parseSearchSource(value) {
+    if (SEARCH_SOURCES.includes(value))
+        return value;
+    throw new Error(`Invalid value for --source: ${value}. Expected one of: ${SEARCH_SOURCES.join("|")}`);
 }
-switch (command) {
-    case "init": {
-        const result = agentikitInit();
-        console.log(JSON.stringify(result, null, 2));
-        break;
-    }
-    case "index": {
-        const result = agentikitIndex();
-        console.log(JSON.stringify(result, null, 2));
-        break;
-    }
-    case "search": {
-        const query = args.find((a, i) => i > 0 && !a.startsWith("--") && args[i - 1] !== "--type" && args[i - 1] !== "--limit") ?? "";
-        const type = flag("--type");
-        const limitStr = flag("--limit");
-        const limit = limitStr ? parseInt(limitStr, 10) : undefined;
-        console.log(JSON.stringify(agentikitSearch({ query, type, limit }), null, 2));
-        break;
-    }
-    case "open": {
-        const ref = args[1];
-        if (!ref) {
-            console.error("Error: missing ref argument\n");
-            usage();
-        }
-        console.log(JSON.stringify(agentikitOpen({ ref }), null, 2));
-        break;
-    }
-    case "run": {
-        const ref = args[1];
-        if (!ref) {
-            console.error("Error: missing ref argument\n");
-            usage();
-        }
-        const result = agentikitRun({ ref });
-        console.log(JSON.stringify(result, null, 2));
-        process.exit(result.exitCode);
-        break;
-    }
-    default:
-        usage();
+function parseConnectionValue(key, value, exampleEndpoint, exampleModel) {
+    if (value === "null" || value === "")
+        return undefined;
+    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":"${exampleEndpoint}","model":"${exampleModel}"}')`);
+    }
+    if (typeof parsed !== "object" || parsed === null || Array.isArray(parsed)) {
+        throw new Error(`Invalid value for ${key}: expected a JSON object`);
+    }
+    const obj = parsed;
+    if (typeof obj.endpoint !== "string" || !obj.endpoint || typeof obj.model !== "string" || !obj.model) {
+        throw new Error(`Invalid value for ${key}: "endpoint" and "model" are required string fields`);
+    }
+    const result = {
+        endpoint: obj.endpoint,
+        model: obj.model,
+    };
+    if (typeof obj.apiKey === "string" && obj.apiKey) {
+        result.apiKey = obj.apiKey;
+    }
+    return result;
+}
+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 "additionalStashDirs":
+            try {
+                const parsed = JSON.parse(value);
+                if (!Array.isArray(parsed))
+                    throw new Error("expected JSON array");
+                return { additionalStashDirs: parsed.filter((d) => typeof d === "string") };
+            }
+            catch {
+                throw new Error(`Invalid value for additionalStashDirs: expected JSON array (e.g. '["/path/a","/path/b"]')`);
+            }
+        case "embedding":
+            return { embedding: parseConnectionValue("embedding", value, "http://localhost:11434/v1/embeddings", "nomic-embed-text") };
+        case "llm":
+            return { llm: parseConnectionValue("llm", value, "http://localhost:11434/v1/chat/completions", "llama3.2") };
+        default:
+            throw new Error(`Unknown config key: ${key}`);
+    }
+}
+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("AGENTIKIT_STASH_DIR"))
+        return "Run `akm init` or set AGENTIKIT_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.";
+    return undefined;
 }

package/dist/src/common.d.ts

@@ -0,0 +1,8 @@
+export type AgentikitAssetType = "tool" | "skill" | "command" | "agent" | "knowledge";
+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;

package/dist/src/common.js

@@ -0,0 +1,46 @@
+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.AGENTIKIT_STASH_DIR?.trim();
+    if (!raw) {
+        throw new Error("AGENTIKIT_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 AGENTIKIT_STASH_DIR at "${stashDir}".`);
+    }
+    if (!stat.isDirectory()) {
+        throw new Error(`AGENTIKIT_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;
+}

package/dist/src/config.d.ts

@@ -0,0 +1,37 @@
+import type { RegistryInstalledEntry } from "./registry-types";
+export interface EmbeddingConnectionConfig {
+    /** 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 API key for authenticated endpoints */
+    apiKey?: string;
+}
+export interface LlmConnectionConfig {
+    /** 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 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[];
+    /** 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;
+}
+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;

package/dist/src/config.js

@@ -0,0 +1,124 @@
+import fs from "node:fs";
+import path from "node:path";
+import { resolveStashDir } from "./common";
+// ── Defaults ────────────────────────────────────────────────────────────────
+export const DEFAULT_CONFIG = {
+    semanticSearch: true,
+    additionalStashDirs: [],
+};
+// ── Paths ───────────────────────────────────────────────────────────────────
+export function getConfigPath(stashDir) {
+    return path.join(stashDir, "config.json");
+}
+// ── Load / Save / Update ────────────────────────────────────────────────────
+export function loadConfig(stashDir) {
+    const dir = stashDir ?? resolveStashDir();
+    const configPath = getConfigPath(dir);
+    let raw;
+    try {
+        raw = JSON.parse(fs.readFileSync(configPath, "utf8"));
+        if (typeof raw !== "object" || raw === null || Array.isArray(raw)) {
+            return { ...DEFAULT_CONFIG };
+        }
+    }
+    catch {
+        return { ...DEFAULT_CONFIG };
+    }
+    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");
+}
+export function updateConfig(partial, stashDir) {
+    const dir = stashDir ?? resolveStashDir();
+    const current = loadConfig(dir);
+    const merged = { ...current, ...partial };
+    saveConfig(merged, dir);
+    return merged;
+}
+// ── Helpers ─────────────────────────────────────────────────────────────────
+function pickKnownKeys(raw) {
+    const config = { ...DEFAULT_CONFIG };
+    if (typeof raw.semanticSearch === "boolean") {
+        config.semanticSearch = raw.semanticSearch;
+    }
+    if (Array.isArray(raw.additionalStashDirs)) {
+        config.additionalStashDirs = raw.additionalStashDirs.filter((d) => typeof d === "string");
+    }
+    const embedding = parseConnectionConfig(raw.embedding);
+    if (embedding)
+        config.embedding = embedding;
+    const llm = parseConnectionConfig(raw.llm);
+    if (llm)
+        config.llm = llm;
+    const registry = parseRegistryConfig(raw.registry);
+    if (registry)
+        config.registry = registry;
+    return config;
+}
+function parseConnectionConfig(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.apiKey === "string" && obj.apiKey) {
+        result.apiKey = obj.apiKey;
+    }
+    return result;
+}
+function parseRegistryConfig(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    if (!Array.isArray(obj.installed))
+        return undefined;
+    const installed = obj.installed
+        .map((entry) => parseRegistryInstalledEntry(entry))
+        .filter((entry) => entry !== undefined);
+    return { installed };
+}
+function parseRegistryInstalledEntry(value) {
+    if (typeof value !== "object" || value === null || Array.isArray(value))
+        return undefined;
+    const obj = value;
+    const id = asNonEmptyString(obj.id);
+    const source = asRegistrySource(obj.source);
+    const ref = asNonEmptyString(obj.ref);
+    const artifactUrl = asNonEmptyString(obj.artifactUrl);
+    const stashRoot = asNonEmptyString(obj.stashRoot);
+    const cacheDir = asNonEmptyString(obj.cacheDir);
+    const installedAt = asNonEmptyString(obj.installedAt);
+    if (!id || !source || !ref || !artifactUrl || !stashRoot || !cacheDir || !installedAt)
+        return undefined;
+    const entry = {
+        id,
+        source,
+        ref,
+        artifactUrl,
+        stashRoot,
+        cacheDir,
+        installedAt,
+    };
+    const resolvedVersion = asNonEmptyString(obj.resolvedVersion);
+    if (resolvedVersion)
+        entry.resolvedVersion = resolvedVersion;
+    const resolvedRevision = asNonEmptyString(obj.resolvedRevision);
+    if (resolvedRevision)
+        entry.resolvedRevision = resolvedRevision;
+    return entry;
+}
+function asNonEmptyString(value) {
+    return typeof value === "string" && value ? value : undefined;
+}
+function asRegistrySource(value) {
+    return value === "npm" || value === "github" ? value : undefined;
+}

package/dist/src/embedder.d.ts

@@ -0,0 +1,10 @@
+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>;

package/dist/src/embedder.js

@@ -0,0 +1,87 @@
+// ── Singleton local embedder ────────────────────────────────────────────────
+let localEmbedder;
+async function getLocalEmbedder() {
+    if (!localEmbedder) {
+        let pipeline;
+        try {
+            const mod = await import("@xenova/transformers");
+            pipeline = mod.pipeline;
+        }
+        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");
+    }
+    return localEmbedder;
+}
+async function embedLocal(text) {
+    const model = await getLocalEmbedder();
+    const result = await model(text, { pooling: "mean", normalize: true });
+    return Array.from(result.data);
+}
+// ── OpenAI-compatible remote embedder ───────────────────────────────────────
+async function embedRemote(text, config) {
+    const headers = { "Content-Type": "application/json" };
+    if (config.apiKey) {
+        headers["Authorization"] = `Bearer ${config.apiKey}`;
+    }
+    const response = await fetch(config.endpoint, {
+        method: "POST",
+        headers,
+        body: JSON.stringify({
+            input: text,
+            model: config.model,
+        }),
+    });
+    if (!response.ok) {
+        const body = await response.text().catch(() => "");
+        throw new Error(`Embedding request failed (${response.status}): ${body}`);
+    }
+    const json = (await response.json());
+    if (!json.data?.[0]?.embedding) {
+        throw new Error("Unexpected embedding response format: missing data[0].embedding");
+    }
+    return json.data[0].embedding;
+}
+// ── Public API ──────────────────────────────────────────────────────────────
+/**
+ * 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 async function embed(text, embeddingConfig) {
+    if (embeddingConfig) {
+        return embedRemote(text, embeddingConfig);
+    }
+    return embedLocal(text);
+}
+// ── Similarity ──────────────────────────────────────────────────────────────
+export function cosineSimilarity(a, b) {
+    const len = Math.min(a.length, b.length);
+    if (len === 0)
+        return 0;
+    let dot = 0;
+    for (let i = 0; i < len; i++) {
+        dot += a[i] * b[i];
+    }
+    return dot;
+}
+// ── Availability check ──────────────────────────────────────────────────────
+export async function isEmbeddingAvailable(embeddingConfig) {
+    if (embeddingConfig) {
+        try {
+            await embedRemote("test", embeddingConfig);
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    try {
+        await getLocalEmbedder();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}