@angri450/zvec-grep 0.2.2

package/dist/cli/commands.js

@@ -0,0 +1,801 @@
+import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { createZvecGrep, } from "../index.js";
+import { globalConfigPath, updateGlobalConfig } from "../engine/config.js";
+import { ENGINE_ERROR_CODE_PREFIX, EngineError, } from "../engine/errors.js";
+import { listEmbeddingModels } from "../engine/models/index.js";
+import { DaemonClient } from "../client/daemon-client.js";
+import { resolveDirectSearchPolicy, resolveServerSearchPolicy, } from "../client/search-policy.js";
+import { resolveClientMode, resolveServerUrl, routeByMode, } from "../client/mode-router.js";
+import { serverStatus } from "../daemon/server-controller.js";
+import { findNearestWorkspace } from "../engine/service/root.js";
+import { contextWarningLines, printCliContextResult, } from "./format/context.js";
+import { printDebug } from "./format/debug.js";
+import { createIndexProgressReporter } from "./format/progress.js";
+import { formatContextLines } from "./errors.js";
+import { printWorkspaceInfo, printIndexPathFilterTip, printIndexResult, printIndexScanDiagnostics, printNoIndexableFilesTip, printServerIndexInfo, } from "./format/status.js";
+import { planRemoteIndexAuthorization, planRemoteSearchAuthorization, } from "../authorization/index.js";
+import { indexCompletionFromStatus, indexStatusNeedsRefresh, } from "../engine/index-status.js";
+import { indexProgressFromMessage } from "../index-progress.js";
+import { normalizeManagedRgInput } from "./managed-rg.js";
+import { INCOMPATIBLE_SERVER_SEARCH_MESSAGE, parseServerSearchResponse, } from "./server-search.js";
+import { runInstall, runUninstall } from "./install.js";
+import { runAuth, authorizationStore, authorizeCliPlan, resolveAuthorizationSchema, embeddingModelInfo, configuredEmbeddingReference, workspaceRuntimeFromInfo, assertEmbeddingModelCompatible, assertRequestedEndpointCompatible, requireEmbeddingModelCatalogEntry, unsupportedRemoteEmbeddingProvider, withRemoteEmbeddingOperationPermit, } from "./auth.js";
+const DEFAULT_IMPLICIT_EMBEDDING = "local/potion-code-16m-v2";
+export async function runParsedCommand(parsed) {
+    switch (parsed.command) {
+        case "query":
+            await runQuery(parsed);
+            return;
+        case "index":
+            await runIndex(parsed);
+            return;
+        case "status":
+            await runStatus(parsed);
+            return;
+        case "install":
+            await runInstall(parsed);
+            return;
+        case "uninstall":
+            await runUninstall(parsed);
+            return;
+        case "config":
+            await runConfig(parsed);
+            return;
+        case "auth":
+            await runAuth(parsed);
+            return;
+        case "server":
+            await runServer(parsed);
+            return;
+        case "help":
+        case "version":
+            throw new Error(`${parsed.command} must be handled before dispatch`);
+    }
+}
+async function runConfig(parsed) {
+    if (parsed.positionals.length !== 1) {
+        throw new Error(`zg --config ${parsed.options.configAction === "provider-set" ? "provider" : "model"} set requires exactly one reference`);
+    }
+    const reference = parsed.positionals[0];
+    if (parsed.options.configAction === "provider-set") {
+        if (!/^[a-z][a-z0-9_-]*$/.test(reference)) {
+            throw unsupportedRemoteEmbeddingProvider(reference, "Invalid embedding provider");
+        }
+        if (reference === "local" ||
+            !listEmbeddingModels().some((entry) => entry.provider === reference)) {
+            throw unsupportedRemoteEmbeddingProvider(reference);
+        }
+        if (parsed.options.apiKey === undefined) {
+            throw new Error("zg --config provider set requires --api-key");
+        }
+        updateGlobalConfig({
+            providers: {
+                [reference]: {
+                    apiKey: parsed.options.apiKey,
+                },
+            },
+        });
+        console.log(`Provider config: ${reference}`);
+        console.log(`Global config: ${globalConfigPath()}`);
+        return;
+    }
+    if (parsed.options.configAction !== "model-set") {
+        throw new Error("zg --config requires provider set or model set");
+    }
+    const catalogEntry = requireEmbeddingModelCatalogEntry(reference);
+    if (parsed.options.endpoint === undefined &&
+        parsed.options.device === undefined &&
+        !parsed.options.defaultModel) {
+        throw new Error("zg --config model set requires --endpoint, --device, or --default");
+    }
+    if (catalogEntry.provider === "local" &&
+        parsed.options.endpoint !== undefined) {
+        throw new Error("--endpoint is only supported for remote embedding models");
+    }
+    if (catalogEntry.provider !== "local" &&
+        parsed.options.device !== undefined) {
+        throw new Error("--device is only supported for local embedding models");
+    }
+    if (parsed.options.endpoint !== undefined) {
+        assertHttpEndpoint(parsed.options.endpoint);
+    }
+    updateGlobalConfig({
+        ...(parsed.options.endpoint !== undefined ||
+            parsed.options.device !== undefined
+            ? {
+                models: {
+                    [reference]: {
+                        ...(parsed.options.endpoint !== undefined
+                            ? { endpoint: parsed.options.endpoint }
+                            : {}),
+                        ...(parsed.options.device !== undefined
+                            ? { device: parsed.options.device }
+                            : {}),
+                    },
+                },
+            }
+            : {}),
+        ...(parsed.options.defaultModel
+            ? { defaults: { embedding: reference } }
+            : {}),
+    });
+    console.log(`Model config: ${reference}`);
+    console.log(`Global config: ${globalConfigPath()}`);
+}
+function assertHttpEndpoint(endpoint) {
+    let parsed;
+    try {
+        parsed = new URL(endpoint);
+    }
+    catch {
+        throw new Error("--endpoint must be a valid HTTP(S) URL");
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new Error("--endpoint must be a valid HTTP(S) URL");
+    }
+}
+async function runIndex(parsed) {
+    const explicitRoot = parsed.positionals.length > 0;
+    const root = resolveIndexRoot(parsed.positionals[0]);
+    const rootPath = indexRootPath(root, parsed.options);
+    if (parsed.positionals.length > 1) {
+        throw new Error("zg --index accepts at most one root path");
+    }
+    if (parsed.options.drop) {
+        await runDropIndex(parsed, rootPath.absolutePath);
+        return;
+    }
+    if (parsed.options.embedding) {
+        requireEmbeddingModelCatalogEntry(parsed.options.embedding);
+    }
+    const mode = resolveClientMode(parsed.options.mode);
+    await routeByMode({
+        mode,
+        serverAvailable: () => daemonIsReady(parsed.options.home),
+        server: async () => {
+            const client = daemonClient(parsed.options);
+            const progress = createIndexProgressReporter({
+                color: parsed.options.color,
+            });
+            let result;
+            try {
+                result = await client.callTool("zvec_grep_index", {
+                    root: rootPath.absolutePath,
+                    embedding: parsed.options.embedding,
+                    apiKey: parsed.options.apiKey,
+                    endpoint: parsed.options.endpoint,
+                    device: parsed.options.device,
+                    rebuild: parsed.options.rebuild,
+                    resetPaths: parsed.options.resetPaths,
+                    globs: parsed.options.globs,
+                    insensitiveGlobs: parsed.options.insensitiveGlobs,
+                    fileTypes: parsed.options.fileTypes,
+                    excludedFileTypes: parsed.options.excludedFileTypes,
+                    hidden: parsed.options.hidden,
+                    noIgnore: parsed.options.noIgnore,
+                    ignoreFiles: parsed.options.ignoreFiles,
+                    maxDepth: parsed.options.maxDepth,
+                    maxFileSizeBytes: parsed.options.maxFileSizeBytes,
+                    follow: parsed.options.follow,
+                    embeddingConcurrency: parsed.options.embeddingConcurrency,
+                    debug: parsed.options.debug,
+                    wait: true,
+                }, {
+                    onProgress: (event) => {
+                        const update = indexProgressFromMessage(event.message);
+                        if (update) {
+                            progress.report(update.progress);
+                        }
+                    },
+                    embeddingEnvironment: process.env.ZVEC_GREP_EMBEDDING?.trim(),
+                });
+            }
+            finally {
+                progress.finish();
+            }
+            console.log(`Workspace index: ${String(result.state ?? "submitted")}`);
+            console.log(`Root: ${String(result.root ?? rootPath.absolutePath)}`);
+            console.log(`Job: ${String(result.job_id ?? "unknown")}`);
+            if (parsed.options.debug) {
+                printIndexScanDiagnostics(result.scan_diagnostics);
+            }
+            if (result.state === "failed") {
+                throw serverIndexFailure(result);
+            }
+            if (result.state === "succeeded") {
+                const status = (await client
+                    .callTool("zvec_grep_index_status", {
+                    root: rootPath.absolutePath,
+                })
+                    .catch(() => undefined));
+                if (status?.persistent.files?.scanned === 0) {
+                    printNoIndexableFilesTip(parsed.options);
+                }
+            }
+        },
+        direct: () => runDirectIndex(parsed, rootPath, explicitRoot),
+    });
+}
+function serverIndexFailure(result) {
+    const error = result.error;
+    if (error && typeof error === "object") {
+        const fields = error;
+        const code = nonEmptyString(fields.code);
+        if (code?.startsWith(`${ENGINE_ERROR_CODE_PREFIX}.`)) {
+            const message = nonEmptyString(fields.message) ?? "Index job failed unexpectedly.";
+            return new EngineError(stripErrorCode(message, code), {
+                code: code,
+                context: nonEmptyString(fields.context),
+                cause: nonEmptyString(fields.cause),
+            });
+        }
+    }
+    const cause = error && typeof error === "object" && "cause" in error
+        ? nonEmptyString(error.cause)
+        : undefined;
+    return new Error(serverIndexFailureMessage(result), { cause });
+}
+function serverIndexFailureMessage(result) {
+    const error = result.error;
+    const context = error && typeof error === "object" && "context" in error
+        ? error.context
+        : undefined;
+    const details = typeof context === "string" ? formatContextLines(context) : [];
+    return [
+        serverIndexFailureSummary(result),
+        ...(details.length > 0
+            ? ["Details:", ...details.map((line) => `  ${line}`)]
+            : []),
+    ].join("\n");
+}
+function serverIndexFailureSummary(result) {
+    const error = result.error;
+    if (error && typeof error === "object") {
+        const code = error.code;
+        const message = error.message;
+        if (typeof message === "string" && message.length > 0) {
+            if (typeof code !== "string" ||
+                code.length === 0 ||
+                message.includes(`[${code}]`)) {
+                return message;
+            }
+            return `[${code}] ${message}`;
+        }
+        if (typeof code === "string" && code.length > 0) {
+            return `[${code}] Index job failed.`;
+        }
+    }
+    return `Index job ${String(result.job_id ?? "unknown")} failed. Run zg --status --mode server for details.`;
+}
+function nonEmptyString(value) {
+    return typeof value === "string" && value.trim().length > 0
+        ? value
+        : undefined;
+}
+function stripErrorCode(message, code) {
+    const prefix = `[${code}]`;
+    return message.startsWith(prefix)
+        ? message.slice(prefix.length).trimStart()
+        : message;
+}
+async function runDirectIndex(parsed, rootPath, explicitRoot) {
+    const serviceOptions = createServiceOptions(parsed.options, rootPath.absolutePath);
+    const zvecGrep = await createZvecGrep(serviceOptions);
+    const progress = createIndexProgressReporter({ color: parsed.options.color });
+    try {
+        const infoBefore = await zvecGrep.info({
+            root: rootPath.absolutePath,
+            includeStatus: parsed.options.rebuild !== true,
+        });
+        const schema = resolveAuthorizationSchema(configuredEmbeddingReference(parsed.options, infoBefore.workspaceIndex?.embedding), infoBefore.workspaceIndex?.embedding);
+        assertEmbeddingModelCompatible(infoBefore.workspaceIndex?.embedding, schema, parsed.options.rebuild === true);
+        const workspaceRuntime = workspaceRuntimeFromInfo(infoBefore);
+        assertRequestedEndpointCompatible(infoBefore, workspaceRuntime, parsed.options.endpoint, parsed.options.rebuild === true);
+        const modelInfo = schema?.provider === "qwen"
+            ? await embeddingModelInfo(schema, serviceOptions, workspaceRuntime)
+            : undefined;
+        const plan = modelInfo
+            ? await planRemoteIndexAuthorization({
+                info: infoBefore,
+                model: modelInfo,
+                rebuild: parsed.options.rebuild,
+                store: authorizationStore(parsed.options),
+            })
+            : undefined;
+        const authorizationResolution = plan
+            ? await authorizeCliPlan(plan, parsed.options)
+            : {};
+        printIndexPathFilterTip(parsed.options);
+        const result = await withRemoteEmbeddingOperationPermit(authorizationResolution.authorization, () => zvecGrep.index({
+            root: rootPath.absolutePath,
+            rootPaths: explicitRoot ? [rootPath] : undefined,
+            rebuild: parsed.options.rebuild,
+            resetPaths: parsed.options.resetPaths,
+            globs: parsed.options.globs,
+            insensitiveGlobs: parsed.options.insensitiveGlobs,
+            fileTypes: parsed.options.fileTypes,
+            excludedFileTypes: parsed.options.excludedFileTypes,
+            hidden: parsed.options.hidden,
+            noIgnore: parsed.options.noIgnore,
+            ignoreFiles: parsed.options.ignoreFiles,
+            maxDepth: parsed.options.maxDepth,
+            maxFileSizeBytes: parsed.options.maxFileSizeBytes,
+            follow: parsed.options.follow,
+            embeddingConcurrency: parsed.options.embeddingConcurrency,
+            onProgress: progress.report,
+        }));
+        progress.finish();
+        const info = await zvecGrep.info({ root: rootPath.absolutePath });
+        printIndexResult("Workspace index", result, parsed.options, info.workspaceIndex?.rootPaths);
+    }
+    catch (error) {
+        progress.finish();
+        throw error;
+    }
+    finally {
+        await zvecGrep.close();
+    }
+}
+async function runDropIndex(parsed, root) {
+    if (!(await confirmIndexDrop(root, parsed.options.yes === true))) {
+        console.log("Index drop cancelled.");
+        return;
+    }
+    const printResult = (removed) => {
+        console.log(removed ? `Dropped index for ${root}` : `No index found for ${root}`);
+    };
+    await routeByMode({
+        mode: resolveClientMode(parsed.options.mode),
+        serverAvailable: () => daemonIsReady(parsed.options.home),
+        server: async () => {
+            const result = await daemonClient(parsed.options).callTool("zvec_grep_index_drop", { root });
+            printResult(result.removed === true);
+        },
+        direct: async () => {
+            const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, root));
+            try {
+                printResult(await zvecGrep.dropIndex({ root }));
+            }
+            finally {
+                await zvecGrep.close();
+            }
+        },
+    });
+}
+async function confirmIndexDrop(root, accepted) {
+    if (accepted) {
+        return true;
+    }
+    if (!process.stdin.isTTY || !process.stdout.isTTY) {
+        throw new Error("zg --index --drop requires --yes in a non-interactive shell");
+    }
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question(`Drop the index for ${root}? [y/N] `);
+        return ["y", "yes"].includes(answer.trim().toLowerCase());
+    }
+    finally {
+        readline.close();
+    }
+}
+async function runServer(parsed) {
+    if (parsed.positionals.length > 0) {
+        throw new Error(`zg --server ${parsed.options.serverStdio ? "--stdio" : parsed.options.serverAction} does not accept positional arguments`);
+    }
+    const { readPackageVersion } = await import("./version.js");
+    if (parsed.options.serverStdio) {
+        const { runStdioBootstrapBridge } = await import("../mcp/stdio-bridge.js");
+        await runStdioBootstrapBridge({
+            cliPath: process.argv[1],
+            version: readPackageVersion(),
+            home: parsed.options.home,
+            tokenFile: parsed.options.serverTokenFile,
+            listen: parsed.options.listen,
+            mcpToolset: parsed.options.mcpToolset,
+        });
+        return;
+    }
+    if (parsed.options.serverAction === "on") {
+        const { startServer } = await import("../daemon/server-controller.js");
+        const status = await startServer({
+            cliPath: process.argv[1],
+            listen: parsed.options.listen,
+            tokenFile: parsed.options.serverTokenFile,
+            home: parsed.options.home,
+            mcpToolset: parsed.options.mcpToolset,
+        });
+        printServerControlStatus(status);
+        return;
+    }
+    if (parsed.options.serverAction === "off") {
+        const { stopServer } = await import("../daemon/server-controller.js");
+        printServerControlStatus(await stopServer(parsed.options.home, 30_000, parsed.options.serverTokenFile));
+        return;
+    }
+    if (parsed.options.serverAction === "status") {
+        const status = await serverStatus(parsed.options.home);
+        printServerControlStatus(status);
+        if (parsed.options.checkReady && !status.ready) {
+            throw new Error("zvec-grep server is not ready");
+        }
+        return;
+    }
+    const { runDaemonForeground } = await import("../daemon/runtime.js");
+    await runDaemonForeground({
+        version: readPackageVersion(),
+        listen: parsed.options.listen,
+        tokenFile: parsed.options.serverTokenFile,
+        home: parsed.options.home,
+        mcpToolset: parsed.options.mcpToolset,
+        serviceOptions: createServiceOptions(parsed.options, process.cwd()),
+    });
+}
+async function runStatus(parsed) {
+    const root = parsed.positionals[0] ?? process.cwd();
+    if (parsed.positionals.length > 1) {
+        throw new Error("zg --status accepts at most one root path");
+    }
+    const mode = resolveClientMode(parsed.options.mode);
+    const state = await routeByMode({
+        mode,
+        serverAvailable: () => daemonIsReady(parsed.options.home),
+        server: async () => {
+            const result = await daemonClient(parsed.options).callTool("zvec_grep_index_status", { root: resolve(root) });
+            return printServerIndexInfo(result, parsed.options);
+        },
+        direct: async () => {
+            const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, root));
+            try {
+                return printWorkspaceInfo(await zvecGrep.info({ root }), parsed.options);
+            }
+            finally {
+                await zvecGrep.close();
+            }
+        },
+    });
+    if (parsed.options.checkReady && state !== "ready") {
+        throw new Error(`Workspace index is not ready (state: ${state})`);
+    }
+}
+async function runQuery(parsed) {
+    const rgInput = parsed.options.rg
+        ? normalizeManagedRgInput(parsed)
+        : undefined;
+    const commandOptions = rgInput?.options ?? parsed.options;
+    const queries = (rgInput?.queries ?? [
+        ...parsed.positionals,
+        ...(parsed.options.hybridQueries ?? []),
+    ])
+        .map((query) => query.trim())
+        .filter((query) => query.length > 0);
+    const routes = parsed.options.routes ?? [];
+    if (queries.length === 0 &&
+        routes.length === 0 &&
+        (parsed.options.rgOptions?.patternFiles?.length ?? 0) === 0) {
+        throw new Error(parsed.options.rg
+            ? "zg --rg requires a pattern. Use zg --help search for examples."
+            : "zg requires text or --hybrid/--fts/--vector routes. Use zg --help search for examples.");
+    }
+    if (commandOptions.rg) {
+        await runDirectRgQuery(commandOptions, queries);
+        return;
+    }
+    const mode = resolveClientMode(commandOptions.mode);
+    if (mode !== "direct") {
+        await routeByMode({
+            mode,
+            serverAvailable: () => daemonIsReady(commandOptions.home),
+            server: async () => {
+                await ensureServerIndex(commandOptions);
+                await runServerQuery(commandOptions, queries, routes);
+            },
+            direct: () => runDirectQuery(commandOptions, queries),
+        });
+        return;
+    }
+    await runDirectQuery(commandOptions, queries);
+}
+async function runDirectRgQuery(commandOptions, queries) {
+    const zvecGrep = await createZvecGrep(createServiceOptions(commandOptions, undefined));
+    try {
+        const result = await zvecGrep.context(contextOptions(commandOptions, queries));
+        printCliContextResult(result, commandOptions);
+        for (const line of contextWarningLines(result)) {
+            console.error(line);
+        }
+        if (commandOptions.debug) {
+            printDebug(result, { trace: false });
+        }
+    }
+    finally {
+        await zvecGrep.close();
+    }
+}
+async function runDirectQuery(commandOptions, queries) {
+    if (commandOptions.refresh === "background") {
+        console.error("warning: --refresh background requires Server mode; Direct mode uses --refresh off");
+    }
+    const serviceOptions = createServiceOptions(commandOptions, undefined);
+    const zvecGrep = await createZvecGrep(serviceOptions);
+    const progress = createIndexProgressReporter({
+        color: commandOptions.color,
+    });
+    try {
+        const contextRequest = contextOptions(commandOptions, queries, (progressEvent) => {
+            if (progressEvent.phase !== "done")
+                progress.report(progressEvent);
+        });
+        let info = await directQueryInfo(zvecGrep);
+        if (!info.indexed && info.indexPolicy !== "disabled") {
+            await buildImplicitDirectIndex(commandOptions, info.root, progress.report);
+            info = await directQueryInfo(zvecGrep);
+        }
+        const schema = info.workspaceIndex?.embedding;
+        const workspaceRuntime = workspaceRuntimeFromInfo(info);
+        const modelInfo = !commandOptions.rg && schema?.provider === "qwen"
+            ? await embeddingModelInfo(schema, createServiceOptions(commandOptions, info.root), workspaceRuntime)
+            : undefined;
+        const plan = modelInfo
+            ? await planRemoteSearchAuthorization({
+                info,
+                model: modelInfo,
+                search: normalizedDirectSearchInput(commandOptions, queries, info.root),
+                store: authorizationStore(commandOptions),
+            })
+            : undefined;
+        const authorizationResolution = plan
+            ? await authorizeCliPlan(plan, commandOptions, "local_search")
+            : {};
+        const effectiveContextRequest = authorizationResolution.alternative === "local_search"
+            ? ftsFallbackContextRequest(contextRequest)
+            : contextRequest;
+        const result = await withRemoteEmbeddingOperationPermit(authorizationResolution.authorization, () => zvecGrep.context(effectiveContextRequest));
+        progress.finish();
+        printCliContextResult(result, commandOptions);
+        for (const line of contextWarningLines(result)) {
+            console.error(line);
+        }
+        if (result.source === "index" &&
+            effectiveContextRequest.autoUpdate !== true &&
+            indexStatusNeedsRefresh(info.status)) {
+            printStaleIndexStatus("idle", indexCompletionFromStatus(info.status));
+        }
+        if (commandOptions.debug) {
+            printDebug(result, {
+                trace: commandOptions.trace === true,
+            });
+        }
+    }
+    catch (error) {
+        progress.finish();
+        throw error;
+    }
+    finally {
+        await zvecGrep.close();
+    }
+}
+async function buildImplicitDirectIndex(options, root, onProgress) {
+    const embedding = implicitEmbeddingReference(options);
+    console.error(`No index found; creating one with ${embedding}.`);
+    const service = await createZvecGrep(createServiceOptions({ ...options, embedding }, root));
+    try {
+        await service.index({
+            root,
+            onProgress,
+            embeddingConcurrency: options.embeddingConcurrency,
+        });
+    }
+    finally {
+        await service.close();
+    }
+}
+async function ensureServerIndex(options) {
+    const root = resolve(process.cwd());
+    const client = daemonClient(options);
+    const status = await client.callTool("zvec_grep_index_status", { root });
+    if (status.indexed === true || status.index_policy === "disabled")
+        return;
+    const embedding = implicitEmbeddingReference(options);
+    console.error(`No index found; creating one with ${embedding}.`);
+    const progress = createIndexProgressReporter({ color: options.color });
+    let result;
+    try {
+        result = await client.callTool("zvec_grep_index", {
+            root,
+            embedding,
+            device: options.device,
+            embeddingConcurrency: options.embeddingConcurrency,
+            wait: true,
+        }, {
+            onProgress: (event) => {
+                const update = indexProgressFromMessage(event.message);
+                if (update)
+                    progress.report(update.progress);
+            },
+            embeddingEnvironment: embedding,
+        });
+    }
+    finally {
+        progress.finish();
+    }
+    if (result.state === "failed")
+        throw serverIndexFailure(result);
+}
+function implicitEmbeddingReference(options) {
+    const configured = configuredEmbeddingReference(options, undefined);
+    return configured?.startsWith("local/")
+        ? configured
+        : DEFAULT_IMPLICIT_EMBEDDING;
+}
+async function runServerQuery(options, queries, routes) {
+    const searchPolicy = resolveServerSearchPolicy(options);
+    const structuredContent = await daemonClient(options).callTool("zvec_grep_search", {
+        root: resolve(process.cwd()),
+        apiKey: options.apiKey,
+        device: options.device,
+        queries: queries.length ? queries : undefined,
+        routes: routes.length ? routes : undefined,
+        fuse: options.fuse,
+        limit: options.limit,
+        trace: options.trace,
+        preferSymbol: options.preferSymbol,
+        symbolTypes: options.symbolTypes,
+        globs: options.globs,
+        insensitiveGlobs: options.insensitiveGlobs,
+        fileTypes: options.fileTypes,
+        excludedFileTypes: options.excludedFileTypes,
+        hidden: options.hidden,
+        noIgnore: options.noIgnore,
+        ignoreFiles: options.ignoreFiles,
+        maxDepth: options.maxDepth,
+        maxFileSizeBytes: options.maxFileSizeBytes,
+        follow: options.follow,
+        modifiedAfter: options.modifiedAfter,
+        modifiedBefore: options.modifiedBefore,
+        freshness: searchPolicy.freshness,
+        autoUpdate: searchPolicy.autoUpdate,
+    }, {
+        toolContract: {
+            inputProperties: ["routes"],
+            outputProperties: ["result"],
+            errorMessage: INCOMPATIBLE_SERVER_SEARCH_MESSAGE,
+        },
+    });
+    const response = parseServerSearchResponse(structuredContent);
+    printCliContextResult(response.result, options);
+    for (const line of contextWarningLines(response.result)) {
+        console.error(line);
+    }
+    if (response.freshness === "possibly_stale") {
+        printStaleIndexStatus(response.indexing?.state, response.indexing);
+    }
+    if (options.debug) {
+        printDebug(response.result, { trace: options.trace === true });
+    }
+}
+function printStaleIndexStatus(state, completion) {
+    console.error("status: possibly_stale");
+    if (!state)
+        return;
+    const progress = completion?.completed === undefined || completion.total === undefined
+        ? ""
+        : ` (${completion.completed}/${completion.total})`;
+    console.error("results: served_from_current_index");
+    console.error(`background_refresh: ${state}${progress}`);
+}
+function daemonClient(options) {
+    return new DaemonClient({
+        serverUrl: resolveServerUrl(),
+        home: options.home,
+        tokenFile: options.serverTokenFile,
+        allowRemote: options.allowRemote,
+    });
+}
+function ftsFallbackContextRequest(request) {
+    const queries = [
+        ...(request.queries ?? []),
+        ...(request.query ? [request.query] : []),
+        ...(request.routes ?? []).map((route) => route.query),
+    ];
+    return {
+        ...request,
+        query: undefined,
+        queries: undefined,
+        routes: queries.map((query) => ({ mode: "fts", query })),
+        autoUpdate: false,
+    };
+}
+async function directQueryInfo(service) {
+    return await service.info({ root: process.cwd() });
+}
+function normalizedDirectSearchInput(options, queries, root) {
+    const policy = resolveDirectSearchPolicy(options);
+    return {
+        root,
+        apiKey: options.apiKey,
+        device: options.device,
+        queries: !options.rg && queries.length > 0 ? [...queries] : undefined,
+        routes: [...(options.routes ?? [])],
+        ...policy,
+    };
+}
+async function daemonIsReady(home) {
+    return (await serverStatus(home)).ready;
+}
+function printServerControlStatus(status) {
+    console.log(`Server: ${status.running ? (status.ready ? "ready" : "starting") : "stopped"}`);
+    if (status.pid)
+        console.log(`PID: ${status.pid}`);
+    if (status.serverUrl)
+        console.log(`URL: ${status.serverUrl}`);
+    if (status.mcpToolset)
+        console.log(`MCP toolset: ${status.mcpToolset}`);
+}
+function contextOptions(options, queries, onAutoUpdateProgress) {
+    const policy = resolveDirectSearchPolicy(options);
+    return {
+        queries: queries.length > 0 ? queries : undefined,
+        rg: options.rg,
+        rgOptions: options.rgOptions,
+        rgPaths: options.rgPaths,
+        routes: options.routes,
+        fuse: options.fuse,
+        limit: options.limit,
+        autoUpdate: policy.autoUpdate,
+        onAutoUpdateProgress,
+        trace: options.trace,
+        preferSymbol: options.preferSymbol,
+        globs: options.globs,
+        insensitiveGlobs: options.insensitiveGlobs,
+        fileTypes: options.fileTypes,
+        excludedFileTypes: options.excludedFileTypes,
+        hidden: options.hidden,
+        noIgnore: options.noIgnore,
+        ignoreFiles: options.ignoreFiles,
+        maxDepth: options.maxDepth,
+        maxFileSizeBytes: options.maxFileSizeBytes,
+        follow: options.follow,
+        modifiedAfter: options.modifiedAfter,
+        modifiedBefore: options.modifiedBefore,
+        symbolTypes: options.symbolTypes,
+    };
+}
+export function createServiceOptions(options, root) {
+    return {
+        root,
+        home: options.home ?? process.env.ZVEC_GREP_HOME,
+        embedding: options.embedding,
+        apiKey: options.apiKey,
+        endpoint: options.endpoint,
+        modelCacheDir: options.modelCacheDir,
+        device: options.device,
+        authorizationSigningKeyPath: process.env.ZVEC_GREP_AUTHORIZATION_KEY_FILE,
+    };
+}
+function resolveIndexRoot(root) {
+    if (root !== undefined) {
+        return root;
+    }
+    return findNearestWorkspace(process.cwd())?.root ?? process.cwd();
+}
+function indexRootPath(path, options) {
+    return {
+        absolutePath: resolve(path),
+        recursive: true,
+        globs: options.globs,
+        insensitiveGlobs: options.insensitiveGlobs,
+        fileTypes: options.fileTypes,
+        excludedFileTypes: options.excludedFileTypes,
+        hidden: options.hidden,
+        noIgnore: options.noIgnore,
+        ignoreFiles: options.ignoreFiles,
+        maxDepth: options.maxDepth,
+        maxFileSizeBytes: options.maxFileSizeBytes,
+        follow: options.follow,
+    };
+}
+//# sourceMappingURL=commands.js.map