@zvec/zvec-grep 0.1.4 → 0.1.6

package/dist/cli/commands.js

@@ -1,53 +1,272 @@
 import { resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { createZvecGrep, } from "../index.js";
-import { findNearestAnonymousWorkspace } from "../engine/service/root.js";
-import { contextWarningLines, printAgentContextResult, printHumanContextResult } from "./format/context.js";
+import { globalConfigPath, updateGlobalConfig } from "../engine/config.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, printAgentContextResult, printHumanContextResult, } from "./format/context.js";
+import { createHighlighter, shouldUseColor } from "./format/highlight.js";
 import { printDebug } from "./format/debug.js";
 import { createIndexProgressReporter } from "./format/progress.js";
-import { printAnonymousInfo, printCollectionInfo, printCollectionList, printCollectionRemoveResult, printIndexPathFilterTip, printIndexResult, } from "./format/status.js";
+import { printWorkspaceInfo, printIndexPathFilterTip, printIndexResult, 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 { runInstall, runUninstall } from "./install.js";
+import { runAuth, authorizationStore, authorizeCliPlan, resolveAuthorizationSchema, embeddingModelInfo, configuredEmbeddingReference, workspaceRuntimeFromInfo, assertEmbeddingModelCompatible, assertRequestedEndpointCompatible, requireEmbeddingModelCatalogEntry, unsupportedRemoteEmbeddingProvider, withRemoteEmbeddingOperationPermit, } from "./auth.js";
 export async function runParsedCommand(parsed) {
-    if (parsed.options.index) {
-        await runIndex(parsed);
-        return;
+    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`);
     }
-    if (parsed.options.disableIndex) {
-        await runDisableIndex(parsed);
-        return;
+}
+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`);
     }
-    if (parsed.options.status) {
-        await runStatus(parsed);
+    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.collections) {
-        await runCollections(parsed);
-        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");
     }
-    await runQuery(parsed);
 }
 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");
+        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 zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, rootPath.absolutePath));
-    const progress = createIndexProgressReporter();
+    const mode = resolveClientMode(parsed.options.mode);
+    await routeByMode({
+        mode,
+        serverAvailable: () => daemonIsReady(parsed.options.home),
+        server: async () => {
+            const progress = createIndexProgressReporter({
+                color: parsed.options.color,
+            });
+            let result;
+            try {
+                result = await daemonClient(parsed.options).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,
+                    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 (result.state === "failed") {
+                throw new Error(serverIndexFailureMessage(result));
+            }
+        },
+        direct: () => runDirectIndex(parsed, rootPath, explicitRoot),
+    });
+}
+function serverIndexFailureMessage(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.`;
+}
+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 zvecGrep.index({
+        const result = await withRemoteEmbeddingOperationPermit(authorizationResolution.authorization, () => zvecGrep.index({
             root: rootPath.absolutePath,
             rootPaths: explicitRoot ? [rootPath] : undefined,
             rebuild: parsed.options.rebuild,
             resetPaths: parsed.options.resetPaths,
-            includePaths: parsed.options.includePaths,
-            excludePaths: parsed.options.excludePaths,
+            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("Indexed anonymous workspace", result, parsed.options, info.collection?.rootPaths);
+        printIndexResult("Workspace index", result, parsed.options, info.workspaceIndex?.rootPaths);
     }
     catch (error) {
         progress.finish();
@@ -57,131 +276,186 @@ async function runIndex(parsed) {
         await zvecGrep.close();
     }
 }
-async function runDisableIndex(parsed) {
-    const root = resolveIndexRoot(parsed.positionals[0]);
-    if (parsed.positionals.length > 1) {
-        throw new Error("zg --disable-index accepts at most one root path");
+async function runDropIndex(parsed, root) {
+    if (!(await confirmIndexDrop(root, parsed.options.yes === true))) {
+        console.log("Index drop cancelled.");
+        return;
     }
-    const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, root));
+    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 info = await zvecGrep.disableIndex({ root });
-        printAnonymousInfo(info, parsed.options);
+        const answer = await readline.question(`Drop the index for ${root}? [y/N] `);
+        return ["y", "yes"].includes(answer.trim().toLowerCase());
     }
     finally {
-        await zvecGrep.close();
+        readline.close();
     }
 }
-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");
+async function runServer(parsed) {
+    if (parsed.positionals.length > 0) {
+        throw new Error(`zg server ${parsed.options.serverAction} does not accept positional arguments`);
     }
-    const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, root));
-    try {
-        const info = await zvecGrep.info({ root });
-        printAnonymousInfo(info, parsed.options);
+    const { readPackageVersion } = await import("./version.js");
+    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;
     }
-    finally {
-        await zvecGrep.close();
+    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;
     }
-}
-async function runCollections(parsed) {
-    const [action = "list", name, root] = parsed.positionals;
-    const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, undefined));
-    try {
-        if (action === "list") {
-            if (parsed.options.resetPaths) {
-                throw new Error("--reset-paths can only be used with --collections index");
-            }
-            printCollectionList(await zvecGrep.collections.list(), parsed.options);
-            return;
-        }
-        if (action === "info") {
-            if (parsed.options.resetPaths) {
-                throw new Error("--reset-paths can only be used with --collections index");
-            }
-            if (!name) {
-                throw new Error("zg --collections info requires <name>");
-            }
-            const [info, status] = await Promise.all([
-                zvecGrep.collections.info(name),
-                zvecGrep.collections.status(name),
-            ]);
-            if (!info) {
-                throw new Error(`Collection not found: ${name}`);
-            }
-            printCollectionInfo(info, status, parsed.options);
-            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");
         }
-        if (action === "index") {
-            if (!name) {
-                throw new Error("zg --collections index requires <name>");
-            }
-            const explicitRoot = root !== undefined;
-            const rootPath = indexRootPath(root ?? process.cwd(), parsed.options);
-            const rootPaths = explicitRoot ? rootPath : undefined;
-            const progress = createIndexProgressReporter();
+        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 {
-                const result = await zvecGrep.collections.index(name, rootPaths, {
-                    rebuild: parsed.options.rebuild,
-                    resetPaths: parsed.options.resetPaths,
-                    includePaths: parsed.options.includePaths,
-                    excludePaths: parsed.options.excludePaths,
-                    embeddingConcurrency: parsed.options.embeddingConcurrency,
-                    onProgress: progress.report,
-                });
-                progress.finish();
-                const info = await zvecGrep.collections.info(name);
-                printIndexResult(`Indexed collection ${name}`, result, parsed.options, info?.rootPaths);
-            }
-            catch (error) {
-                progress.finish();
-                throw error;
+                return printWorkspaceInfo(await zvecGrep.info({ root }), parsed.options);
             }
-            return;
-        }
-        if (action === "remove") {
-            if (parsed.options.resetPaths) {
-                throw new Error("--reset-paths can only be used with --collections index");
+            finally {
+                await zvecGrep.close();
             }
-            if (!name) {
-                throw new Error("zg --collections remove requires <name>");
-            }
-            const removed = await zvecGrep.collections.remove(name);
-            printCollectionRemoveResult(name, removed, parsed.options);
-            return;
-        }
-        if (parsed.options.resetPaths) {
-            throw new Error("--reset-paths can only be used with --collections index");
-        }
-        throw new Error(`Unknown collections action: ${action}`);
-    }
-    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
-        ? normalizeRgInput(parsed)
+        ? normalizeManagedRgInput(parsed)
         : undefined;
     const commandOptions = rgInput?.options ?? parsed.options;
-    const queries = (rgInput?.queries ?? parsed.positionals)
+    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) {
+    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 --help for examples."
-            : "zg query requires text or --fts/--vector routes. Use --help for examples.");
+            ? "zg query --rg requires a pattern. Use zg help query for examples."
+            : "zg query requires text or --hybrid/--fts/--vector routes. Use zg help query for examples.");
+    }
+    if (!commandOptions.rg) {
+        const mode = resolveClientMode(commandOptions.mode);
+        if (mode !== "direct") {
+            await routeByMode({
+                mode,
+                serverAvailable: () => daemonIsReady(commandOptions.home),
+                server: () => runServerQuery(commandOptions, queries, routes),
+                direct: () => runDirectQuery(commandOptions, queries),
+            });
+            return;
+        }
+    }
+    await runDirectQuery(commandOptions, queries);
+}
+async function runDirectQuery(commandOptions, queries) {
+    if (commandOptions.refresh === "background") {
+        console.error("warning: --refresh background requires Server mode; Direct mode uses --refresh off");
     }
-    const zvecGrep = await createZvecGrep(createServiceOptions(commandOptions, undefined));
-    const progress = createIndexProgressReporter();
+    const serviceOptions = createServiceOptions(commandOptions, undefined);
+    const zvecGrep = await createZvecGrep(serviceOptions);
+    const progress = createIndexProgressReporter({
+        color: commandOptions.color,
+    });
     try {
-        const result = await zvecGrep.context(contextOptions(commandOptions, queries, (progressEvent) => {
-            if (progressEvent.phase !== "done") {
+        const contextRequest = contextOptions(commandOptions, queries, (progressEvent) => {
+            if (progressEvent.phase !== "done")
                 progress.report(progressEvent);
-            }
-        }));
+        });
+        const 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();
         if (commandOptions.human) {
             printHumanContextResult(result, commandOptions);
@@ -192,6 +466,10 @@ async function runQuery(parsed) {
         for (const line of contextWarningLines(result)) {
             console.error(line);
         }
+        if (effectiveContextRequest.autoUpdate !== true &&
+            indexStatusNeedsRefresh(info.status)) {
+            printStaleIndexStatus("idle", indexCompletionFromStatus(info.status));
+        }
         if (commandOptions.debug) {
             printDebug(result, {
                 trace: commandOptions.trace === true,
@@ -206,95 +484,166 @@ async function runQuery(parsed) {
         await zvecGrep.close();
     }
 }
+async function runServerQuery(options, queries, routes) {
+    const searchPolicy = resolveServerSearchPolicy(options);
+    const fts = routes
+        .filter((route) => route.mode === "fts")
+        .map((route) => route.query);
+    const vector = routes
+        .filter((route) => route.mode === "vector")
+        .map((route) => route.query);
+    const response = await daemonClient(options).callTextTool("zvec_grep_search", {
+        root: resolve(process.cwd()),
+        apiKey: options.apiKey,
+        device: options.device,
+        queries: queries.length ? queries : undefined,
+        fts: fts.length ? fts : undefined,
+        vector: vector.length ? vector : 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,
+        embeddingConcurrency: options.embeddingConcurrency,
+        modifiedAfter: options.modifiedAfter,
+        modifiedBefore: options.modifiedBefore,
+        freshness: searchPolicy.freshness,
+        autoUpdate: searchPolicy.autoUpdate,
+    });
+    const highlighter = createHighlighter([...queries, ...fts, ...vector].join(" "), shouldUseColor(options));
+    for (const line of response.split("\n")) {
+        console.log(highlighter(line));
+    }
+}
+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(`indexing: ${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,
-        collection: options.collection,
+        fuse: options.fuse,
         limit: options.limit,
-        fallback: "disabled",
-        autoUpdate: !options.noAutoUpdate,
+        autoUpdate: policy.autoUpdate,
         onAutoUpdateProgress,
         trace: options.trace,
         preferSymbol: options.preferSymbol,
-        includePaths: options.includePaths,
-        excludePaths: options.excludePaths,
+        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,
         embeddingConcurrency: options.embeddingConcurrency,
     };
 }
-function normalizeRgInput(parsed) {
-    const explicitPatterns = parsed.options.rgOptions?.patterns ?? [];
-    const queries = explicitPatterns.length > 0
-        ? explicitPatterns
-        : parsed.positionals.slice(0, 1);
-    const paths = explicitPatterns.length > 0
-        ? parsed.positionals
-        : parsed.positionals.slice(1);
-    return {
-        queries,
-        options: {
-            ...parsed.options,
-            rgPaths: paths.length > 0 ? paths : undefined,
-        },
-    };
-}
-function createServiceOptions(options, root) {
-    const embedding = options.embedding ?? process.env.ZVEC_GREP_EMBEDDING;
-    const apiKey = options.apiKey
-        ?? process.env.ZVEC_GREP_API_KEY
-        ?? process.env.DASHSCOPE_API_KEY
-        ?? process.env.QWEN_API_KEY;
-    const endpoint = options.endpoint ?? process.env.ZVEC_GREP_ENDPOINT;
+export function createServiceOptions(options, root) {
     return {
         root,
         home: options.home ?? process.env.ZVEC_GREP_HOME,
-        embedding,
-        apiKey,
-        endpoint,
-        modelCacheDir: options.modelCacheDir ?? process.env.ZVEC_GREP_MODEL_CACHE,
-        llamaGpu: options.llamaGpu ?? parseEnvLlamaGpu(process.env.ZVEC_GREP_LLAMA_GPU),
-        embeddingParallelism: options.embeddingParallelism ?? parseEnvPositiveInteger(process.env.ZVEC_GREP_EMBED_PARALLELISM),
+        embedding: options.embedding,
+        apiKey: options.apiKey,
+        endpoint: options.endpoint,
+        modelCacheDir: options.modelCacheDir,
+        device: options.device,
+        authorizationSigningKeyPath: process.env.ZVEC_GREP_AUTHORIZATION_KEY_FILE,
     };
 }
-function parseEnvLlamaGpu(value) {
-    const normalized = value?.trim().toLowerCase() ?? "";
-    if (!normalized) {
-        return undefined;
-    }
-    if (normalized === "auto" || normalized === "metal" || normalized === "vulkan" || normalized === "cuda") {
-        return normalized;
-    }
-    if (["false", "off", "none", "disable", "disabled", "0"].includes(normalized)) {
-        return false;
-    }
-    return undefined;
-}
-function parseEnvPositiveInteger(value) {
-    const normalized = value?.trim() ?? "";
-    if (!normalized) {
-        return undefined;
-    }
-    const parsed = Number.parseInt(normalized, 10);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
-}
 function resolveIndexRoot(root) {
     if (root !== undefined) {
         return root;
     }
-    return findNearestAnonymousWorkspace(process.cwd())?.root ?? process.cwd();
+    return findNearestWorkspace(process.cwd())?.root ?? process.cwd();
 }
 function indexRootPath(path, options) {
     return {
         absolutePath: resolve(path),
         recursive: true,
-        include: options.includePaths,
-        exclude: options.excludePaths,
+        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