@zvec/zvec-grep 0.1.4 → 0.1.5

package/dist/cli/commands.js

@@ -1,35 +1,219 @@
-import { resolve } from "node:path";
+import { randomUUID } from "node:crypto";
+import { chmod, lstat, mkdir, open, readFile, readlink, rename, stat, unlink, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { dirname, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
 import { createZvecGrep, } from "../index.js";
+import { globalConfigPath, updateGlobalConfigFromExplicitOptions, } from "../engine/config.js";
 import { findNearestAnonymousWorkspace } from "../engine/service/root.js";
-import { contextWarningLines, printAgentContextResult, printHumanContextResult } from "./format/context.js";
+import { contextWarningLines, printAgentContextResult, printHumanContextResult, } from "./format/context.js";
 import { printDebug } from "./format/debug.js";
 import { createIndexProgressReporter } from "./format/progress.js";
 import { printAnonymousInfo, printCollectionInfo, printCollectionList, printCollectionRemoveResult, printIndexPathFilterTip, printIndexResult, } from "./format/status.js";
+const AGENT_INSTALLERS = [
+    {
+        id: "codex",
+        label: "Codex",
+        description: "configure zvec-grep MCP and Codex guidance",
+        install: installCodexIntegration,
+        uninstall: uninstallCodexIntegration,
+    },
+];
+const ZVEC_GREP_CONFIG_START = "# ZVEC_GREP_START";
+const ZVEC_GREP_CONFIG_END = "# ZVEC_GREP_END";
+const ZVEC_GREP_AGENTS_START = "<!-- ZVEC_GREP_START -->";
+const ZVEC_GREP_AGENTS_END = "<!-- ZVEC_GREP_END -->";
+const DEFAULT_MCP_TOOL_TIMEOUT_SECONDS = 600;
 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 "collections":
+            await runCollections(parsed);
+            return;
+        case "install":
+            await runInstall(parsed);
+            return;
+        case "uninstall":
+            await runUninstall(parsed);
+            return;
+        case "serve":
+            await runServe(parsed);
+            return;
+        case "help":
+        case "version":
+            throw new Error(`${parsed.command} must be handled before dispatch`);
     }
-    if (parsed.options.disableIndex) {
-        await runDisableIndex(parsed);
+}
+async function runInstall(parsed) {
+    const installers = await resolveInstallers(parsed, "install");
+    if (installers.length === 0) {
+        console.log("No agents selected.");
         return;
     }
-    if (parsed.options.status) {
-        await runStatus(parsed);
-        return;
+    console.log(`Installing zvec-grep for: ${installers.map((installer) => installer.label).join(", ")}`);
+    for (const installer of installers) {
+        const result = await installer.install({
+            force: parsed.options.force === true,
+            mcpToolTimeoutSeconds: parsed.options.installMcpToolTimeoutSeconds ??
+                DEFAULT_MCP_TOOL_TIMEOUT_SECONDS,
+        });
+        console.log(`Installed ${installer.label}:`);
+        for (const file of result.files) {
+            console.log(`  ${file}`);
+        }
     }
-    if (parsed.options.collections) {
-        await runCollections(parsed);
+    console.log("Restart the selected agent or start a new session to pick up the integration.");
+    if (installers.some((installer) => installer.id === "codex")) {
+        console.log("Codex MCP server: zg serve --mcp");
+    }
+}
+async function runUninstall(parsed) {
+    const installers = await resolveInstallers(parsed, "uninstall");
+    if (installers.length === 0) {
+        console.log("No agents selected.");
         return;
     }
-    await runQuery(parsed);
+    console.log(`Removing zvec-grep from: ${installers.map((installer) => installer.label).join(", ")}`);
+    for (const installer of installers) {
+        const result = await installer.uninstall();
+        console.log(`Removed ${installer.label} integration:`);
+        for (const file of result.files) {
+            console.log(`  ${file}`);
+        }
+    }
+    console.log("Restart the selected agent or start a new session to apply the change.");
+}
+async function installCodexIntegration(options) {
+    const codexHome = resolveCodexHome();
+    const configPath = resolve(codexHome, "config.toml");
+    const agentsPath = resolve(codexHome, "AGENTS.md");
+    await writeMarkedFile({
+        path: configPath,
+        startMarker: ZVEC_GREP_CONFIG_START,
+        endMarker: ZVEC_GREP_CONFIG_END,
+        block: codexConfigBlock(options.mcpToolTimeoutSeconds),
+        force: options.force,
+        hasConflict: hasCodexMcpServerConfig,
+        conflictMessage: `Existing [mcp_servers.zvec_grep] found in ${configPath}. Re-run with --force after removing or moving that table into the zvec-grep managed block.`,
+        removeConflict: removeCodexMcpServerConfig,
+    });
+    await writeMarkedFile({
+        path: agentsPath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+        block: codexAgentsBlock(),
+        force: true,
+    });
+    return { files: [configPath, agentsPath] };
+}
+async function uninstallCodexIntegration() {
+    const codexHome = resolveCodexHome();
+    const configPath = resolve(codexHome, "config.toml");
+    const agentsPath = resolve(codexHome, "AGENTS.md");
+    await removeMarkedFile({
+        path: configPath,
+        startMarker: ZVEC_GREP_CONFIG_START,
+        endMarker: ZVEC_GREP_CONFIG_END,
+    });
+    await removeMarkedFile({
+        path: agentsPath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+    });
+    return { files: [configPath, agentsPath] };
+}
+async function resolveInstallers(parsed, action) {
+    const targetTokens = [
+        ...(parsed.options.installTargets ?? []),
+        ...parsed.positionals,
+    ];
+    if (targetTokens.length > 0) {
+        return installersFromTokens(targetTokens);
+    }
+    if (parsed.options.yes === true ||
+        !process.stdin.isTTY ||
+        !process.stdout.isTTY) {
+        return installersFromTokens(["auto"]);
+    }
+    return promptInstallers(action);
+}
+async function promptInstallers(action) {
+    console.log(`Select agents whose zvec-grep integration should be ${action === "install" ? "installed" : "removed"}:`);
+    AGENT_INSTALLERS.forEach((installer, index) => {
+        console.log(`  ${index + 1}. ${installer.label} - ${installer.description}`);
+    });
+    console.log("  all. All supported agents");
+    console.log("  none. Cancel");
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question("Agents [codex]: ");
+        const normalized = answer.trim();
+        return installersFromTokens(normalized.length > 0 ? splitTargetTokens(normalized) : ["codex"]);
+    }
+    finally {
+        readline.close();
+    }
+}
+function installersFromTokens(tokens) {
+    const normalized = tokens.flatMap(splitTargetTokens);
+    if (normalized.length === 0) {
+        return installersFromTokens(["auto"]);
+    }
+    const selected = new Map();
+    for (const token of normalized) {
+        const lower = token.toLowerCase();
+        if (lower === "none") {
+            return [];
+        }
+        if (lower === "auto" || lower === "all") {
+            for (const installer of AGENT_INSTALLERS) {
+                selected.set(installer.id, installer);
+            }
+            continue;
+        }
+        const numbered = /^\d+$/.test(lower) ? Number(lower) : Number.NaN;
+        if (Number.isInteger(numbered) &&
+            numbered >= 1 &&
+            numbered <= AGENT_INSTALLERS.length) {
+            const installer = AGENT_INSTALLERS[numbered - 1];
+            selected.set(installer.id, installer);
+            continue;
+        }
+        const installer = AGENT_INSTALLERS.find((candidate) => candidate.id === lower || candidate.label.toLowerCase() === lower);
+        if (!installer) {
+            throw new Error(`Unknown install target: ${token}`);
+        }
+        selected.set(installer.id, installer);
+    }
+    return [...selected.values()];
+}
+function splitTargetTokens(value) {
+    return value
+        .split(/[,\s]+/)
+        .map((target) => target.trim())
+        .filter((target) => target.length > 0);
 }
 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;
     }
     const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, rootPath.absolutePath));
     const progress = createIndexProgressReporter();
@@ -40,14 +224,23 @@ async function runIndex(parsed) {
             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);
+        persistExplicitGlobalConfig(parsed.options, info.collection?.embedding?.provider);
     }
     catch (error) {
         progress.finish();
@@ -57,24 +250,50 @@ 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));
     try {
-        const info = await zvecGrep.disableIndex({ root });
-        printAnonymousInfo(info, parsed.options);
+        const removed = await zvecGrep.dropIndex({ root });
+        console.log(removed ? `Dropped index for ${root}` : `No index found for ${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 runServe(parsed) {
+    if (parsed.positionals.length > 0) {
+        throw new Error("zg serve --mcp does not accept positional arguments");
+    }
+    const { runMcpServer } = await import("./mcp.js");
+    await runMcpServer(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");
+        throw new Error("zg status accepts at most one root path");
     }
     const zvecGrep = await createZvecGrep(createServiceOptions(parsed.options, root));
     try {
@@ -87,21 +306,26 @@ async function runStatus(parsed) {
 }
 async function runCollections(parsed) {
     const [action = "list", name, root] = parsed.positionals;
+    validateCollectionArguments(action, parsed.positionals);
+    const indexOption = collectionIndexOption(parsed.options);
+    if (action !== "index" && indexOption) {
+        throw new Error(`${indexOption} can only be used with zg collections index`);
+    }
     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");
+                throw new Error("--reset-paths can only be used with zg 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");
+                throw new Error("--reset-paths can only be used with zg collections index");
             }
             if (!name) {
-                throw new Error("zg --collections info requires <name>");
+                throw new Error("zg collections info requires <name>");
             }
             const [info, status] = await Promise.all([
                 zvecGrep.collections.info(name),
@@ -115,7 +339,7 @@ async function runCollections(parsed) {
         }
         if (action === "index") {
             if (!name) {
-                throw new Error("zg --collections index requires <name>");
+                throw new Error("zg collections index requires <name>");
             }
             const explicitRoot = root !== undefined;
             const rootPath = indexRootPath(root ?? process.cwd(), parsed.options);
@@ -125,14 +349,23 @@ async function runCollections(parsed) {
                 const result = await zvecGrep.collections.index(name, rootPaths, {
                     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.collections.info(name);
                 printIndexResult(`Indexed collection ${name}`, result, parsed.options, info?.rootPaths);
+                persistExplicitGlobalConfig(parsed.options, info?.embedding?.provider);
             }
             catch (error) {
                 progress.finish();
@@ -142,17 +375,17 @@ async function runCollections(parsed) {
         }
         if (action === "remove") {
             if (parsed.options.resetPaths) {
-                throw new Error("--reset-paths can only be used with --collections index");
+                throw new Error("--reset-paths can only be used with zg collections index");
             }
             if (!name) {
-                throw new Error("zg --collections remove requires <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("--reset-paths can only be used with zg collections index");
         }
         throw new Error(`Unknown collections action: ${action}`);
     }
@@ -160,19 +393,67 @@ async function runCollections(parsed) {
         await zvecGrep.close();
     }
 }
+function validateCollectionArguments(action, positionals) {
+    if (action === "list") {
+        if (positionals.length > 1) {
+            throw new Error("zg collections list does not accept arguments");
+        }
+        return;
+    }
+    if (action === "info" || action === "remove") {
+        if (positionals.length > 2) {
+            throw new Error(`zg collections ${action} accepts only <name>`);
+        }
+        return;
+    }
+    if (action === "index") {
+        if (positionals.length > 3) {
+            throw new Error("zg collections index accepts only <name> and [root]");
+        }
+        return;
+    }
+    throw new Error(`Unknown collections action: ${action}`);
+}
+function collectionIndexOption(options) {
+    const candidates = [
+        [options.rebuild, "--rebuild"],
+        [options.resetPaths, "--reset-paths"],
+        [options.embedding, "--embedding"],
+        [options.modelCacheDir, "--model-cache"],
+        [options.llamaGpu, "--llama-gpu"],
+        [options.embeddingParallelism, "--embedding-parallelism"],
+        [options.apiKey, "--api-key"],
+        [options.endpoint, "--endpoint"],
+        [options.embeddingConcurrency, "--embedding-concurrency"],
+        [options.globs?.length, "--glob"],
+        [options.insensitiveGlobs?.length, "--iglob"],
+        [options.fileTypes?.length, "--type"],
+        [options.excludedFileTypes?.length, "--type-not"],
+        [options.hidden, "--hidden"],
+        [options.noIgnore, "--no-ignore"],
+        [options.ignoreFiles?.length, "--ignore-file"],
+        [options.maxDepth, "--max-depth"],
+        [options.maxFileSizeBytes, "--max-filesize"],
+        [options.follow, "--follow"],
+    ];
+    return candidates.find(([value]) => Array.isArray(value) ? value.length > 0 : value !== undefined)?.[1];
+}
 async function runQuery(parsed) {
-    const rgInput = parsed.options.rg
-        ? normalizeRgInput(parsed)
-        : undefined;
+    const rgInput = parsed.options.rg ? normalizeRgInput(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.");
     }
     const zvecGrep = await createZvecGrep(createServiceOptions(commandOptions, undefined));
     const progress = createIndexProgressReporter();
@@ -213,15 +494,23 @@ function contextOptions(options, queries, onAutoUpdateProgress) {
         rgOptions: options.rgOptions,
         rgPaths: options.rgPaths,
         routes: options.routes,
+        fuse: options.fuse,
         collection: options.collection,
         limit: options.limit,
-        fallback: "disabled",
         autoUpdate: !options.noAutoUpdate,
         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,
@@ -230,10 +519,11 @@ function contextOptions(options, queries, onAutoUpdateProgress) {
 }
 function normalizeRgInput(parsed) {
     const explicitPatterns = parsed.options.rgOptions?.patterns ?? [];
-    const queries = explicitPatterns.length > 0
+    const hasPatternFiles = (parsed.options.rgOptions?.patternFiles?.length ?? 0) > 0;
+    const queries = explicitPatterns.length > 0 || hasPatternFiles
         ? explicitPatterns
         : parsed.positionals.slice(0, 1);
-    const paths = explicitPatterns.length > 0
+    const paths = explicitPatterns.length > 0 || hasPatternFiles
         ? parsed.positionals
         : parsed.positionals.slice(1);
     return {
@@ -244,12 +534,12 @@ function normalizeRgInput(parsed) {
         },
     };
 }
-function createServiceOptions(options, root) {
+export 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 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;
     return {
         root,
@@ -259,15 +549,25 @@ function createServiceOptions(options, root) {
         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),
+        embeddingParallelism: options.embeddingParallelism ??
+            parseEnvPositiveInteger(process.env.ZVEC_GREP_EMBED_PARALLELISM),
     };
 }
+function persistExplicitGlobalConfig(options, indexedProvider) {
+    if (!updateGlobalConfigFromExplicitOptions(options, indexedProvider)) {
+        return;
+    }
+    console.log(`Global config: ${globalConfigPath()}`);
+}
 function parseEnvLlamaGpu(value) {
     const normalized = value?.trim().toLowerCase() ?? "";
     if (!normalized) {
         return undefined;
     }
-    if (normalized === "auto" || normalized === "metal" || normalized === "vulkan" || normalized === "cuda") {
+    if (normalized === "auto" ||
+        normalized === "metal" ||
+        normalized === "vulkan" ||
+        normalized === "cuda") {
         return normalized;
     }
     if (["false", "off", "none", "disable", "disabled", "0"].includes(normalized)) {
@@ -277,11 +577,237 @@ function parseEnvLlamaGpu(value) {
 }
 function parseEnvPositiveInteger(value) {
     const normalized = value?.trim() ?? "";
-    if (!normalized) {
+    if (!/^\d+$/.test(normalized)) {
         return undefined;
     }
-    const parsed = Number.parseInt(normalized, 10);
-    return Number.isInteger(parsed) && parsed > 0 ? parsed : undefined;
+    const parsed = Number(normalized);
+    return Number.isSafeInteger(parsed) && parsed > 0 ? parsed : undefined;
+}
+function resolveCodexHome() {
+    return resolve(process.env.CODEX_HOME ?? resolve(homedir(), ".codex"));
+}
+async function writeMarkedFile(options) {
+    let existing = await readTextFileIfExists(options.path);
+    const next = replaceMarkedBlock(existing, options.startMarker, options.endMarker, options.block);
+    if (next === null) {
+        existing = removeOrphanedMarkers(existing, options.startMarker, options.endMarker);
+    }
+    if (next === null && options.hasConflict?.(existing)) {
+        if (!options.force) {
+            throw new Error(options.conflictMessage ??
+                `Existing unmanaged configuration found in ${options.path}`);
+        }
+        existing = options.removeConflict
+            ? options.removeConflict(existing)
+            : existing;
+    }
+    await writeTextFileAtomic(options.path, next ?? appendMarkedBlock(existing, options.block));
+}
+async function removeMarkedFile(options) {
+    const existing = await readTextFileIfExists(options.path);
+    if (!existing) {
+        return;
+    }
+    const next = replaceMarkedBlock(existing, options.startMarker, options.endMarker, "") ??
+        removeOrphanedMarkers(existing, options.startMarker, options.endMarker);
+    if (next === existing) {
+        return;
+    }
+    await writeTextFileAtomic(options.path, next);
+}
+async function writeTextFileAtomic(path, content) {
+    const targetPath = await resolveAtomicWriteTarget(path);
+    await mkdir(dirname(targetPath), { recursive: true });
+    const mode = await fileModeIfExists(targetPath);
+    const temporaryPath = `${targetPath}.${process.pid}.${randomUUID()}.tmp`;
+    let temporaryFile;
+    try {
+        temporaryFile = await open(temporaryPath, "wx", mode);
+        await temporaryFile.writeFile(content, "utf8");
+        await temporaryFile.sync();
+        await temporaryFile.close();
+        temporaryFile = undefined;
+        if (mode !== undefined) {
+            await chmod(temporaryPath, mode);
+        }
+        await rename(temporaryPath, targetPath);
+    }
+    catch (error) {
+        await temporaryFile?.close().catch(() => undefined);
+        await unlink(temporaryPath).catch(() => undefined);
+        throw error;
+    }
+}
+async function resolveAtomicWriteTarget(path, visited = new Set()) {
+    const absolutePath = resolve(path);
+    if (visited.has(absolutePath)) {
+        throw new Error(`Cannot atomically write through circular symbolic link: ${path}`);
+    }
+    try {
+        const file = await lstat(absolutePath);
+        if (!file.isSymbolicLink()) {
+            return absolutePath;
+        }
+        visited.add(absolutePath);
+        const link = await readlink(absolutePath);
+        return resolveAtomicWriteTarget(resolve(dirname(absolutePath), link), visited);
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return absolutePath;
+        }
+        throw error;
+    }
+}
+async function fileModeIfExists(path) {
+    try {
+        return (await stat(path)).mode & 0o777;
+    }
+    catch (error) {
+        if (isNodeError(error) && error.code === "ENOENT") {
+            return undefined;
+        }
+        throw error;
+    }
+}
+async function readTextFileIfExists(path) {
+    try {
+        return await readFile(path, "utf8");
+    }
+    catch (error) {
+        if (error instanceof Error && "code" in error && error.code === "ENOENT") {
+            return "";
+        }
+        throw error;
+    }
+}
+function isNodeError(error) {
+    return typeof error === "object" && error !== null && "code" in error;
+}
+function replaceMarkedBlock(existing, startMarker, endMarker, block) {
+    const lines = existing.split(/\r?\n/);
+    const markerLines = new Set();
+    const ranges = [];
+    let pendingStart;
+    for (const [index, line] of lines.entries()) {
+        const trimmed = line.trim();
+        if (trimmed === startMarker) {
+            markerLines.add(index);
+            pendingStart = index;
+            continue;
+        }
+        if (trimmed === endMarker) {
+            markerLines.add(index);
+            if (pendingStart !== undefined) {
+                ranges.push({ start: pendingStart, end: index });
+                pendingStart = undefined;
+            }
+        }
+    }
+    const first = ranges[0];
+    if (!first) {
+        return null;
+    }
+    const before = retainedMarkedLines(lines, 0, first.start, markerLines, [])
+        .join("\n")
+        .trimEnd();
+    const after = retainedMarkedLines(lines, first.end + 1, lines.length, markerLines, ranges.slice(1))
+        .join("\n")
+        .trim();
+    return ([before, block.trim(), after.trim()]
+        .filter((part) => part.length > 0)
+        .join("\n\n") + "\n");
+}
+function retainedMarkedLines(lines, start, end, markerLines, removedRanges) {
+    const retained = [];
+    for (let index = start; index < end; index += 1) {
+        if (markerLines.has(index)) {
+            continue;
+        }
+        if (removedRanges.some((range) => index >= range.start && index <= range.end)) {
+            continue;
+        }
+        retained.push(lines[index]);
+    }
+    return retained;
+}
+function removeOrphanedMarkers(existing, startMarker, endMarker) {
+    return (existing
+        .split(/\r?\n/)
+        .filter((line) => {
+        const trimmed = line.trim();
+        return trimmed !== startMarker && trimmed !== endMarker;
+    })
+        .join("\n")
+        .trimEnd() + "\n");
+}
+function appendMarkedBlock(existing, block) {
+    const prefix = existing.trimEnd();
+    return `${prefix.length > 0 ? `${prefix}\n\n` : ""}${block.trim()}\n`;
+}
+function hasCodexMcpServerConfig(existing) {
+    return existing.split(/\r?\n/).some((line) => {
+        const tableName = tomlTableName(line);
+        return tableName !== undefined && isCodexMcpServerTableName(tableName);
+    });
+}
+function removeCodexMcpServerConfig(existing) {
+    const lines = existing.split(/\r?\n/);
+    const kept = [];
+    let skipping = false;
+    for (const line of lines) {
+        const tableName = tomlTableName(line);
+        if (tableName !== undefined) {
+            skipping = isCodexMcpServerTableName(tableName);
+        }
+        if (!skipping) {
+            kept.push(line);
+        }
+    }
+    return kept.join("\n").trimEnd() + "\n";
+}
+function tomlTableName(line) {
+    return line.match(/^\s*\[([^\]]+)\]\s*(?:#.*)?$/)?.[1]?.trim();
+}
+function isCodexMcpServerTableName(tableName) {
+    return /^(?:mcp_servers|"mcp_servers"|'mcp_servers')\s*\.\s*(?:zvec_grep|"zvec_grep"|'zvec_grep')(?:\s*\.|$)/.test(tableName);
+}
+function codexConfigBlock(mcpToolTimeoutSeconds) {
+    return `${ZVEC_GREP_CONFIG_START}
+[mcp_servers.zvec_grep]
+command = "zg"
+args = ["serve", "--mcp"]
+env_vars = [
+  "DASHSCOPE_API_KEY",
+  "QWEN_API_KEY",
+  "ZVEC_GREP_API_KEY",
+  "ZVEC_GREP_EMBEDDING",
+  "ZVEC_GREP_ENDPOINT",
+  "ZVEC_GREP_HOME",
+  "ZVEC_GREP_MODEL_CACHE",
+  "ZVEC_GREP_LLAMA_GPU",
+  "ZVEC_GREP_EMBED_PARALLELISM",
+  "NODE_LLAMA_CPP_CMAKE_OPTION_GGML_OPENMP",
+  "NODE_LLAMA_CPP_CMAKE_OPTION_GGML_NATIVE",
+  "NODE_LLAMA_CPP_CMAKE_OPTION_GGML_CPU_ARM_ARCH"
+]
+startup_timeout_sec = 20
+tool_timeout_sec = ${mcpToolTimeoutSeconds}
+default_tools_approval_mode = "auto"
+${ZVEC_GREP_CONFIG_END}`;
+}
+function codexAgentsBlock() {
+    return `${ZVEC_GREP_AGENTS_START}
+## zvec-grep
+
+Use zvec-grep before grep, rg, or broad file reads when you need to understand or locate code.
+
+- **MCP tools**: Use \`zvec_grep_search\` for indexed semantic/lexical code search and \`zvec_grep_rg\` for explicit no-index lexical search.
+- **Indexing and status**: These are CLI-only operations. If an index is missing, use \`zvec_grep_rg\` and mention \`zg index\` as the opt-in setup path; use \`zg status\` when status inspection is needed.
+- **Shell fallback**: If the MCP server is unavailable, use \`zg status\`, \`zg query "<query>"\`, and \`zg query --rg "<pattern>"\`.
+
+Prefer focused -g/--glob and -t/--type filters, and exclude dependencies, generated output, caches, build artifacts, and logs unless the task is about those files.
+${ZVEC_GREP_AGENTS_END}`;
 }
 function resolveIndexRoot(root) {
     if (root !== undefined) {
@@ -293,8 +819,16 @@ 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