@heyamiko/amiko-cli 0.4.0 → 0.4.7

package/dist/app.js

@@ -0,0 +1,355 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useCallback, useEffect, useMemo, useState } from "react";
+import { Box, Static, Text, useApp, useInput, useStdout } from "ink";
+import { getModels, getProviders } from "@mariozechner/pi-ai";
+import { parseCommand } from "./commands.js";
+import { qmdCollectionAdd, qmdEmbed, qmdGet, qmdSearch } from "./memory/qmd.js";
+import { buildPrompt } from "./prompt.js";
+import { appendSession } from "./session.js";
+import { readWorkspaceFiles } from "./workspace.js";
+import { createPiAgent } from "./agent/piAgent.js";
+import { ModelPicker } from "./components/ModelPicker.js";
+import { saveConfigFile } from "./configFile.js";
+export function App({ config, workspace, sessionPath }) {
+    const { exit } = useApp();
+    const { stdout } = useStdout();
+    const [input, setInput] = useState("");
+    const [messages, setMessages] = useState([]);
+    const [streamingAssistant, setStreamingAssistant] = useState("");
+    const [status, setStatus] = useState("ready");
+    const [agentReady, setAgentReady] = useState(false);
+    const [currentModel, setCurrentModel] = useState(() => {
+        if (config.model)
+            return config.model;
+        if (config.modelProvider && config.modelId)
+            return `${config.modelProvider}/${config.modelId}`;
+        return "auto";
+    });
+    const [showModelPicker, setShowModelPicker] = useState(false);
+    const toolMessageIds = useMemo(() => new Set(), []);
+    const agentPromise = useMemo(() => createPiAgent(config), [
+        config.model,
+        config.modelProvider,
+        config.modelId,
+        config.thinkingLevel
+    ]);
+    useEffect(() => {
+        let mounted = true;
+        agentPromise.then((agent) => {
+            if (!mounted)
+                return;
+            setAgentReady(true);
+            if (currentModel === "auto") {
+                const value = agent.getCurrentModel?.();
+                if (value)
+                    setCurrentModel(value);
+            }
+            if (agent.onEvent) {
+                agent.onEvent((event) => {
+                    if (event?.type === "tool_execution_start") {
+                        const key = `${event.toolCallId ?? ""}:${event.toolName ?? ""}:${JSON.stringify(event.args || {})}`;
+                        if (toolMessageIds.has(key))
+                            return;
+                        toolMessageIds.add(key);
+                        const lines = [`[${event.toolName}] start`];
+                        if (event.args?.command)
+                            lines.push(`command: ${event.args.command}`);
+                        if (event.args?.cwd)
+                            lines.push(`cwd: ${event.args.cwd}`);
+                        if (event.args?.timeoutMs)
+                            lines.push(`timeoutMs: ${event.args.timeoutMs}`);
+                        pushMessage("tool", lines.join("\n"));
+                        return;
+                    }
+                    if (event?.type === "tool_execution_end") {
+                        const key = `${event.toolCallId ?? ""}:${event.toolName ?? ""}:${JSON.stringify(event.args || {})}`;
+                        if (toolMessageIds.has(key + ":end"))
+                            return;
+                        toolMessageIds.add(key + ":end");
+                        const resultText = event.result?.content
+                            ? event.result.content.map((c) => (c.text ? c.text : "")).join("\\n")
+                            : "";
+                        const trimmed = resultText.trim();
+                        const summary = trimmed.length > 0 ? trimmed : "(no output)";
+                        pushMessage("tool", `[${event.toolName}] done\n${summary}`);
+                    }
+                });
+            }
+        });
+        return () => {
+            mounted = false;
+        };
+    }, [agentPromise, currentModel]);
+    const pushMessage = useCallback((role, content) => {
+        setMessages((prev) => [...prev, { role, content }]);
+    }, []);
+    const handleSubmit = useCallback(async () => {
+        const trimmed = input.trim();
+        if (!trimmed)
+            return;
+        setInput("");
+        const command = parseCommand(trimmed);
+        if (command) {
+            await handleCommand(command.name, command.args);
+            return;
+        }
+        pushMessage("user", trimmed);
+        await appendSession(sessionPath, "user", trimmed);
+        setStatus("thinking");
+        setStreamingAssistant("");
+        const [workspaceData, agent] = await Promise.all([
+            readWorkspaceFiles(workspace),
+            agentPromise
+        ]);
+        let hits = [];
+        if (config.qmdEnabled) {
+            hits = await qmdSearch({
+                qmdBin: config.qmdBin,
+                query: trimmed,
+                limit: config.qmdLimit,
+                collection: config.qmdCollection
+            });
+        }
+        if (config.qmdFull && hits.length > 0) {
+            const expanded = [];
+            for (const hit of hits) {
+                const docId = hit.path || hit.id;
+                if (!docId) {
+                    expanded.push(hit);
+                    continue;
+                }
+                const text = await qmdGet({ qmdBin: config.qmdBin, docId, full: true });
+                expanded.push({ ...hit, snippet: text || hit.snippet });
+            }
+            hits = expanded;
+        }
+        const prompt = buildPrompt({
+            identity: workspaceData.identity,
+            personality: workspaceData.personality,
+            memory: workspaceData.memory,
+            hits
+        });
+        let assistantText = "";
+        try {
+            for await (const chunk of agent.streamReply({ prompt, userMessage: trimmed })) {
+                assistantText += chunk;
+                setStreamingAssistant((prev) => prev + chunk);
+            }
+        }
+        catch (error) {
+            const message = error.message || "unknown error";
+            assistantText += `\n[amiko] ${message}\n`;
+            setStreamingAssistant((prev) => prev + `\n[amiko] ${message}\n`);
+        }
+        if (assistantText) {
+            await appendSession(sessionPath, "assistant", assistantText);
+            pushMessage("assistant", assistantText);
+        }
+        setStreamingAssistant("");
+        setStatus("ready");
+    }, [
+        input,
+        agentPromise,
+        config.qmdBin,
+        config.qmdEnabled,
+        config.qmdLimit,
+        config.qmdFull,
+        config.qmdCollection,
+        pushMessage,
+        sessionPath,
+        workspace
+    ]);
+    const handleCommand = useCallback(async (name, args) => {
+        switch (name) {
+            case "exit":
+                exit();
+                return;
+            case "help":
+                pushMessage("assistant", "Commands: /help /exit /search <query> /memory /session /plan /identity /personality /index [collection] /model [provider[/id]]");
+                return;
+            case "memory": {
+                const data = await readWorkspaceFiles(workspace);
+                pushMessage("assistant", `MEMORY.md:\n\n${data.memory.trim() || "(empty)"}`);
+                return;
+            }
+            case "session":
+                pushMessage("assistant", `Session file: ${sessionPath}`);
+                return;
+            case "plan":
+                pushMessage("assistant", "Plan file: PLAN.md");
+                return;
+            case "identity": {
+                const data = await readWorkspaceFiles(workspace);
+                pushMessage("assistant", `IDENTITY.md:\n\n${data.identity.trim() || "(empty)"}`);
+                return;
+            }
+            case "personality": {
+                const data = await readWorkspaceFiles(workspace);
+                pushMessage("assistant", `PERSONALITY.md:\n\n${data.personality.trim() || "(empty)"}`);
+                return;
+            }
+            case "index": {
+                if (!config.qmdEnabled) {
+                    pushMessage("assistant", "QMD is disabled.");
+                    return;
+                }
+                const name = args || config.qmdCollection || "amiko";
+                const added = await qmdCollectionAdd({
+                    qmdBin: config.qmdBin,
+                    name,
+                    path: workspace.root
+                });
+                if (!added) {
+                    pushMessage("assistant", "Failed to add QMD collection.");
+                    return;
+                }
+                const embedded = await qmdEmbed({ qmdBin: config.qmdBin, collection: name });
+                pushMessage("assistant", embedded ? `Indexed QMD collection "${name}".` : `Collection "${name}" added, but embedding failed.`);
+                return;
+            }
+            case "search": {
+                if (!args) {
+                    pushMessage("assistant", "Usage: /search <query>");
+                    return;
+                }
+                if (!config.qmdEnabled) {
+                    pushMessage("assistant", "QMD is disabled.");
+                    return;
+                }
+                const hits = await qmdSearch({
+                    qmdBin: config.qmdBin,
+                    query: args,
+                    limit: config.qmdLimit,
+                    collection: config.qmdCollection
+                });
+                if (hits.length === 0) {
+                    pushMessage("assistant", "No memory hits.");
+                    return;
+                }
+                const formatted = hits
+                    .map((hit, index) => {
+                    const label = hit.title || hit.path || hit.id;
+                    const score = hit.score ? ` (${hit.score.toFixed(2)})` : "";
+                    return `${index + 1}. ${label}${score}`;
+                })
+                    .join("\n");
+                pushMessage("assistant", formatted);
+                return;
+            }
+            case "model": {
+                const agent = await agentPromise;
+                if (!args) {
+                    setShowModelPicker(true);
+                    return;
+                }
+                const parts = args.split(" ").filter(Boolean);
+                const slashParts = args.includes("/") ? args.split("/") : [];
+                let provider = parts[0];
+                let modelId = parts[1];
+                const providerIndex = Number(provider);
+                const providers = getProviders().sort();
+                if (Number.isInteger(providerIndex) && providerIndex > 0 && providerIndex <= providers.length) {
+                    provider = providers[providerIndex - 1];
+                }
+                if (slashParts.length >= 2) {
+                    provider = slashParts[0]?.trim();
+                    modelId = slashParts.slice(1).join("/").trim();
+                }
+                if (provider && !modelId) {
+                    const models = getModels(provider);
+                    if (models.length === 0) {
+                        pushMessage("assistant", `Unknown provider: ${provider}`);
+                        return;
+                    }
+                    const modelList = models.map((m) => m.id).sort();
+                    pushMessage("assistant", `Models for ${provider}:\n${modelList.join("\n")}`);
+                    return;
+                }
+                if (!provider || !modelId) {
+                    pushMessage("assistant", "Usage: /model <provider> [modelId] or /model <provider>/<modelId>");
+                    return;
+                }
+                if (!agent.setModel) {
+                    pushMessage("assistant", "Agent does not support model switching.");
+                    return;
+                }
+                const result = agent.setModel(provider, modelId);
+                pushMessage("assistant", result.message);
+                if (result.ok) {
+                    setCurrentModel(`${provider}/${modelId}`);
+                    await saveConfigFile(workspace.root, {
+                        model: `${provider}/${modelId}`,
+                        modelProvider: provider,
+                        modelId
+                    });
+                }
+                return;
+            }
+            default:
+                pushMessage("assistant", `Unknown command: ${name}`);
+        }
+    }, [
+        agentPromise,
+        config.qmdBin,
+        config.qmdLimit,
+        config.qmdCollection,
+        exit,
+        pushMessage,
+        sessionPath,
+        workspace,
+        currentModel,
+        config.qmdEnabled
+    ]);
+    useInput((value, key) => {
+        if (key.return) {
+            void handleSubmit();
+            return;
+        }
+        if (key.backspace || key.delete) {
+            setInput((prev) => prev.slice(0, -1));
+            return;
+        }
+        if (key.ctrl && value === "c") {
+            exit();
+            return;
+        }
+        setInput((prev) => prev + value);
+    });
+    const terminalWidth = stdout?.columns ?? 80;
+    const shortWorkspace = terminalWidth < 90 ? workspace.root.split("/").slice(-2).join("/") : workspace.root;
+    const shortModel = terminalWidth < 90 && currentModel.includes("/")
+        ? currentModel.split("/").slice(-2).join("/")
+        : currentModel;
+    const maxVisibleMessages = Math.max(4, (stdout?.rows ?? 24) - 12);
+    const visibleMessages = messages.length > maxVisibleMessages ? messages.slice(messages.length - maxVisibleMessages) : messages;
+    const staticItems = [
+        { type: "banner" },
+        ...visibleMessages.map((message) => ({ type: "message", message }))
+    ];
+    return (_jsxs(Box, { flexDirection: "column", padding: 1, children: [_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Static, { items: staticItems, children: (item, index) => {
+                            if (item.type === "banner") {
+                                return (_jsxs(Box, { borderStyle: "round", borderColor: "cyan", paddingX: 1, marginBottom: 1, flexDirection: "column", children: [_jsxs(Box, { children: [_jsx(Text, { children: "amiko-cli" }), _jsxs(Text, { color: "gray", children: ["  ", shortWorkspace] })] }), _jsxs(Box, { children: [_jsxs(Text, { color: "blue", children: ["model: ", shortModel] }), _jsx(Text, { children: "  " }), _jsxs(Text, { color: agentReady ? "green" : "yellow", children: ["agent: ", agentReady ? "ready" : "loading"] }), _jsx(Text, { children: "  " }), _jsxs(Text, { color: "magenta", children: ["status: ", status] })] })] }, `banner-${index}`));
+                            }
+                            const message = item.message;
+                            return (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsxs(Text, { color: message.role === "user" ? "cyan" : message.role === "tool" ? "yellow" : "green", children: ["[", message.role, "]"] }), _jsx(Text, { children: message.content })] }, `message-${index}`));
+                        } }), streamingAssistant ? (_jsxs(Box, { flexDirection: "column", marginBottom: 1, children: [_jsx(Text, { color: "green", children: "[assistant]" }), _jsx(Text, { children: streamingAssistant })] })) : null] }), showModelPicker ? (_jsx(ModelPicker, { currentModel: currentModel, onCancel: () => setShowModelPicker(false), onSelect: async (provider, modelId) => {
+                    const agent = await agentPromise;
+                    if (!agent.setModel) {
+                        pushMessage("assistant", "Agent does not support model switching.");
+                        setShowModelPicker(false);
+                        return;
+                    }
+                    const result = agent.setModel(provider, modelId);
+                    pushMessage("assistant", result.message);
+                    if (result.ok)
+                        setCurrentModel(`${provider}/${modelId}`);
+                    if (result.ok) {
+                        await saveConfigFile(workspace.root, {
+                            model: `${provider}/${modelId}`,
+                            modelProvider: provider,
+                            modelId
+                        });
+                    }
+                    setShowModelPicker(false);
+                } })) : null, _jsxs(Box, { children: [_jsx(Text, { color: "yellow", children: "> " }), _jsx(Text, { children: input })] })] }));
+}

package/dist/cli.js

@@ -0,0 +1,77 @@
+#!/usr/bin/env node
+import { jsx as _jsx } from "react/jsx-runtime";
+import { render } from "ink";
+import { loadConfig } from "./config.js";
+import { initWorkspace } from "./workspace.js";
+import { createSessionFile } from "./session.js";
+import { App } from "./app.js";
+import { loadConfigFile } from "./configFile.js";
+function parseArgs(argv) {
+    const overrides = {};
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        switch (arg) {
+            case "--workspace":
+            case "-w":
+                overrides.workspacePath = argv[i + 1];
+                i += 1;
+                break;
+            case "--session":
+                overrides.sessionId = argv[i + 1];
+                i += 1;
+                break;
+            case "--qmd-bin":
+                overrides.qmdBin = argv[i + 1];
+                i += 1;
+                break;
+            case "--qmd-limit":
+                overrides.qmdLimit = Number(argv[i + 1]);
+                i += 1;
+                break;
+            case "--qmd-collection":
+                overrides.qmdCollection = argv[i + 1];
+                i += 1;
+                break;
+            case "--qmd-full":
+                overrides.qmdFull = true;
+                break;
+            case "--no-qmd":
+                overrides.qmdEnabled = false;
+                break;
+            case "--model":
+                overrides.model = argv[i + 1];
+                i += 1;
+                break;
+            case "--model-provider":
+                overrides.modelProvider = argv[i + 1];
+                i += 1;
+                break;
+            case "--model-id":
+                overrides.modelId = argv[i + 1];
+                i += 1;
+                break;
+            case "--thinking":
+                overrides.thinkingLevel = argv[i + 1];
+                i += 1;
+                break;
+            default:
+                break;
+        }
+    }
+    return overrides;
+}
+async function main() {
+    const config = loadConfig();
+    const overrides = parseArgs(process.argv.slice(2));
+    const finalConfig = { ...config, ...overrides };
+    const workspace = await initWorkspace(finalConfig.workspacePath);
+    const persisted = await loadConfigFile(workspace.root);
+    const mergedConfig = { ...finalConfig, ...persisted, ...overrides };
+    const sessionFile = await createSessionFile(workspace.sessionsDir, finalConfig.sessionId);
+    render(_jsx(App, { config: mergedConfig, workspace: workspace, sessionPath: sessionFile.path }));
+}
+main().catch((error) => {
+    // eslint-disable-next-line no-console
+    console.error("amiko-cli failed:", error);
+    process.exit(1);
+});

package/dist/commands.js

@@ -0,0 +1,22 @@
+export function parseCommand(input) {
+    if (!input.startsWith("/"))
+        return null;
+    const [command, ...rest] = input.slice(1).split(" ");
+    const name = command.toLowerCase();
+    const args = rest.join(" ").trim();
+    switch (name) {
+        case "exit":
+        case "help":
+        case "memory":
+        case "session":
+        case "search":
+        case "plan":
+        case "index":
+        case "identity":
+        case "personality":
+        case "model":
+            return { name, args };
+        default:
+            return null;
+    }
+}

package/dist/components/ModelPicker.js

@@ -0,0 +1,63 @@
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { useMemo, useState } from "react";
+import { Box, Text, useInput, useStdout } from "ink";
+import SelectInput from "ink-select-input";
+import { getEnvApiKey, getModels, getProviders } from "@mariozechner/pi-ai";
+export function ModelPicker({ currentModel, onSelect, onCancel }) {
+    const [step, setStep] = useState("provider");
+    const [provider, setProvider] = useState(null);
+    const { stdout } = useStdout();
+    const maxItems = Math.max(6, Math.min(15, (stdout?.rows ?? 24) - 12));
+    const [currentProvider, currentModelId] = useMemo(() => {
+        if (!currentModel || currentModel === "auto")
+            return [null, null];
+        const parts = currentModel.split("/");
+        if (parts.length < 2)
+            return [null, null];
+        return [parts[0], parts.slice(1).join("/")];
+    }, [currentModel]);
+    const providerItems = useMemo(() => {
+        const providers = getProviders().sort();
+        return providers.map((p) => {
+            const hasKey = Boolean(getEnvApiKey(p));
+            return {
+                label: `${hasKey ? "[x]" : "[ ]"} ${p}`,
+                value: p
+            };
+        });
+    }, []);
+    const providerInitialIndex = useMemo(() => {
+        if (!currentProvider)
+            return 0;
+        const idx = providerItems.findIndex((item) => item.value === currentProvider);
+        return idx >= 0 ? idx : 0;
+    }, [providerItems, currentProvider]);
+    const modelItems = useMemo(() => {
+        if (!provider)
+            return [];
+        return getModels(provider)
+            .map((m) => ({
+            label: m.id,
+            value: m.id
+        }))
+            .sort((a, b) => a.label.localeCompare(b.label));
+    }, [provider]);
+    const modelInitialIndex = useMemo(() => {
+        if (!currentModelId)
+            return 0;
+        const idx = modelItems.findIndex((item) => item.value === currentModelId);
+        return idx >= 0 ? idx : 0;
+    }, [modelItems, currentModelId]);
+    useInput((_, key) => {
+        if (key.escape)
+            onCancel();
+    });
+    return (_jsxs(Box, { flexDirection: "column", borderStyle: "round", borderColor: "cyan", padding: 1, marginBottom: 1, children: [_jsx(Text, { color: "cyan", children: "Model Picker" }), _jsxs(Text, { color: "gray", children: ["Current: ", currentModel] }), step === "provider" ? (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsx(Text, { children: "Select provider (Esc to cancel)" }), _jsx(SelectInput, { items: providerItems, initialIndex: providerInitialIndex, limit: maxItems, onSelect: (item) => {
+                            setProvider(item.value);
+                            setStep("model");
+                        } })] })) : (_jsxs(Box, { flexDirection: "column", marginTop: 1, children: [_jsxs(Text, { children: ["Select model for ", provider] }), modelItems.length === 0 ? (_jsx(Text, { color: "red", children: "No models found." })) : (_jsx(SelectInput, { items: modelItems, initialIndex: modelInitialIndex, limit: maxItems, onSelect: (item) => {
+                            if (!provider)
+                                return;
+                            onSelect(provider, item.value);
+                        } })), _jsx(Text, { color: "gray", children: "Press Esc to cancel" })] }))] }));
+}

package/dist/config.js

@@ -0,0 +1,26 @@
+import os from "node:os";
+import path from "node:path";
+import { randomUUID } from "node:crypto";
+function defaultWorkspacePath() {
+    return path.join(os.homedir(), ".amiko");
+}
+function newSessionId() {
+    return randomUUID().split("-")[0];
+}
+export function loadConfig() {
+    const workspacePath = process.env.AMIKO_WORKSPACE || defaultWorkspacePath();
+    const sessionId = process.env.AMIKO_SESSION_ID || newSessionId();
+    return {
+        workspacePath,
+        sessionId,
+        qmdBin: process.env.AMIKO_QMD_BIN || "qmd",
+        qmdLimit: Number(process.env.AMIKO_QMD_LIMIT || 5),
+        qmdEnabled: process.env.AMIKO_QMD_ENABLED !== "0",
+        qmdCollection: process.env.AMIKO_QMD_COLLECTION || undefined,
+        qmdFull: process.env.AMIKO_QMD_FULL === "1",
+        model: process.env.AMIKO_MODEL || undefined,
+        modelProvider: process.env.AMIKO_MODEL_PROVIDER || undefined,
+        modelId: process.env.AMIKO_MODEL_ID || undefined,
+        thinkingLevel: process.env.AMIKO_THINKING_LEVEL || undefined
+    };
+}

package/dist/configFile.js

@@ -0,0 +1,23 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import os from "node:os";
+export function getConfigFilePath(workspacePath) {
+    const base = workspacePath || path.join(os.homedir(), ".amiko");
+    return path.join(base, "config.json");
+}
+export async function loadConfigFile(workspacePath) {
+    const filePath = getConfigFilePath(workspacePath);
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        return parsed || {};
+    }
+    catch {
+        return {};
+    }
+}
+export async function saveConfigFile(workspacePath, config) {
+    const filePath = getConfigFilePath(workspacePath);
+    await fs.mkdir(path.dirname(filePath), { recursive: true });
+    await fs.writeFile(filePath, JSON.stringify(config, null, 2) + "\n", "utf8");
+}

package/dist/memory/qmd.js

@@ -0,0 +1,87 @@
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+const execFileAsync = promisify(execFile);
+function parseJsonLines(text) {
+    const lines = text.split("\n").map((line) => line.trim()).filter(Boolean);
+    const results = [];
+    for (const line of lines) {
+        try {
+            results.push(JSON.parse(line));
+        }
+        catch {
+            // ignore
+        }
+    }
+    return results;
+}
+export async function qmdSearch(options) {
+    const { qmdBin, query, limit, collection } = options;
+    try {
+        const args = ["query", "--json", "-n", String(limit)];
+        if (collection) {
+            args.push("-c", collection);
+        }
+        args.push(query);
+        const { stdout } = await execFileAsync(qmdBin, [
+            ...args
+        ]);
+        try {
+            const parsed = JSON.parse(stdout);
+            if (Array.isArray(parsed)) {
+                return parsed.map(normalizeHit);
+            }
+        }
+        catch {
+            // fall through to JSONL parsing
+        }
+        return parseJsonLines(stdout).map(normalizeHit);
+    }
+    catch {
+        return [];
+    }
+}
+export async function qmdGet(options) {
+    const { qmdBin, docId, full } = options;
+    try {
+        const args = ["get", docId];
+        if (full)
+            args.push("--full");
+        const { stdout } = await execFileAsync(qmdBin, args);
+        return stdout.trim();
+    }
+    catch {
+        return null;
+    }
+}
+export async function qmdCollectionAdd(options) {
+    const { qmdBin, name, path } = options;
+    try {
+        await execFileAsync(qmdBin, ["collection", "add", path, "--name", name]);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function qmdEmbed(options) {
+    const { qmdBin, collection } = options;
+    try {
+        const args = ["embed"];
+        if (collection)
+            args.push("-c", collection);
+        await execFileAsync(qmdBin, args);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function normalizeHit(hit) {
+    return {
+        id: String(hit.id ?? hit.docId ?? hit.path ?? "unknown"),
+        score: typeof hit.score === "number" ? hit.score : undefined,
+        title: hit.title ?? hit.name,
+        snippet: hit.snippet ?? hit.text,
+        path: hit.path
+    };
+}