@zvec/zvec-grep 0.1.5 → 0.1.7

package/dist/cli/install.js

@@ -0,0 +1,963 @@
+import { randomUUID } from "node:crypto";
+import { constants as fileSystemConstants } from "node:fs";
+import { access, chmod, lstat, mkdir, open, readFile, readlink, rename, stat, unlink, } from "node:fs/promises";
+import { homedir } from "node:os";
+import { delimiter, dirname, resolve } from "node:path";
+import { createInterface } from "node:readline/promises";
+import { resolveServerUrl } from "../client/mode-router.js";
+import { formatPromptRules, ZVEC_GREP_WORKSPACE_EVIDENCE_RULES, } from "../prompts/zvec-grep-guidance.js";
+const AGENT_INSTALLERS = [
+    {
+        id: "claude",
+        label: "Claude Code",
+        executable: "claude",
+        install: installClaudeIntegration,
+        uninstall: uninstallClaudeIntegration,
+    },
+    {
+        id: "codex",
+        label: "Codex",
+        executable: "codex",
+        install: installCodexIntegration,
+        uninstall: uninstallCodexIntegration,
+    },
+    {
+        id: "opencode",
+        label: "OpenCode",
+        executable: "opencode",
+        install: installOpenCodeIntegration,
+        uninstall: uninstallOpenCodeIntegration,
+    },
+    {
+        id: "cursor",
+        label: "Cursor",
+        executable: "cursor",
+        install: installCursorIntegration,
+        uninstall: uninstallCursorIntegration,
+    },
+];
+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 CLAUDE_MCP_PERMISSION = "mcp__zvec_grep__*";
+const DEFAULT_MCP_TOOL_TIMEOUT_SECONDS = 600;
+export async function runInstall(parsed) {
+    printInstallHeader();
+    const installers = await resolveInstallers(parsed, "install");
+    if (installers.length === 0) {
+        console.log("\nNo agent integrations selected.");
+        return;
+    }
+    const transport = await resolveInstallTransport(parsed);
+    console.log("\nInstalling integrations\n");
+    for (const installer of installers) {
+        await installer.install({
+            force: parsed.options.force === true,
+            transport,
+            mcpToolset: parsed.options.mcpToolset,
+            mcpToolTimeoutSeconds: parsed.options.installMcpToolTimeoutSeconds ??
+                DEFAULT_MCP_TOOL_TIMEOUT_SECONDS,
+            mcpTokenEnv: parsed.options.installMcpTokenEnv,
+        });
+        console.log(`  ${installSuccessMark()} ${installer.label}`);
+        console.log("    MCP       configured");
+        console.log("");
+    }
+    const server = await ensureInstalledServer(parsed.options.mcpToolset);
+    if (server.ready) {
+        console.log(`  ${installSuccessMark()} Server`);
+        console.log(`    ready at ${server.serverUrl ?? resolveServerUrl()}`);
+    }
+    else {
+        console.log(`  ${installMutedMark()} Server`);
+        console.log("    not started; run `zg server on`");
+    }
+    if (transport === "stdio") {
+        console.log(`  ${installSuccessMark()} Connection`);
+        console.log("    stdio; reconnects start the server automatically");
+    }
+    console.log("\nzvec-grep is ready\n");
+    console.log(`  Agents       ${installers.map((installer) => installer.label).join(", ")}`);
+    console.log("  Remote data  Authorization requested on first remote use");
+    console.log("\nRestart the selected agents or start a new session to load the integration.");
+}
+export async function runUninstall(parsed) {
+    printInstallHeader();
+    const installers = await resolveInstallers(parsed, "uninstall");
+    if (installers.length === 0) {
+        console.log("\nNo agent integrations selected.");
+        return;
+    }
+    console.log("\nRemoving integrations\n");
+    for (const installer of installers) {
+        await installer.uninstall();
+        console.log(`  ${installSuccessMark()} ${installer.label}`);
+        console.log("    integration removed");
+    }
+    console.log("\nRestart the selected agents 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),
+        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: agentGuidanceBlock(),
+        force: true,
+    });
+    return { files: [configPath, agentsPath] };
+}
+async function installClaudeIntegration(options) {
+    const configDirectory = resolveClaudeConfigDirectory();
+    const mcpConfigPath = resolveClaudeMcpConfigPath();
+    const settingsPath = resolve(configDirectory, "settings.json");
+    const guidancePath = resolve(configDirectory, "CLAUDE.md");
+    await updateClaudeMcpConfig({
+        path: mcpConfigPath,
+        force: options.force,
+        transport: options.transport,
+        mcpToolset: options.mcpToolset,
+        tokenEnv: options.mcpTokenEnv,
+    });
+    await updateClaudePermissionSettings(settingsPath, true);
+    await writeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+        block: agentGuidanceBlock(),
+        force: true,
+    });
+    return { files: [mcpConfigPath, settingsPath, guidancePath] };
+}
+async function uninstallClaudeIntegration() {
+    const configDirectory = resolveClaudeConfigDirectory();
+    const mcpConfigPath = resolveClaudeMcpConfigPath();
+    const settingsPath = resolve(configDirectory, "settings.json");
+    const guidancePath = resolve(configDirectory, "CLAUDE.md");
+    await removeClaudeMcpConfig(mcpConfigPath);
+    await updateClaudePermissionSettings(settingsPath, false);
+    await removeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+    });
+    return { files: [mcpConfigPath, settingsPath, guidancePath] };
+}
+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 installOpenCodeIntegration(options) {
+    const configPath = resolveOpenCodeConfigPath();
+    const guidancePath = resolve(dirname(configPath), "AGENTS.md");
+    await installJsonMcpServer({
+        path: configPath,
+        containerKey: "mcp",
+        server: options.transport === "stdio"
+            ? {
+                type: "local",
+                command: stdioCommand(options.mcpToolset),
+                enabled: true,
+                timeout: options.mcpToolTimeoutSeconds * 1_000,
+            }
+            : {
+                type: "remote",
+                url: resolveServerUrl(),
+                enabled: true,
+                timeout: options.mcpToolTimeoutSeconds * 1_000,
+                oauth: false,
+                ...(options.mcpTokenEnv
+                    ? {
+                        headers: {
+                            Authorization: `Bearer {env:${options.mcpTokenEnv}}`,
+                        },
+                    }
+                    : {}),
+            },
+        force: options.force,
+        label: "OpenCode",
+    });
+    await writeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+        block: agentGuidanceBlock({
+            search: "zvec_grep_zvec_grep_search",
+            rg: "zvec_grep_zvec_grep_rg",
+        }),
+        force: true,
+    });
+    return { files: [configPath, guidancePath] };
+}
+async function uninstallOpenCodeIntegration() {
+    const configPath = resolveOpenCodeConfigPath();
+    const guidancePath = resolve(dirname(configPath), "AGENTS.md");
+    await uninstallJsonMcpServer(configPath, "mcp");
+    await removeMarkedFile({
+        path: guidancePath,
+        startMarker: ZVEC_GREP_AGENTS_START,
+        endMarker: ZVEC_GREP_AGENTS_END,
+    });
+    return { files: [configPath, guidancePath] };
+}
+async function installCursorIntegration(options) {
+    const configPath = resolveCursorConfigPath();
+    await installJsonMcpServer({
+        path: configPath,
+        containerKey: "mcpServers",
+        server: options.transport === "stdio"
+            ? { command: "zg", args: stdioArgs(options.mcpToolset) }
+            : {
+                url: resolveServerUrl(),
+                ...(options.mcpTokenEnv
+                    ? {
+                        headers: {
+                            Authorization: `Bearer \${${options.mcpTokenEnv}}`,
+                        },
+                    }
+                    : {}),
+            },
+        force: options.force,
+        label: "Cursor",
+    });
+    return { files: [configPath] };
+}
+async function uninstallCursorIntegration() {
+    const configPath = resolveCursorConfigPath();
+    await uninstallJsonMcpServer(configPath, "mcpServers");
+    return { files: [configPath] };
+}
+async function resolveInstallers(parsed, action) {
+    const detected = await detectAgentInstallers();
+    const targetTokens = [
+        ...(parsed.options.installTargets ?? []),
+        ...parsed.positionals,
+    ];
+    if (targetTokens.length > 0) {
+        return installersFromTokens(targetTokens, detected);
+    }
+    if (parsed.options.yes === true ||
+        !process.stdin.isTTY ||
+        !process.stdout.isTTY) {
+        return installersFromTokens(["auto"], detected);
+    }
+    return promptInstallers(action, detected);
+}
+async function resolveInstallTransport(parsed) {
+    if (parsed.options.installMcpTransport) {
+        return parsed.options.installMcpTransport;
+    }
+    if (parsed.options.yes === true ||
+        !process.stdin.isTTY ||
+        !process.stdout.isTTY) {
+        return "stdio";
+    }
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question("MCP transport [stdio] (stdio/http): ");
+        const value = answer.trim().toLowerCase();
+        if (!value || value === "stdio")
+            return "stdio";
+        if (value === "http")
+            return "http";
+        throw new Error("MCP transport must be stdio or http");
+    }
+    finally {
+        readline.close();
+    }
+}
+async function promptInstallers(action, detected) {
+    console.log(action === "install"
+        ? "\nChoose agent integrations\n"
+        : "\nChoose integrations to remove\n");
+    const selected = await promptInstallerSelection(detected);
+    return AGENT_INSTALLERS.filter((installer) => selected.has(installer.id));
+}
+function installersFromTokens(tokens, detected = new Set()) {
+    const normalized = tokens.flatMap(splitTargetTokens);
+    if (normalized.length === 0) {
+        return installersFromTokens(["auto"], detected);
+    }
+    const selected = new Map();
+    for (const token of normalized) {
+        const input = token.toLowerCase();
+        const lower = input === "cc" || input === "claude-code" ? "claude" : input;
+        if (lower === "none") {
+            return [];
+        }
+        if (lower === "auto") {
+            for (const installer of AGENT_INSTALLERS) {
+                if (detected.has(installer.id)) {
+                    selected.set(installer.id, installer);
+                }
+            }
+            continue;
+        }
+        if (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()];
+}
+async function detectAgentInstallers() {
+    const detected = new Set();
+    const checks = await Promise.all(AGENT_INSTALLERS.map(async (installer) => ({
+        installer,
+        available: await executableIsAvailable(installer.executable),
+    })));
+    for (const check of checks) {
+        if (check.available) {
+            detected.add(check.installer.id);
+        }
+    }
+    return detected;
+}
+async function executableIsAvailable(executable) {
+    const path = process.env.PATH ?? "";
+    const extensions = process.platform === "win32"
+        ? (process.env.PATHEXT ?? ".EXE;.CMD;.BAT;.COM").split(";")
+        : [""];
+    for (const pathEntry of path.split(delimiter)) {
+        const directory = pathEntry || process.cwd();
+        for (const extension of extensions) {
+            try {
+                await access(resolve(directory, `${executable}${extension.toLowerCase()}`), fileSystemConstants.X_OK);
+                return true;
+            }
+            catch {
+                // Continue searching PATH.
+            }
+        }
+    }
+    return false;
+}
+async function promptInstallerSelection(detected) {
+    if (typeof process.stdin.setRawMode !== "function") {
+        return promptInstallerLineSelection(detected);
+    }
+    let activeIndex = Math.max(0, AGENT_INSTALLERS.findIndex((installer) => detected.has(installer.id)));
+    let renderedLineCount = 0;
+    const render = () => {
+        const lines = installerSelectionLines(activeIndex, detected);
+        if (renderedLineCount > 0) {
+            process.stdout.write(`\u001b[${renderedLineCount}A`);
+        }
+        for (const line of lines) {
+            process.stdout.write(`\u001b[2K${line}\n`);
+        }
+        renderedLineCount = lines.length;
+    };
+    render();
+    return new Promise((resolveSelection) => {
+        const wasRaw = process.stdin.isRaw === true;
+        const finish = (result) => {
+            process.stdin.removeListener("data", onData);
+            process.stdin.setRawMode(wasRaw);
+            if (!wasRaw)
+                process.stdin.pause();
+            process.stdout.write("\n");
+            resolveSelection(result);
+        };
+        const onData = (chunk) => {
+            const key = chunk.toString();
+            if (key === "\u0003" || key === "\u001b") {
+                finish(new Set());
+                return;
+            }
+            if (key === "\u001b[A") {
+                activeIndex =
+                    (activeIndex - 1 + AGENT_INSTALLERS.length) % AGENT_INSTALLERS.length;
+                render();
+                return;
+            }
+            if (key === "\u001b[B") {
+                activeIndex = (activeIndex + 1) % AGENT_INSTALLERS.length;
+                render();
+                return;
+            }
+            if (key.includes("\r") || key.includes("\n")) {
+                finish(new Set([AGENT_INSTALLERS[activeIndex].id]));
+            }
+        };
+        process.stdin.setRawMode(true);
+        process.stdin.resume();
+        process.stdin.on("data", onData);
+    });
+}
+export function installerSelectionLines(activeIndex, detected) {
+    const labelWidth = Math.max(...AGENT_INSTALLERS.map((installer) => installer.label.length));
+    return [
+        ...AGENT_INSTALLERS.map((installer, index) => {
+            const marker = index === activeIndex ? installSuccess("●") : installDim("○");
+            const label = installer.label.padEnd(labelWidth);
+            const status = detected.has(installer.id)
+                ? installDim("detected")
+                : installDim("not found");
+            return `  ${marker} ${label}  ${status}`;
+        }),
+        "",
+        installDim("  Use ↑↓ to move · Enter to select"),
+    ];
+}
+async function promptInstallerLineSelection(detected) {
+    AGENT_INSTALLERS.forEach((installer, index) => {
+        console.log(`  ${index + 1}. ${installer.label} (${detected.has(installer.id) ? "detected" : "not found"})`);
+    });
+    const defaults = [...detected].join(",") || "none";
+    const readline = createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    try {
+        const answer = await readline.question(`Agents [${defaults}]: `);
+        const value = answer.trim() || defaults;
+        return new Set(installersFromTokens(splitTargetTokens(value), detected).map((installer) => installer.id));
+    }
+    finally {
+        readline.close();
+    }
+}
+function printInstallHeader() {
+    console.log(installAccent("zvec-grep setup"));
+    console.log(installDim("─".repeat(40)));
+}
+function installSuccessMark() {
+    return installSuccess("✓");
+}
+function installMutedMark() {
+    return installDim("○");
+}
+function installSuccess(value) {
+    return installStyle("32", value);
+}
+function installAccent(value) {
+    return installStyle("36", value);
+}
+function installDim(value) {
+    return installStyle("2", value);
+}
+function installStyle(code, value) {
+    return process.stdout.isTTY && process.env.NO_COLOR === undefined
+        ? `\u001b[${code}m${value}\u001b[0m`
+        : value;
+}
+async function ensureInstalledServer(mcpToolset) {
+    if (process.env.ZVEC_GREP_INSTALL_SKIP_SERVER === "1") {
+        return { running: false, ready: false };
+    }
+    const { startServer } = await import("../daemon/server-controller.js");
+    return startServer({ cliPath: process.argv[1], mcpToolset });
+}
+function splitTargetTokens(value) {
+    return value
+        .split(/[,\s]+/)
+        .map((target) => target.trim())
+        .filter((target) => target.length > 0);
+}
+function resolveCodexHome() {
+    return resolve(process.env.CODEX_HOME ?? resolve(homedir(), ".codex"));
+}
+function resolveClaudeConfigDirectory() {
+    return resolve(process.env.CLAUDE_CONFIG_DIR ?? resolve(homedir(), ".claude"));
+}
+function resolveClaudeMcpConfigPath() {
+    return process.env.CLAUDE_CONFIG_DIR
+        ? resolve(process.env.CLAUDE_CONFIG_DIR, ".claude.json")
+        : resolve(homedir(), ".claude.json");
+}
+function resolveOpenCodeConfigPath() {
+    return resolve(process.env.OPENCODE_CONFIG ??
+        resolve(homedir(), ".config", "opencode", "opencode.json"));
+}
+function resolveCursorConfigPath() {
+    return resolve(process.env.CURSOR_CONFIG_DIR ?? resolve(homedir(), ".cursor"), "mcp.json");
+}
+async function installJsonMcpServer(options) {
+    const config = await readJsonObject(options.path);
+    const existingContainer = config[options.containerKey];
+    if (existingContainer !== undefined && !isJsonObject(existingContainer)) {
+        throw new Error(`Expected ${options.containerKey} in ${options.path} to be a JSON object`);
+    }
+    const container = { ...(existingContainer ?? {}) };
+    const existingServer = container.zvec_grep;
+    if (existingServer !== undefined &&
+        !isManagedJsonMcpServer(existingServer) &&
+        !options.force) {
+        throw new Error(`Existing unmanaged zvec_grep MCP server found in ${options.path}. Re-run with --force to replace it for ${options.label}.`);
+    }
+    container.zvec_grep = options.server;
+    config[options.containerKey] = container;
+    await writeTextFileAtomic(options.path, `${JSON.stringify(config, null, 2)}\n`);
+}
+async function uninstallJsonMcpServer(path, containerKey) {
+    const existing = await readTextFileIfExists(path);
+    if (!existing)
+        return;
+    const config = parseJsonObject(path, existing);
+    const container = config[containerKey];
+    if (!isJsonObject(container))
+        return;
+    if (!isManagedJsonMcpServer(container.zvec_grep))
+        return;
+    const nextContainer = { ...container };
+    delete nextContainer.zvec_grep;
+    if (Object.keys(nextContainer).length === 0) {
+        delete config[containerKey];
+    }
+    else {
+        config[containerKey] = nextContainer;
+    }
+    await writeTextFileAtomic(path, `${JSON.stringify(config, null, 2)}\n`);
+}
+async function updateClaudeMcpConfig(options) {
+    const root = await readJsonObject(options.path);
+    const currentServers = root.mcpServers;
+    if (currentServers !== undefined &&
+        !isJsonObject(currentServers) &&
+        !options.force) {
+        throw new Error(`Invalid mcpServers configuration in ${options.path}. Re-run with --force to replace it.`);
+    }
+    const mcpServers = isJsonObject(currentServers) ? currentServers : {};
+    const current = mcpServers.zvec_grep;
+    if (current !== undefined &&
+        !isManagedJsonMcpServer(current) &&
+        !options.force) {
+        throw new Error(`Existing Claude Code MCP server "zvec_grep" found in ${options.path}. Re-run with --force to replace it.`);
+    }
+    const existingServer = isJsonObject(current) ? current : {};
+    const { type: _type, url: _url, command: _command, args: _args, headers: _headers, ...retained } = existingServer;
+    mcpServers.zvec_grep =
+        options.transport === "stdio"
+            ? {
+                ...retained,
+                type: "stdio",
+                command: "zg",
+                args: stdioArgs(options.mcpToolset),
+            }
+            : {
+                ...retained,
+                type: "http",
+                url: resolveServerUrl(),
+                ...(options.tokenEnv
+                    ? {
+                        headers: {
+                            Authorization: `Bearer \${${options.tokenEnv}}`,
+                        },
+                    }
+                    : {}),
+            };
+    root.mcpServers = mcpServers;
+    await writeJsonObject(options.path, root);
+}
+async function removeClaudeMcpConfig(path) {
+    const source = await readTextFileIfExists(path);
+    if (!source.trim())
+        return;
+    const root = parseJsonObject(path, source);
+    if (!isJsonObject(root.mcpServers))
+        return;
+    const current = root.mcpServers.zvec_grep;
+    if (!isManagedJsonMcpServer(current))
+        return;
+    delete root.mcpServers.zvec_grep;
+    if (Object.keys(root.mcpServers).length === 0) {
+        delete root.mcpServers;
+    }
+    await writeJsonObject(path, root);
+}
+async function updateClaudePermissionSettings(path, grant) {
+    const source = await readTextFileIfExists(path);
+    if (!source.trim() && !grant)
+        return;
+    const root = source.trim() ? parseJsonObject(path, source) : {};
+    const currentPermissions = root.permissions;
+    if (currentPermissions !== undefined && !isJsonObject(currentPermissions)) {
+        throw new Error(`Invalid permissions configuration in ${path}.`);
+    }
+    const permissions = isJsonObject(currentPermissions)
+        ? currentPermissions
+        : {};
+    const currentAllow = permissions.allow;
+    if (currentAllow !== undefined && !Array.isArray(currentAllow)) {
+        throw new Error(`Invalid permissions.allow configuration in ${path}.`);
+    }
+    if (Array.isArray(currentAllow) &&
+        currentAllow.some((item) => typeof item !== "string")) {
+        throw new Error(`Invalid permissions.allow rule in ${path}.`);
+    }
+    const allow = Array.isArray(currentAllow)
+        ? currentAllow.slice()
+        : [];
+    if (grant) {
+        if (!allow.includes(CLAUDE_MCP_PERMISSION)) {
+            allow.push(CLAUDE_MCP_PERMISSION);
+        }
+        permissions.allow = allow;
+        root.permissions = permissions;
+    }
+    else {
+        const retained = allow.filter((item) => item !== CLAUDE_MCP_PERMISSION);
+        if (retained.length > 0)
+            permissions.allow = retained;
+        else
+            delete permissions.allow;
+        if (Object.keys(permissions).length > 0)
+            root.permissions = permissions;
+        else
+            delete root.permissions;
+    }
+    await writeJsonObject(path, root);
+}
+async function readJsonObject(path) {
+    const source = await readTextFileIfExists(path);
+    return source.trim() ? parseJsonObject(path, source) : {};
+}
+function parseJsonObject(path, source) {
+    let parsed;
+    try {
+        parsed = JSON.parse(source);
+    }
+    catch (error) {
+        throw new Error(`Invalid JSON in ${path}.`, { cause: error });
+    }
+    if (!isJsonObject(parsed)) {
+        throw new Error(`Expected a JSON object in ${path}.`);
+    }
+    return parsed;
+}
+function isJsonObject(value) {
+    return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isManagedJsonMcpServer(value) {
+    if (!isJsonObject(value))
+        return false;
+    if (value.url === resolveServerUrl())
+        return true;
+    if (value.command === "zg" && isStdioArgs(value.args))
+        return true;
+    return (value.type === "local" &&
+        Array.isArray(value.command) &&
+        (value.command.length === 3 || value.command.length === 5) &&
+        value.command[0] === "zg" &&
+        value.command[1] === "server" &&
+        value.command[2] === "--stdio" &&
+        (value.command.length === 3 ||
+            (value.command[3] === "--mcp-toolset" &&
+                (value.command[4] === "agent" || value.command[4] === "full"))));
+}
+function isStdioArgs(value) {
+    return (Array.isArray(value) &&
+        (value.length === 2 || value.length === 4) &&
+        value[0] === "server" &&
+        value[1] === "--stdio" &&
+        (value.length === 2 ||
+            (value[2] === "--mcp-toolset" &&
+                (value[3] === "agent" || value[3] === "full"))));
+}
+function stdioArgs(mcpToolset) {
+    return [
+        "server",
+        "--stdio",
+        ...(mcpToolset ? ["--mcp-toolset", mcpToolset] : []),
+    ];
+}
+function stdioCommand(mcpToolset) {
+    return ["zg", ...stdioArgs(mcpToolset)];
+}
+function tomlStringArray(values) {
+    return `[${values.map((value) => JSON.stringify(value)).join(", ")}]`;
+}
+async function writeJsonObject(path, value) {
+    await writeTextFileAtomic(path, `${JSON.stringify(value, null, 2)}\n`);
+}
+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(options) {
+    return `${ZVEC_GREP_CONFIG_START}
+[mcp_servers.zvec_grep]
+${options.transport === "stdio"
+        ? `command = "zg"
+args = ${tomlStringArray(stdioArgs(options.mcpToolset))}`
+        : `url = "${resolveServerUrl()}"`}
+${options.mcpTokenEnv
+        ? `bearer_token_env_var = "${options.mcpTokenEnv}"
+`
+        : ""}tool_timeout_sec = ${options.mcpToolTimeoutSeconds}
+default_tools_approval_mode = "approve"
+${ZVEC_GREP_CONFIG_END}`;
+}
+function agentGuidanceBlock(toolNames) {
+    const searchTool = toolNames?.search ?? "zvec_grep_search";
+    const rgTool = toolNames?.rg ?? "zvec_grep_rg";
+    const exactLookupRoute = `\`${rgTool}\` when it is listed by the current host; otherwise native Grep or \`rg\``;
+    return `${ZVEC_GREP_AGENTS_START}
+## zvec-grep
+
+Choose the evidence source before the retrieval mode.
+
+${formatPromptRules("### Workspace evidence", ZVEC_GREP_WORKSPACE_EVIDENCE_RULES)}
+
+${formatPromptRules("### Retrieval routing", [
+        `When an exact word, phrase, name, date, identifier, filename, path, configuration key, error message, source fragment, literal, or regex is known and locating its occurrences is sufficient, use ${exactLookupRoute}.`,
+        `Use \`${searchTool}\` when wording or location is unknown, or when the answer requires semantic, conceptual, fuzzy, or paraphrase discovery; relationships, chronology, causality, architecture, or data or control flow; or comparison or synthesis across files, sections, or documents.`,
+        `For a mixed task with exact anchors that still requires relationships or cross-file synthesis, call \`${searchTool}\` with the concept and anchors, then use ${exactLookupRoute} for focused follow-up.`,
+        `When no sufficient exact anchor is available and the user asks whether conceptually related material exists locally, make at most one focused \`${searchTool}\` probe using the question plus distinctive names, dates, or terms. This probe does not apply to exact quotations, configuration keys, filenames, regexes, or exhaustive occurrence requests. Continue only when results are relevant; otherwise stop and report that the indexed workspace did not establish the answer.`,
+        "Before broad file reads or delegating workspace discovery, use the appropriate search route. Do not delegate solely to locate material, and stop when the evidence is sufficient.",
+    ])}
+
+${formatPromptRules("### Search arguments and evidence", [
+        "`query` creates one primary hybrid result group; `queries` creates one or more primary hybrid result groups.",
+        "`fts` and `vector` add supplemental lexical and semantic routes. `fts` is a retrieval route, not a hard filter or constraint.",
+        "Without `fuse`, search groups are evaluated separately and returned as one deduplicated, reranked list with query-group metadata. Set `fuse: true` to collapse the supplied primary and supplemental intents into one search plan.",
+        "Search results include bounded source snippets. Treat a sufficient snippet as already-read evidence, and read a cited file only when a required detail falls outside the snippet.",
+    ])}
+
+Example mixed search:
+
+\`\`\`json
+{
+  "root": "/absolute/workspace",
+  "query": "how are search results ranked and fused",
+  "fts": ["RRF", "score"],
+  "fuse": true
+}
+\`\`\`
+
+${formatPromptRules("### Freshness and index lifecycle", [
+        "Pass a daemon-visible absolute `root` on every zvec-grep workspace call.",
+        "Read `freshness` and `background_refresh` from search results without a status preflight.",
+        "When results are `served_from_current_index`, use them when sufficient instead of waiting for the background refresh.",
+        `If the index is missing but exact or regex lookup can answer the task, use ${exactLookupRoute}.`,
+        "Creating, rebuilding, or dropping a persistent index requires an explicit user request or authorization; never do so silently.",
+    ])}
+${ZVEC_GREP_AGENTS_END}`;
+}
+//# sourceMappingURL=install.js.map