zinkee 0.1.11 → 0.1.12

package/dist/index.js

@@ -732,6 +732,197 @@ var commandRegistry = {
   }
 };
 
+// src/utils/argv-rewrite.ts
+var HOISTABLE_GLOBAL_FLAGS = {
+  "--profile": "value",
+  "--base-url": "value",
+  "--api-key": "value",
+  "--read-only": "boolean",
+  "--json": "boolean"
+};
+function isHoistableFlag(flagName) {
+  return Object.hasOwn(HOISTABLE_GLOBAL_FLAGS, flagName);
+}
+function getCommandPath(command) {
+  const parts = [];
+  let cursor = command;
+  while (cursor && cursor.parent) {
+    parts.unshift(cursor.name());
+    cursor = cursor.parent;
+  }
+  return parts.join(" ");
+}
+function buildOptionMetadata(program) {
+  const valueFlags = /* @__PURE__ */ new Set();
+  const booleanFlags = /* @__PURE__ */ new Set();
+  const localOptionsByCommand = /* @__PURE__ */ new Map();
+  function visit(command, isRoot) {
+    const localFlags = /* @__PURE__ */ new Set();
+    for (const option of command.options) {
+      if (!option.long) continue;
+      if (option.required || option.optional) {
+        valueFlags.add(option.long);
+      } else {
+        booleanFlags.add(option.long);
+      }
+      if (!isRoot) {
+        localFlags.add(option.long);
+      }
+    }
+    if (!isRoot) {
+      localOptionsByCommand.set(getCommandPath(command), localFlags);
+    }
+    for (const sub of command.commands) {
+      visit(sub, false);
+    }
+  }
+  visit(program, true);
+  return { valueFlags, booleanFlags, localOptionsByCommand };
+}
+function createDefaultOptionMetadata() {
+  return {
+    valueFlags: /* @__PURE__ */ new Set([
+      "--profile",
+      "--base-url",
+      "--api-key",
+      "--install-completion",
+      "--show-completion"
+    ]),
+    booleanFlags: /* @__PURE__ */ new Set([
+      "--read-only",
+      "--json",
+      "--example",
+      "--help"
+    ]),
+    localOptionsByCommand: /* @__PURE__ */ new Map()
+  };
+}
+function isFlagToken(token) {
+  return token.length > 1 && token.startsWith("-");
+}
+function splitFlagToken(token) {
+  if (token.startsWith("--") && token.includes("=")) {
+    const eqIdx = token.indexOf("=");
+    return {
+      flagName: token.slice(0, eqIdx),
+      inlineValue: token.slice(eqIdx + 1)
+    };
+  }
+  return { flagName: token, inlineValue: void 0 };
+}
+function flagConsumesValue(flagName, optionMeta) {
+  if (optionMeta.valueFlags.has(flagName)) {
+    return true;
+  }
+  if (optionMeta.booleanFlags.has(flagName)) {
+    return false;
+  }
+  return true;
+}
+function collectOperandTokens(userArgs, optionMeta, options = {}) {
+  const operands = [];
+  let i = 0;
+  while (i < userArgs.length) {
+    const token = userArgs[i];
+    if (token === "--") {
+      break;
+    }
+    if (isFlagToken(token)) {
+      const { flagName, inlineValue } = splitFlagToken(token);
+      if (options.skipFlag !== void 0 && flagName === options.skipFlag) {
+        i += 1;
+        continue;
+      }
+      if (inlineValue !== void 0) {
+        i += 1;
+        continue;
+      }
+      const consumes = flagConsumesValue(flagName, optionMeta);
+      const next = userArgs[i + 1];
+      if (consumes && next !== void 0 && !isFlagToken(next)) {
+        i += 2;
+      } else {
+        i += 1;
+      }
+      continue;
+    }
+    operands.push({ index: i, token });
+    i += 1;
+  }
+  return operands;
+}
+function findCommandPath(operands, registry) {
+  if (operands.length === 0) return null;
+  const commandsByLength = Object.keys(registry).sort(
+    (left, right) => right.split(" ").length - left.split(" ").length
+  );
+  for (let start = 0; start < operands.length; start += 1) {
+    for (const commandName of commandsByLength) {
+      const parts = commandName.split(" ");
+      if (start + parts.length > operands.length) continue;
+      let matches = true;
+      for (let j = 0; j < parts.length; j += 1) {
+        if (operands[start + j].token !== parts[j]) {
+          matches = false;
+          break;
+        }
+      }
+      if (matches) {
+        return {
+          commandName,
+          firstArgvIndex: operands[start].index,
+          lastArgvIndex: operands[start + parts.length - 1].index
+        };
+      }
+    }
+  }
+  return null;
+}
+function hoistGlobalOptions(argv, optionMeta, registry) {
+  if (argv.length < 3) return [...argv];
+  const userArgs = argv.slice(2);
+  const operands = collectOperandTokens(userArgs, optionMeta);
+  const cmdPath = findCommandPath(operands, registry);
+  if (!cmdPath) return [...argv];
+  const localOptions = optionMeta.localOptionsByCommand.get(cmdPath.commandName) ?? /* @__PURE__ */ new Set();
+  const hoisted = [];
+  const remaining = [];
+  let i = 0;
+  while (i < userArgs.length) {
+    const token = userArgs[i];
+    if (token === "--") {
+      remaining.push(...userArgs.slice(i));
+      break;
+    }
+    if (!isFlagToken(token)) {
+      remaining.push(token);
+      i += 1;
+      continue;
+    }
+    const { flagName, inlineValue } = splitFlagToken(token);
+    if (!isHoistableFlag(flagName)) {
+      remaining.push(token);
+      i += 1;
+      continue;
+    }
+    const isAfterCommandPath = i > cmdPath.lastArgvIndex;
+    const collidesWithLocal = localOptions.has(flagName);
+    const target = isAfterCommandPath && collidesWithLocal ? remaining : hoisted;
+    target.push(token);
+    const spec = HOISTABLE_GLOBAL_FLAGS[flagName];
+    if (spec === "value" && inlineValue === void 0) {
+      const next = userArgs[i + 1];
+      if (next !== void 0 && !isFlagToken(next)) {
+        target.push(next);
+        i += 2;
+        continue;
+      }
+    }
+    i += 1;
+  }
+  return [argv[0], argv[1], ...hoisted, ...remaining];
+}
+
 // src/client.ts
 var ApiClientError = class extends Error {
   name = "ApiClientError";
@@ -6392,26 +6583,6 @@ async function getResolvedCommandExamples(commandName, filters = {}, options = {
 function getStdout(stdout) {
   return stdout ?? process.stdout;
 }
-function resolveExampleCommand(tokens) {
-  const commands = Object.keys(commandRegistry).sort(
-    (left, right) => right.split(" ").length - left.split(" ").length
-  );
-  for (const commandName of commands) {
-    const commandTokens2 = commandName.split(" ");
-    const matches = commandTokens2.every((token, index) => tokens[index] === token);
-    if (matches) {
-      return {
-        commandName,
-        remainingTokens: tokens.slice(commandTokens2.length)
-      };
-    }
-  }
-  const commandTokens = tokens.filter((token) => !token.startsWith("-"));
-  return {
-    commandName: commandTokens.join(" "),
-    remainingTokens: []
-  };
-}
 function extractExampleFilters(tokens) {
   const filters = {};
   for (let index = 0; index < tokens.length; index += 1) {
@@ -6451,18 +6622,19 @@ function extractExampleOverrides(tokens) {
   }
   return overrides;
 }
-function extractExampleRequest(argv) {
-  const exampleIndex = argv.indexOf("--example");
-  if (exampleIndex === -1) {
+function extractExampleRequest(argv, optionMeta = createDefaultOptionMetadata()) {
+  if (!argv.includes("--example")) {
     return null;
   }
-  const requestTokens = argv.slice(exampleIndex + 1);
-  const { commandName, remainingTokens } = resolveExampleCommand(requestTokens);
-  if (commandName.length === 0) {
+  const userArgs = argv.slice(2);
+  const operands = collectOperandTokens(userArgs, optionMeta, { skipFlag: "--example" });
+  const cmdPath = findCommandPath(operands, commandRegistry);
+  if (!cmdPath) {
     throw new CliError("invalid_cli_usage", 'Provide a command after "--example".');
   }
+  const remainingTokens = userArgs.slice(cmdPath.lastArgvIndex + 1);
   return {
-    commandName,
+    commandName: cmdPath.commandName,
     filters: extractExampleFilters(remainingTokens),
     overrides: extractExampleOverrides(argv),
     json: argv.includes("--json")
@@ -11541,7 +11713,9 @@ async function runCli(argv) {
       process.exitCode = exitCode;
       return;
     }
-    const exampleRequest = extractExampleRequest(argv);
+    const program = buildProgram();
+    const optionMeta = buildOptionMetadata(program);
+    const exampleRequest = extractExampleRequest(argv, optionMeta);
     if (exampleRequest) {
       await showExamples(
         exampleRequest.commandName,
@@ -11555,7 +11729,8 @@ async function runCli(argv) {
       );
       throw new ExampleDisplayed();
     }
-    await buildProgram().parseAsync(argv);
+    const rewrittenArgv = hoistGlobalOptions(argv, optionMeta, commandRegistry);
+    await program.parseAsync(rewrittenArgv);
   } catch (error) {
     if (error instanceof ExampleDisplayed) {
       process.exitCode = 0;