@zvec/zvec-grep 0.1.5 → 0.1.7

package/dist/cli/args.js

@@ -1,4 +1,5 @@
 import { VALID_SYMBOL_TYPES } from "./types.js";
+import { parseMcpToolset } from "../mcp/toolset.js";
 const RG_OPTIONS_WITH_VALUE = new Set([
     "--dfa-size-limit",
     "--encoding",
@@ -89,7 +90,32 @@ export function parseArgs(args) {
     }
     const options = {};
     const positionals = [];
-    const startIndex = 1;
+    let startIndex = 1;
+    if (commandInput.command === "config") {
+        if (args[1] === "model" && args[2] === "set") {
+            options.configAction = "model-set";
+            startIndex = 3;
+        }
+        else if (args[1] === "provider" && args[2] === "set") {
+            options.configAction = "provider-set";
+            startIndex = 3;
+        }
+    }
+    else if (commandInput.command === "auth") {
+        if (args[1] === "grant" || args[1] === "status" || args[1] === "revoke") {
+            options.authAction = args[1];
+            startIndex = 2;
+        }
+    }
+    else if (commandInput.command === "server") {
+        if (args[1] === "on" ||
+            args[1] === "off" ||
+            args[1] === "status" ||
+            args[1] === "run") {
+            options.serverAction = args[1];
+            startIndex = 2;
+        }
+    }
     for (let index = startIndex; index < args.length; index++) {
         const arg = args[index];
         if (arg === "--") {
@@ -111,8 +137,35 @@ export function parseArgs(args) {
         else if (arg === "--version") {
             throw new Error(`${arg} must be used without a command`);
         }
-        else if (arg === "--mcp") {
-            options.mcp = true;
+        else if (isLongOptionWithValue(arg, "--mode")) {
+            options.mode = parseClientMode(valueFromLongOption(arg));
+        }
+        else if (arg === "--mode") {
+            options.mode = parseClientMode(readOptionValue(args, ++index, arg));
+        }
+        else if (arg === "--force-direct") {
+            options.forceDirect = true;
+        }
+        else if (arg === "--stdio") {
+            options.serverStdio = true;
+        }
+        else if (isLongOptionWithValue(arg, "--mcp-toolset")) {
+            options.mcpToolset = parseMcpToolset(valueFromLongOption(arg));
+        }
+        else if (arg === "--mcp-toolset") {
+            options.mcpToolset = parseMcpToolset(readOptionValue(args, ++index, arg));
+        }
+        else if (isLongOptionWithValue(arg, "--listen")) {
+            options.listen = valueFromLongOption(arg);
+        }
+        else if (arg === "--listen") {
+            options.listen = readOptionValue(args, ++index, arg);
+        }
+        else if (isLongOptionWithValue(arg, "--token-file")) {
+            options.serverTokenFile = valueFromLongOption(arg);
+        }
+        else if (arg === "--token-file") {
+            options.serverTokenFile = readOptionValue(args, ++index, arg);
         }
         else if (isLongOptionWithValue(arg, "--target")) {
             options.installTargets = appendInstallTargets(options.installTargets, valueFromLongOption(arg));
@@ -126,9 +179,43 @@ export function parseArgs(args) {
         else if (arg === "--mcp-tool-timeout") {
             options.installMcpToolTimeoutSeconds = parsePositiveInteger(readOptionValue(args, ++index, arg), arg);
         }
+        else if (isLongOptionWithValue(arg, "--mcp-token-env")) {
+            options.installMcpTokenEnv = parseEnvironmentVariable(valueFromLongOption(arg), "--mcp-token-env");
+        }
+        else if (arg === "--mcp-token-env") {
+            options.installMcpTokenEnv = parseEnvironmentVariable(readOptionValue(args, ++index, arg), arg);
+        }
+        else if (isLongOptionWithValue(arg, "--mcp-transport")) {
+            options.installMcpTransport = parseMcpInstallTransport(valueFromLongOption(arg));
+        }
+        else if (arg === "--mcp-transport") {
+            options.installMcpTransport = parseMcpInstallTransport(readOptionValue(args, ++index, arg));
+        }
         else if (arg === "--yes") {
             options.yes = true;
         }
+        else if (isLongOptionWithValue(arg, "--allow-remote")) {
+            throw allowRemoteValueError();
+        }
+        else if (arg === "--allow-remote") {
+            const legacyScope = args[index + 1];
+            if (legacyScope === "once" || legacyScope === "workspace") {
+                throw allowRemoteValueError();
+            }
+            options.allowRemote = true;
+        }
+        else if (isLongOptionWithValue(arg, "--capability")) {
+            options.authorizationCapability = parseAuthorizationCapability(valueFromLongOption(arg));
+        }
+        else if (arg === "--capability") {
+            options.authorizationCapability = parseAuthorizationCapability(readOptionValue(args, ++index, arg));
+        }
+        else if (isLongOptionWithValue(arg, "--scope")) {
+            options.authorizationScope = parseAuthorizationScope(valueFromLongOption(arg));
+        }
+        else if (arg === "--scope") {
+            options.authorizationScope = parseAuthorizationScope(readOptionValue(args, ++index, arg));
+        }
         else if (arg === "--rg") {
             options.rg = true;
         }
@@ -141,6 +228,9 @@ export function parseArgs(args) {
         else if (arg === "--human") {
             options.human = true;
         }
+        else if (arg === "--check-ready") {
+            options.checkReady = true;
+        }
         else if (isLongOptionWithValue(arg, "--preview")) {
             options.preview = parsePreviewMode(valueFromLongOption(arg));
         }
@@ -165,15 +255,18 @@ export function parseArgs(args) {
         else if (arg === "--reset-paths") {
             options.resetPaths = true;
         }
-        else if (arg === "--no-auto-update") {
-            options.noAutoUpdate = true;
+        else if (arg === "--default") {
+            options.defaultModel = true;
+        }
+        else if (isLongOptionWithValue(arg, "--refresh")) {
+            options.refresh = parseQueryRefreshMode(valueFromLongOption(arg));
+        }
+        else if (arg === "--refresh") {
+            options.refresh = parseQueryRefreshMode(readOptionValue(args, ++index, arg));
         }
         else if (arg === "--prefer-symbol") {
             options.preferSymbol = true;
         }
-        else if (arg === "--collection") {
-            options.collection = readOptionValue(args, ++index, arg);
-        }
         else if (arg === "--home") {
             options.home = readOptionValue(args, ++index, arg);
         }
@@ -183,17 +276,8 @@ export function parseArgs(args) {
         else if (arg === "--model-cache") {
             options.modelCacheDir = readOptionValue(args, ++index, arg);
         }
-        else if (arg === "--gpu") {
-            options.llamaGpu = "auto";
-        }
-        else if (arg === "--no-gpu") {
-            options.llamaGpu = false;
-        }
-        else if (arg === "--llama-gpu") {
-            options.llamaGpu = parseLlamaGpu(readOptionValue(args, ++index, arg));
-        }
-        else if (arg === "--embedding-parallelism") {
-            options.embeddingParallelism = parsePositiveInteger(readOptionValue(args, ++index, arg), arg);
+        else if (arg === "--device") {
+            options.device = parseDevice(readOptionValue(args, ++index, arg));
         }
         else if (arg === "--api-key") {
             options.apiKey = readOptionValue(args, ++index, arg);
@@ -393,7 +477,7 @@ function parseCommand(args) {
             throw new Error(`${first} does not accept arguments`);
         }
         if (first === "help" && rest.length > 1) {
-            throw new Error("zg help accepts at most one command name");
+            throw new Error("zg help accepts at most one command or topic");
         }
         return {
             command: "help",
@@ -412,46 +496,66 @@ function parseCommand(args) {
     if (first === "query" ||
         first === "index" ||
         first === "status" ||
-        first === "collections" ||
         first === "install" ||
         first === "uninstall" ||
-        first === "serve") {
+        first === "config" ||
+        first === "auth" ||
+        first === "server") {
         return { command: first };
     }
+    if (first === "serve") {
+        throw new Error("zg serve has been removed; use zg server on and Streamable HTTP MCP");
+    }
     throw new Error(`Unknown command: ${first}`);
 }
 function validateCliShape(command, options, positionals) {
+    if (command === "auth") {
+        if (!options.authAction) {
+            throw new Error("zg auth requires grant, status, or revoke");
+        }
+        if (positionals.length > 1) {
+            throw new Error(`zg auth ${options.authAction} accepts at most one root`);
+        }
+        if (options.authAction !== "grant" &&
+            (options.authorizationCapability || options.authorizationScope)) {
+            throw new Error(`--capability and --scope can only be used with zg auth grant`);
+        }
+    }
+    else if (options.authorizationCapability || options.authorizationScope) {
+        throw new Error("--capability and --scope can only be used with zg auth");
+    }
+    if (options.allowRemote && command !== "query" && command !== "index") {
+        throw new Error("--allow-remote can only be used with query or index commands");
+    }
     const queryOnly = firstEnabledOption([
         [options.rg, "--rg"],
         [options.hybridQueries?.length, "--hybrid"],
         [options.routes?.length, "--fts/--vector"],
         [options.fuse, "--fuse"],
-        [options.debug, "--debug"],
         [options.trace, "--trace"],
         [options.human, "--human"],
         [options.preview, "--preview"],
         [options.limit, "--limit"],
-        [options.noAutoUpdate, "--no-auto-update"],
+        [options.refresh, "--refresh"],
         [options.preferSymbol, "--prefer-symbol"],
         [options.symbolTypes?.length, "--symbol-type"],
         [options.modifiedAfter, "--modified-after"],
         [options.modifiedBefore, "--modified-before"],
-        [options.collection, "--collection"],
         [options.rgCompatibilityOptions?.length, "ripgrep options"],
     ]);
     if (command !== "query" && queryOnly) {
         throw new Error(`${queryOnly} can only be used with zg query`);
     }
+    if (options.debug && command !== "query" && command !== "index") {
+        throw new Error("--debug can only be used with zg query or zg index");
+    }
     const sharedSelection = firstEnabledOption([
         [options.globs?.length, "--glob"],
         [options.insensitiveGlobs?.length, "--iglob"],
         [options.fileTypes?.length, "--type"],
         [options.excludedFileTypes?.length, "--type-not"],
     ]);
-    if (sharedSelection &&
-        command !== "query" &&
-        command !== "index" &&
-        command !== "collections") {
+    if (sharedSelection && command !== "query" && command !== "index") {
         throw new Error(`${sharedSelection} can only be used with query or index commands`);
     }
     const discoveryOption = firstEnabledOption([
@@ -464,10 +568,80 @@ function validateCliShape(command, options, positionals) {
     ]);
     if (discoveryOption &&
         command !== "index" &&
-        command !== "collections" &&
         !(command === "query" && options.rg)) {
         throw new Error(`${discoveryOption} can only be used with index commands or zg query --rg`);
     }
+    if (command === "config") {
+        if (!options.configAction) {
+            throw new Error("zg config requires provider set or model set");
+        }
+        const unsupported = firstEnabledOption([
+            [options.installTargets?.length, "--target"],
+            [options.installMcpToolTimeoutSeconds, "--mcp-tool-timeout"],
+            [options.installMcpTokenEnv, "--mcp-token-env"],
+            [options.yes, "--yes"],
+            [options.rg, "--rg"],
+            [options.home, "--home"],
+            [options.embedding, "--embedding"],
+            [
+                options.configAction === "model-set" ? options.apiKey : undefined,
+                "--api-key",
+            ],
+            [
+                options.configAction === "provider-set" ? options.endpoint : undefined,
+                "--endpoint",
+            ],
+            [
+                options.configAction === "provider-set" ? options.device : undefined,
+                "--device",
+            ],
+            [
+                options.configAction === "provider-set"
+                    ? options.defaultModel
+                    : undefined,
+                "--default",
+            ],
+            [options.mode, "--mode"],
+            [options.listen, "--listen"],
+            [options.serverTokenFile, "--token-file"],
+        ]);
+        if (unsupported) {
+            throw new Error(`zg config ${options.configAction === "model-set" ? "model" : "provider"} set does not accept ${unsupported}`);
+        }
+    }
+    else if (options.defaultModel) {
+        throw new Error("--default can only be used with zg config model set");
+    }
+    if (command === "server") {
+        if (!options.serverAction && !options.serverStdio) {
+            throw new Error("zg server requires on, off, status, run, or --stdio");
+        }
+        if (options.serverAction && options.serverStdio) {
+            throw new Error("--stdio cannot be combined with a server action");
+        }
+        if (options.listen !== undefined &&
+            options.serverAction !== "run" &&
+            options.serverAction !== "on" &&
+            !options.serverStdio) {
+            throw new Error("--listen can only be used with zg server on or run");
+        }
+        if (options.serverTokenFile !== undefined &&
+            options.serverAction === "status") {
+            throw new Error("--token-file cannot be used with zg server status");
+        }
+        if (options.mcpToolset !== undefined &&
+            options.serverAction !== "on" &&
+            options.serverAction !== "run" &&
+            !options.serverStdio) {
+            throw new Error("--mcp-toolset can only be used with zg server on or run");
+        }
+    }
+    else if (options.mcpToolset !== undefined && command !== "install") {
+        throw new Error("--mcp-toolset can only be used with zg server on, run, --stdio, or zg install");
+    }
+    else if (options.serverStdio !== undefined) {
+        throw new Error("--stdio can only be used with zg server");
+    }
     if (options.rg &&
         (hasExplicitRoutes(options) || options.hybridQueries?.length)) {
         throw new Error("--rg cannot be combined with --hybrid, --fts, or --vector");
@@ -475,8 +649,8 @@ function validateCliShape(command, options, positionals) {
     if (options.rg && options.fuse) {
         throw new Error("--rg cannot be combined with --fuse");
     }
-    if (options.rg && options.collection) {
-        throw new Error("--rg cannot be combined with --collection");
+    if (options.forceDirect && options.mode !== "direct") {
+        throw new Error("--force-direct requires --mode direct");
     }
     if (options.rg && options.preview) {
         throw new Error("--preview is not supported with --rg; use -A/-B/-C for rg context");
@@ -488,18 +662,29 @@ function validateCliShape(command, options, positionals) {
         throw new Error("--rg cannot be combined with indexed symbol options");
     }
     if (options.rg &&
-        (options.noAutoUpdate || options.embeddingConcurrency !== undefined)) {
+        (options.refresh || options.embeddingConcurrency !== undefined)) {
         throw new Error("--rg cannot be combined with indexed refresh options");
     }
     if (!options.rg && (options.rgCompatibilityOptions?.length ?? 0) > 0) {
         const [option] = options.rgCompatibilityOptions;
         throw new Error(`${option} can only be used with --rg`);
     }
-    if (options.mcp && command !== "serve") {
-        throw new Error("--mcp can only be used with zg serve");
+    if (options.mode !== undefined &&
+        command !== "query" &&
+        command !== "index" &&
+        command !== "status") {
+        throw new Error("--mode can only be used with query, index, or status");
+    }
+    if (options.checkReady &&
+        command !== "status" &&
+        !(command === "server" && options.serverAction === "status")) {
+        throw new Error("--check-ready can only be used with zg status or zg server status");
     }
-    if (command === "serve" && !options.mcp) {
-        throw new Error("zg serve currently requires --mcp");
+    if (options.listen !== undefined && command !== "server") {
+        throw new Error("--listen can only be used with zg server on or run");
+    }
+    if (options.serverTokenFile !== undefined && command !== "server") {
+        throw new Error("--token-file can only be used with zg server");
     }
     if (options.installTargets?.length &&
         command !== "install" &&
@@ -510,18 +695,27 @@ function validateCliShape(command, options, positionals) {
         command !== "install") {
         throw new Error("--mcp-tool-timeout can only be used with zg install");
     }
+    if (options.installMcpTokenEnv !== undefined && command !== "install") {
+        throw new Error("--mcp-token-env can only be used with zg install");
+    }
+    if (options.installMcpTransport !== undefined && command !== "install") {
+        throw new Error("--mcp-transport can only be used with zg install");
+    }
+    if (command === "install" &&
+        options.installMcpTransport !== "http" &&
+        options.installMcpTokenEnv !== undefined) {
+        throw new Error("--mcp-token-env requires --mcp-transport http");
+    }
     if (options.force && command !== "install") {
         throw new Error("--force can only be used with zg install");
     }
     if (command === "install" || command === "uninstall") {
         const unsupported = firstEnabledOption([
-            [options.mcp, "--mcp"],
             [options.color, "--color"],
             [options.home, "--home"],
             [options.embedding, "--embedding"],
             [options.modelCacheDir, "--model-cache"],
-            [options.llamaGpu, "--llama-gpu"],
-            [options.embeddingParallelism, "--embedding-parallelism"],
+            [options.device, "--device"],
             [options.apiKey, "--api-key"],
             [options.endpoint, "--endpoint"],
             [options.rebuild, "--rebuild"],
@@ -552,11 +746,11 @@ function validateCliShape(command, options, positionals) {
     if (options.drop && command !== "index") {
         throw new Error("--drop can only be used with zg index");
     }
-    if (options.rebuild && command !== "index" && command !== "collections") {
-        throw new Error("--rebuild can only be used with zg index or zg collections index");
+    if (options.rebuild && command !== "index") {
+        throw new Error("--rebuild can only be used with zg index");
     }
-    if (options.resetPaths && command !== "index" && command !== "collections") {
-        throw new Error("--reset-paths can only be used with zg index or zg collections index");
+    if (options.resetPaths && command !== "index") {
+        throw new Error("--reset-paths can only be used with zg index");
     }
     if (options.drop &&
         (options.rebuild ||
@@ -564,8 +758,7 @@ function validateCliShape(command, options, positionals) {
             options.home ||
             options.embedding ||
             options.modelCacheDir ||
-            options.llamaGpu !== undefined ||
-            options.embeddingParallelism ||
+            options.device !== undefined ||
             options.apiKey ||
             options.endpoint ||
             options.globs?.length ||
@@ -577,10 +770,21 @@ function validateCliShape(command, options, positionals) {
             options.ignoreFiles?.length ||
             options.maxDepth !== undefined ||
             options.maxFileSizeBytes !== undefined ||
+            options.debug ||
             options.follow ||
             options.embeddingConcurrency)) {
         throw new Error("zg index --drop cannot be combined with indexing options");
     }
+    if (command === "query") {
+        const unsupported = firstEnabledOption([
+            [options.embedding, "--embedding"],
+            [options.endpoint, "--endpoint"],
+            [options.embeddingConcurrency, "--embedding-concurrency"],
+        ]);
+        if (unsupported) {
+            throw new Error(`${unsupported} is not supported with zg query`);
+        }
+    }
     if (command === "query" && !options.rg) {
         const queryCount = positionals.length +
             (options.hybridQueries?.length ?? 0) +
@@ -593,6 +797,35 @@ function validateCliShape(command, options, positionals) {
 function firstEnabledOption(candidates) {
     return candidates.find(([value]) => Array.isArray(value) ? value.length > 0 : value !== undefined)?.[1];
 }
+function parseClientMode(value) {
+    if (value === "direct" || value === "server" || value === "auto")
+        return value;
+    throw new Error("--mode must be direct, server, or auto");
+}
+function parseQueryRefreshMode(value) {
+    if (value === "background" || value === "wait" || value === "off") {
+        return value;
+    }
+    throw new Error("--refresh must be background, wait, or off");
+}
+function allowRemoteValueError() {
+    return new Error([
+        "--allow-remote does not accept a value.",
+        "It authorizes Remote Embedding for the current command only.",
+        "For persistent authorization, use:",
+        "  zg auth grant --capability embedding --scope workspace",
+    ].join("\n"));
+}
+function parseAuthorizationCapability(value) {
+    if (value === "embedding")
+        return value;
+    throw new Error("--capability currently supports only embedding");
+}
+function parseAuthorizationScope(value) {
+    if (value === "workspace")
+        return value;
+    throw new Error("zg auth supports only workspace scope");
+}
 function readOptionValue(args, index, option) {
     const value = args[index];
     if (value === undefined || value.length === 0) {
@@ -803,6 +1036,17 @@ function parsePositiveInteger(value, option) {
     }
     return parsed;
 }
+function parseEnvironmentVariable(value, option) {
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(value)) {
+        throw new Error(`${option} requires a valid environment variable name`);
+    }
+    return value;
+}
+function parseMcpInstallTransport(value) {
+    if (value === "stdio" || value === "http")
+        return value;
+    throw new Error("--mcp-transport must be stdio or http");
+}
 function parseByteSize(value, option) {
     const match = value.trim().match(/^(\d+)([KMGT])?$/i);
     if (!match) {
@@ -847,18 +1091,16 @@ function parsePreviewMode(value) {
     }
     throw new Error(`Unsupported preview mode: ${value}`);
 }
-export function parseLlamaGpu(value) {
+export function parseDevice(value) {
     const normalized = value.trim().toLowerCase();
     if (normalized === "auto" ||
+        normalized === "cpu" ||
         normalized === "metal" ||
         normalized === "vulkan" ||
         normalized === "cuda") {
         return normalized;
     }
-    if (["false", "off", "none", "disable", "disabled", "0"].includes(normalized)) {
-        return false;
-    }
-    throw new Error(`Unsupported llama GPU mode: ${value}`);
+    throw new Error(`Unsupported device: ${value}`);
 }
 function hasExplicitRoutes(options) {
     return (options.routes?.length ?? 0) > 0;
@@ -884,10 +1126,51 @@ function parseSymbolType(value) {
     throw new Error(`Unsupported symbol type: ${value}`);
 }
 export function splitPathFilters(value) {
-    return value
-        .split(",")
-        .map((item) => item.trim())
-        .filter((item) => item.length > 0);
+    const filters = [];
+    let start = 0;
+    let braceDepth = 0;
+    let bracketDepth = 0;
+    let escaped = false;
+    for (let index = 0; index < value.length; index += 1) {
+        const character = value[index];
+        if (escaped) {
+            escaped = false;
+            continue;
+        }
+        if (character === "\\") {
+            escaped = true;
+            continue;
+        }
+        if (character === "[") {
+            bracketDepth += 1;
+            continue;
+        }
+        if (character === "]" && bracketDepth > 0) {
+            bracketDepth -= 1;
+            continue;
+        }
+        if (bracketDepth === 0 && character === "{") {
+            braceDepth += 1;
+            continue;
+        }
+        if (bracketDepth === 0 && character === "}" && braceDepth > 0) {
+            braceDepth -= 1;
+            continue;
+        }
+        if (character !== "," || braceDepth > 0 || bracketDepth > 0) {
+            continue;
+        }
+        const filter = value.slice(start, index).trim();
+        if (filter.length > 0) {
+            filters.push(filter);
+        }
+        start = index + 1;
+    }
+    const finalFilter = value.slice(start).trim();
+    if (finalFilter.length > 0) {
+        filters.push(finalFilter);
+    }
+    return filters;
 }
 function appendValue(existing, value, option) {
     const normalized = value.trim();