@koda-sl/baker-cli 0.203.0 → 0.204.0

package/README.md

@@ -86,8 +86,20 @@ All commands return a JSON envelope:
 
 // Dry-run
 { "ok": true, "dryRun": true, "operation": "images.delete", "params": { "id": "abc123" } }
+
+// Unknown option — the command stops instead of running without it
+{ "ok": false, "error": { "code": "UNKNOWN_ARGUMENT", "message": "--dimension-filter is not an option of `baker ga4 query`.", "fix": { "action": "check_schema", "explanation": "Did you mean --dimensions? Run `baker schema ga4 query` ..." }, "retryable": false } }
 ```
 
+### Unknown options are refused
+
+An option a command does not declare stops the run with `UNKNOWN_ARGUMENT`, naming the
+closest real one. Previously such an option was accepted and ignored, so a call that
+looked like it had filtered or narrowed a result was in fact answering the unfiltered
+question — and nothing in the output said so. Both spellings of an option work
+(`--run-id` and `--runId`), as they always did. Run `baker schema <command>` to see
+every option a command takes.
+
 Use `--output` to change format:
 
 | Format  | Description                        | Best for           | Available on |

package/dist/cli.js

@@ -44042,6 +44042,172 @@ Full guide: __tooling__/docs/tools/baker/winning-ads.md`
   }
 });
 
+// src/unknown-flags.ts
+var ALWAYS_ACCEPTED = /* @__PURE__ */ new Set(["help", "h", "version"]);
+function subCommandsOf(command) {
+  const sub = command.subCommands;
+  return sub && typeof sub === "object" ? sub : null;
+}
+function argsOf(command) {
+  const args = command.args;
+  return args && typeof args === "object" ? args : null;
+}
+function resolveCommand2(root, argv) {
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    if (!subCommands) {
+      break;
+    }
+    const next = subCommands[token];
+    if (next === void 0) {
+      break;
+    }
+    if (typeof next !== "object") {
+      return { command, resolved: false };
+    }
+    command = next;
+  }
+  return { command, resolved: true };
+}
+function typeOf(def) {
+  return def && typeof def === "object" ? def.type : void 0;
+}
+function acceptedNames(command) {
+  const args = argsOf(command);
+  if (!args) {
+    return null;
+  }
+  const names = new Set(ALWAYS_ACCEPTED);
+  for (const [name, def] of Object.entries(args)) {
+    if (typeOf(def) === "positional") {
+      continue;
+    }
+    for (const spelling of [name, kebab(name), camel(name)]) {
+      names.add(spelling);
+      if (typeOf(def) === "boolean") {
+        names.add(`no-${spelling}`);
+      }
+    }
+  }
+  return names;
+}
+function kebab(name) {
+  return name.replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function camel(name) {
+  return name.replace(/-([a-z0-9])/g, (_, c) => c.toUpperCase());
+}
+function findUnknownFlags(root, argv) {
+  const { command, resolved } = resolveCommand2(root, argv);
+  if (!resolved) {
+    return [];
+  }
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return [];
+  }
+  const unknown = [];
+  for (const token of argv) {
+    if (token === "--") {
+      break;
+    }
+    if (!token.startsWith("--")) {
+      continue;
+    }
+    const name = token.slice(2).split("=")[0] ?? "";
+    if (name.length > 0 && !accepted.has(name) && !unknown.includes(token)) {
+      unknown.push(token);
+    }
+  }
+  return unknown;
+}
+function closestFlag(unknown, command) {
+  const accepted = acceptedNames(command);
+  if (!accepted) {
+    return null;
+  }
+  const name = unknown.replace(/^--/, "").split("=")[0] ?? "";
+  const scored = [...accepted].filter((candidate) => !ALWAYS_ACCEPTED.has(candidate)).map((candidate) => ({
+    candidate,
+    prefix: sharedPrefix(name, candidate),
+    distance: editDistance(name, candidate)
+  })).filter(({ prefix, distance }) => prefix >= 4 || distance <= 3).sort((a, b) => b.prefix - a.prefix || a.distance - b.distance);
+  return scored[0] ? `--${scored[0].candidate}` : null;
+}
+function sharedPrefix(a, b) {
+  let i = 0;
+  while (i < a.length && i < b.length && a[i] === b[i]) {
+    i++;
+  }
+  return i;
+}
+function editDistance(a, b) {
+  let previous = Array.from({ length: b.length + 1 }, (_, j) => j);
+  for (let i = 1; i <= a.length; i++) {
+    const current = [i];
+    for (let j = 1; j <= b.length; j++) {
+      const substitution = (previous[j - 1] ?? 0) + (a[i - 1] === b[j - 1] ? 0 : 1);
+      current.push(Math.min((previous[j] ?? 0) + 1, (current[j - 1] ?? 0) + 1, substitution));
+    }
+    previous = current;
+  }
+  return previous[b.length] ?? 0;
+}
+function commandFor(root, argv) {
+  const { command, resolved } = resolveCommand2(root, argv);
+  return resolved ? command : null;
+}
+function unknownFlagEnvelope(unknown, commandPath, suggestion) {
+  const list = unknown.join(", ");
+  return {
+    ok: false,
+    error: {
+      code: "UNKNOWN_ARGUMENT",
+      message: `${list} ${unknown.length > 1 ? "are not options" : "is not an option"} of \`baker ${commandPath}\`.`,
+      fix: {
+        action: "check_schema",
+        explanation: (suggestion ? `Did you mean ${suggestion}? ` : "") + `Run \`baker schema ${commandPath}\` to see every option this command takes. Do not re-run the same call: until this version an unrecognised option was accepted and ignored, so a command that looked like it had filtered or narrowed the result was in fact answering the unfiltered question.`
+      },
+      retryable: false
+    }
+  };
+}
+function commandPathOf(root, argv) {
+  const path37 = [];
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) {
+      break;
+    }
+    const subCommands = subCommandsOf(command);
+    const next = subCommands?.[token];
+    if (next === void 0 || typeof next !== "object") {
+      break;
+    }
+    path37.push(token);
+    command = next;
+  }
+  return path37.join(" ");
+}
+function refuseUnknownFlags(root, argv) {
+  const unknown = findUnknownFlags(root, argv);
+  if (unknown.length === 0) {
+    return;
+  }
+  const command = commandFor(root, argv);
+  const first = unknown[0];
+  const suggestion = command && first ? closestFlag(first, command) : null;
+  process.stdout.write(
+    `${JSON.stringify(unknownFlagEnvelope(unknown, commandPathOf(root, argv), suggestion), null, 2)}
+`
+  );
+  process.exit(1);
+}
+
 // src/version.ts
 import { readFileSync as readFileSync14 } from "fs";
 function packageJsonUrl() {
@@ -44101,5 +44267,6 @@ Introspection: Run 'baker schema <command>' to inspect argument schemas.`
 });
 installStreamTaps();
 logInvocation(process.argv.slice(2));
+refuseUnknownFlags(main, process.argv.slice(2));
 runMain(main);
 //# sourceMappingURL=cli.js.map