@koda-sl/baker-cli 0.525.0 → 0.527.0

package/dist/chunk-WSYQ6LWB.js

@@ -0,0 +1,710 @@
+import {
+  optionalWorkspaceKind
+} from "./chunk-52IYZCRS.js";
+
+// src/command-loading.ts
+function familiesToLoad(argv, families) {
+  const first = argv.find((token) => !token.startsWith("-"));
+  if (first !== void 0 && first !== "schema" && families.includes(first)) return [first];
+  return "all";
+}
+async function resolved(value) {
+  return typeof value === "function" ? await value() : await value;
+}
+async function subCommandsOf(command) {
+  if (command.subCommands === void 0) return void 0;
+  const subCommands = await resolved(command.subCommands);
+  command.subCommands = subCommands;
+  return subCommands;
+}
+async function loadSubCommandNamed(command, token) {
+  const subCommands = await subCommandsOf(command);
+  if (!subCommands) return null;
+  const named = subCommands[token];
+  if (named !== void 0) {
+    const loaded = await resolved(named);
+    subCommands[token] = loaded;
+    return [token, loaded];
+  }
+  for (const [name, sub] of Object.entries(subCommands)) {
+    const loaded = await resolved(sub);
+    subCommands[name] = loaded;
+    const meta = await resolved(loaded.meta ?? {});
+    const aliases2 = Array.isArray(meta.alias) ? meta.alias : meta.alias === void 0 ? [] : [meta.alias];
+    if (aliases2.includes(token)) return [name, loaded];
+  }
+  return null;
+}
+async function loadAllCommands(command) {
+  const subCommands = await subCommandsOf(command);
+  if (!subCommands) return;
+  for (const [name, sub] of Object.entries(subCommands)) {
+    const loaded = await resolved(sub);
+    subCommands[name] = loaded;
+    await loadAllCommands(loaded);
+  }
+}
+async function loadCommands(root, argv) {
+  const families = Object.keys(await subCommandsOf(root) ?? {});
+  if (familiesToLoad(argv, families) === "all") {
+    await loadAllCommands(root);
+    return root;
+  }
+  let command = root;
+  for (const token of argv) {
+    if (token === "--" || token.startsWith("-")) break;
+    const subCommands = await subCommandsOf(command);
+    const sub = subCommands?.[token];
+    if (!subCommands || sub === void 0) break;
+    const loaded = await resolved(sub);
+    subCommands[token] = loaded;
+    command = loaded;
+  }
+  return root;
+}
+
+// src/profile-help.ts
+function loadedSubCommands(node) {
+  const subCommands = node.subCommands;
+  if (typeof subCommands !== "object" || subCommands === null) return [];
+  return Object.entries(subCommands).flatMap(
+    ([name, sub]) => typeof sub === "object" && sub !== null ? [[name, sub]] : []
+  );
+}
+function subCommandNames(node) {
+  const subCommands = node.subCommands;
+  return typeof subCommands === "object" && subCommands !== null ? Object.keys(subCommands) : [];
+}
+function commandOf(root, mention) {
+  const words = mention.trim().split(/\s+/);
+  let node = root;
+  const path = [];
+  for (const word of words) {
+    const loaded = loadedSubCommands(node).find(([name]) => name === word)?.[1];
+    if (!loaded) {
+      return subCommandNames(node).includes(word) ? [words.join(" ")] : path.length > 0 ? [path.join(" ")] : [];
+    }
+    node = loaded;
+    path.push(word);
+  }
+  return [path.join(" ")];
+}
+function indentOf(line) {
+  return line.length - line.trimStart().length;
+}
+function dropping(lines, drops) {
+  const kept = [];
+  let carried = null;
+  for (const line of lines) {
+    if (carried?.(line)) continue;
+    carried = null;
+    const rest = drops(line);
+    if (rest !== null) {
+      kept.push(rest);
+      continue;
+    }
+    const indent = indentOf(line);
+    if (/\\\s*$/.test(line)) {
+      let open = true;
+      carried = (next) => {
+        const continues = open;
+        open = /\\\s*$/.test(next);
+        return continues;
+      };
+    } else if (indent === 0 && !/[.:!?)]\s*$/.test(line)) {
+      let open = true;
+      carried = (next) => {
+        const continues = open && next.trim() !== "" && indentOf(next) === 0;
+        open = continues && !/[.:!?)]\s*$/.test(next);
+        return continues;
+      };
+    } else if (indent > 0) {
+      carried = (next) => next.trim() !== "" && indentOf(next) > indent;
+    }
+  }
+  return kept;
+}
+var STANDALONE_LINE = /^(?:\s|baker\b|[A-Z][\w ]{0,30}:\s)/;
+function balanced(text) {
+  return (text.match(/\(/g)?.length ?? 0) === (text.match(/\)/g)?.length ?? 0);
+}
+function commandMentions(root, text) {
+  const families = new Set(subCommandNames(root));
+  const quoted = [...text.matchAll(/`([a-z][\w-]*(?:[ \t][a-z][\w-]*)*)(?=[`\s<])/g)].filter(
+    (match) => families.has((match[1] ?? "").split(/\s+/)[0] ?? "")
+  );
+  return [...text.matchAll(/`?\bbaker ((?:[a-z][\w-]*[ \t]?)+)/g), ...quoted].map((match) => ({
+    at: match.index,
+    words: match[1] ?? ""
+  }));
+}
+function firstUnusable(root, text, offered, refusedFlags) {
+  const commands = commandMentions(root, text).filter(({ words }) => commandOf(root, words).some((path) => !offered(path))).map(({ at: at2 }) => at2);
+  const flags = refusedFlags.flatMap((flag) => {
+    const match = new RegExp(`--${flag}(?![\\w-])`).exec(text);
+    return match ? [match.index] : [];
+  });
+  const at = [...commands, ...flags];
+  return at.length > 0 ? Math.min(...at) : -1;
+}
+function sentenceWithout(sentence, unusableAt) {
+  if (unusableAt === -1) return sentence;
+  const before = sentence.slice(0, unusableAt).replace(/`$/, "");
+  const cut = Math.max(before.lastIndexOf(", "), before.lastIndexOf(" \u2014 "), before.lastIndexOf("; "));
+  const clause = cut === -1 ? "" : before.slice(0, cut).trim();
+  const leadsIn = /^(?:to|use|run|call|for|with)\b/i.test(clause);
+  return clause.split(/\s+/).length >= 3 && balanced(clause) && !leadsIn ? `${clause}.` : "";
+}
+var LEANS_BACK = /^(?:it|they|this|that|these|those)\b/i;
+function withoutUnoffered(root, text, offered, refusedFlags = []) {
+  const unusable = (part) => firstUnusable(root, part, offered, refusedFlags);
+  return dropping(text.split("\n"), (line) => {
+    if (unusable(line) === -1) return line;
+    if (STANDALONE_LINE.test(line)) return null;
+    const kept = [];
+    let dropped = false;
+    for (const sentence of line.split(/(?<=[.!?])\s+/)) {
+      const rest = dropped && LEANS_BACK.test(sentence) ? "" : sentenceWithout(sentence, unusable(sentence));
+      dropped = rest === "";
+      if (rest !== "") kept.push(rest);
+    }
+    return kept.length === 0 ? null : kept.join(" ");
+  }).join("\n");
+}
+function holdsUnoffered(node, path, offered) {
+  return loadedSubCommands(node).some(
+    ([name, sub]) => !offered([...path, name].join(" ")) || holdsUnoffered(sub, [...path, name], offered)
+  );
+}
+var WRITE_TALK = /^(?:stage\b|staged\b|staging\b|write subcommands\b|writes\b|then stage\b|drafts:|staged vs published\b|lifecycle:|nothing staged\b|on publish\b|\w+(?: \/ \w+)*\s+—\s+stage\b)/i;
+var WRITE_CLAUSE = /(?:\s*(?:[,;]|\s—|\s-)\s*(?:(?:or|plus|and)\s+)?|\s+(?:or|plus|and)\s+)(?:stage[sd]?|staged)\b[^.]*/gi;
+var VERB_LIST = /^((?:[A-Za-z]+, )*[A-Za-z]+,? (?:or|and) [a-z]+)\b/;
+function withOfferedVerbs(sentence, children, unoffered) {
+  const list = VERB_LIST.exec(sentence)?.[1];
+  if (!list) return sentence;
+  const verbs = list.split(/,\s*(?:(?:or|and)\s+)?|\s+(?:or|and)\s+/).map((verb) => verb.toLowerCase());
+  if (!verbs.every((verb) => children.has(verb))) return sentence;
+  const kept = verbs.filter((verb) => !unoffered.has(verb));
+  if (kept.length === 0) return "";
+  const named = kept.length === 1 ? kept[0] ?? "" : `${kept.slice(0, -1).join(", ")} or ${kept.at(-1)}`;
+  return `${named.charAt(0).toUpperCase()}${named.slice(1)}${sentence.slice(list.length)}`;
+}
+function opensOnUnoffered(text, unoffered) {
+  const first = text.trim().split(/[\s/]+/)[0]?.toLowerCase() ?? "";
+  return unoffered.has(first);
+}
+function isWriteLine(line, unoffered) {
+  if (WRITE_TALK.test(line.trim())) return true;
+  if (indentOf(line) > 0) return opensOnUnoffered(line, unoffered);
+  return /:\s*$/.test(line) && /\bwrites?\b/i.test(line);
+}
+function withoutWriteTalk(paragraph, children, unoffered) {
+  const prose = (text) => text.replace(WRITE_CLAUSE, "").split(/(?<=[.!?])\s+/).map((sentence) => withOfferedVerbs(sentence, children, unoffered)).filter(
+    (sentence) => sentence !== "" && !WRITE_TALK.test(sentence.trim()) && !opensOnUnoffered(sentence, unoffered)
+  ).join(" ");
+  const lines = paragraph.split("\n");
+  if (lines.some((line) => /^\s/.test(line) || STANDALONE_LINE.test(line) || /:\s*$/.test(line))) {
+    return dropping(lines, (line) => {
+      if (isWriteLine(line, unoffered)) return null;
+      if (indentOf(line) > 0 || STANDALONE_LINE.test(line) || !/[.!?]\s*$/.test(line)) return line;
+      const kept = prose(line);
+      return kept === "" ? null : kept;
+    }).join("\n");
+  }
+  return prose(lines.join(" "));
+}
+function withOfferedSubcommands(text, path, offered) {
+  return text.replace(/Subcommands: ([^.]*)\./g, (_whole, list) => {
+    const kept = list.split(/,\s*/).filter((item) => offered([...path, item.split(/\s/)[0] ?? ""].join(" ")));
+    return kept.length > 0 ? `Subcommands: ${kept.join(", ")}.` : "";
+  });
+}
+function tidy(text) {
+  const lines = text.split("\n");
+  const kept = lines.filter((line, index) => {
+    if (!/:\s*$/.test(line)) return true;
+    const next = lines.slice(index + 1).find((later) => later.trim() !== "");
+    return next !== void 0 && /^\s/.test(next) && lines[index + 1]?.trim() !== "";
+  });
+  return kept.join("\n").replace(/\n{3,}/g, "\n\n").replace(/^(?:[ \t]*\n)+/, "").trimEnd();
+}
+function describedFor(root, description, path, node, profile, offered, refusedFlags = []) {
+  const cited = withoutUnoffered(root, description, offered, refusedFlags);
+  if (profile === "company" || !holdsUnoffered(node, path, offered)) return tidy(cited);
+  const children = new Set(subCommandNames(node));
+  const unoffered = new Set([...children].filter((name) => !offered([...path, name].join(" "))));
+  const shaped = cited.split(/\n\s*\n/).map((paragraph) => withoutWriteTalk(withOfferedSubcommands(paragraph, path, offered), children, unoffered)).join("\n\n");
+  const text = tidy(shaped);
+  if (text !== "") return text;
+  const reads = loadedSubCommands(node).flatMap(([name]) => offered([...path, name].join(" ")) ? [name] : []);
+  return reads.length > 0 ? `Read: ${reads.join(", ")}.` : "";
+}
+
+// src/agent-profile.ts
+function agentProfile(workspaceKind = optionalWorkspaceKind()) {
+  return workspaceKind === "organization" ? "organization" : "company";
+}
+var ORGANIZATION_ONLY = ["organization"];
+var ORGANIZATION_COMMANDS = [
+  "schema",
+  "capabilities",
+  "organization",
+  // What a company did and has.
+  "chats",
+  "history",
+  "actions list",
+  "actions log",
+  "actions get",
+  "actions status",
+  "actions draft list",
+  "actions tags list",
+  // The organization's own Scheduled agents, which live in this workspace:
+  // staged like a company's, applied at Publish. Naming a company is still a
+  // read only (`readNamedCompany`), so none of these reaches one.
+  "scheduled-agents",
+  "experiment status",
+  "experiment history",
+  "flows list",
+  "flows show",
+  "flows schema",
+  "testimonials get",
+  "testimonials search",
+  "testimonials list",
+  "testimonials tags list",
+  "testimonials sources list",
+  "images get",
+  "images search",
+  "images library",
+  "images tags list",
+  // A page's or a link's pictures and videos, to the workspace's own disk: a
+  // client's logo, the photos on its site, the video it sent. Firecrawl reads
+  // the page; nothing reaches any library (`--auto-ingest` is refused below).
+  "images download",
+  "images extract",
+  "videos get",
+  "videos search",
+  "videos tags list",
+  "videos fetch",
+  "studio get",
+  "studio list",
+  "avatars list",
+  "avatars get",
+  "creatives performance",
+  "creatives feedback read",
+  "landing export status",
+  "landing export list",
+  "site show",
+  "site domain list",
+  "credentials list",
+  "setup-links list",
+  "media-sources list",
+  "posts list",
+  "posts get",
+  "posts search",
+  "mcp connected",
+  "mcp catalog",
+  "mcp tools",
+  "mcp execute",
+  "mcp list",
+  // Ads, every platform: accounts, structure, results, staged drafts.
+  "ads google accounts",
+  "ads google currency",
+  "ads google url-options",
+  "ads google changes",
+  "ads google invoices",
+  "ads google identity-verification",
+  "ads google previews",
+  "ads google brands",
+  "ads google query",
+  "ads google keywords discover",
+  "ads google keywords metrics",
+  "ads google keywords forecast",
+  "ads google keywords themes",
+  "ads google keywords locations",
+  "ads google keywords languages",
+  "ads google keywords list",
+  "ads google budgets list",
+  "ads google campaigns list",
+  "ads google ad-groups list",
+  "ads google negative-keywords list",
+  "ads google keyword-lists list",
+  "ads google ads list",
+  "ads google assets list",
+  "ads google asset-groups list",
+  "ads google audiences list",
+  "ads google audiences targeting",
+  "ads google conversions list",
+  "ads google bidding-strategies list",
+  "ads google labels list",
+  "ads google campaign-criteria list",
+  "ads google ad-group-criteria list",
+  "ads google ad-group-bid-modifiers list",
+  "ads google account-exclusions list",
+  "ads google asset-group-signals list",
+  "ads google merchant-center list",
+  "ads google draft list",
+  "ads google draft show",
+  "ads meta accounts",
+  "ads meta account",
+  "ads meta businesses",
+  "ads meta pages",
+  "ads meta lead-forms list",
+  "ads meta leads",
+  "ads meta campaigns list",
+  "ads meta adsets list",
+  "ads meta ads list",
+  "ads meta creatives list",
+  "ads meta audiences list",
+  "ads meta custom-conversions list",
+  "ads meta pixels",
+  "ads meta activities",
+  "ads meta insights",
+  "ads meta draft list",
+  "ads meta draft show",
+  "ads linkedin accounts",
+  "ads linkedin account detail",
+  "ads linkedin campaign-groups list",
+  "ads linkedin campaigns list",
+  "ads linkedin creatives list",
+  "ads linkedin draft list",
+  "ads linkedin draft show",
+  "ads linkedin analytics",
+  "ads linkedin demographics",
+  "ads linkedin companies",
+  "ads linkedin top-companies",
+  "ads linkedin resolve",
+  "ads linkedin facets list",
+  "ads linkedin facets values",
+  "ads linkedin audience-size",
+  "ads linkedin bid-pricing",
+  "ads linkedin forecast",
+  "ads linkedin leads",
+  "ads linkedin conversions list",
+  "ads linkedin conversions health",
+  "ads linkedin conversation",
+  "ads linkedin audit",
+  "ads linkedin url-params",
+  "ads x accounts",
+  "ads x funding",
+  "ads x campaigns list",
+  "ads x line-items list",
+  "ads x promoted-tweets list",
+  "ads x tweets",
+  "ads x cards",
+  "ads x draft list",
+  "ads x draft show",
+  "ads x media",
+  "ads x audiences",
+  "ads x targeting-criteria list",
+  "ads x targeting-constants",
+  "ads x active-entities",
+  "ads x stats job-status",
+  "ads chatgpt account show",
+  "ads chatgpt campaigns list",
+  "ads chatgpt ad-groups list",
+  "ads chatgpt ads list",
+  "ads chatgpt conversions list",
+  "ads chatgpt conversions events",
+  "ads chatgpt conversions report",
+  "ads chatgpt audiences list",
+  "ads chatgpt catalogs list",
+  "ads chatgpt catalogs uploads",
+  "ads chatgpt catalogs products",
+  "ads chatgpt history",
+  "ads chatgpt insights",
+  "ads chatgpt locations",
+  "ads chatgpt draft list",
+  "ads chatgpt draft show",
+  // Baker's synced copy of every platform's results, which the live reads above
+  // point at first. Reads only: each `show` beside its staged changes.
+  "ads performance overview",
+  "ads performance trend",
+  // Who the ads brought: counts per ad and per persona answer, and the ladder
+  // and persona map they are counted by (`adPerformance/peopleRoute.ts`).
+  "ads performance people",
+  "ads performance personas",
+  "ads performance ladder",
+  "ads performance persona-fields",
+  "ads performance accounts",
+  "ads performance setup",
+  "ads performance entities",
+  "ads performance entity",
+  "ads performance changes",
+  "ads performance impact",
+  "ads performance creatives",
+  "ads performance families show",
+  "ads performance families choices",
+  "ads performance creative-health",
+  "ads performance creative-assets",
+  "ads performance health",
+  "ads performance breakdown",
+  "ads performance search-terms",
+  "ads performance pacing",
+  "ads performance funnel",
+  "ads performance tracking",
+  "ads performance landings",
+  "ads performance live-in",
+  "ads performance status",
+  "ads performance goals show",
+  "ads performance progress",
+  "ads performance diagnose",
+  "ads performance pulse",
+  "ads performance anomalies",
+  "ads performance recap",
+  "ads performance targets show",
+  "ads performance budget-recommendations",
+  "ads performance attention show",
+  "ads performance currency show",
+  "ads performance brand-split",
+  "ads performance impression-share",
+  "ads performance keyword-quality",
+  "ads performance google-report",
+  "ads performance budgets show",
+  "ads performance segments show",
+  // Pages and measurement.
+  "analytics overview",
+  "analytics traffic",
+  "analytics funnel",
+  "analytics flow",
+  "analytics page",
+  "analytics triggers",
+  "analytics releases",
+  "analytics paid",
+  "analytics delivery",
+  "analytics submissions",
+  "analytics geo",
+  "analytics bots",
+  "analytics landings",
+  "analytics tags",
+  "analytics events",
+  "analytics feed",
+  "analytics lookup",
+  "analytics devices",
+  "analytics ads",
+  "analytics conversions",
+  "analytics sends",
+  "analytics tracking",
+  "analytics arrivals",
+  "analytics sending-events",
+  "analytics sources",
+  "analytics website-tag",
+  "analytics sites",
+  "analytics questionnaire",
+  "analytics presets",
+  "funnel",
+  "ga4 properties",
+  "ga4 config",
+  "ga4 audit",
+  "ga4 query",
+  "ga4 draft list",
+  "ga4 draft show",
+  "gsc",
+  "tags list",
+  "tags draft",
+  "tag-manager containers",
+  "tag-manager read",
+  "tag-manager draft list",
+  "tag-manager draft show",
+  // CRM and accounts.
+  "hubspot",
+  "accounts influenced",
+  "accounts engagement",
+  "accounts warm",
+  "accounts company",
+  "accounts campaigns",
+  "accounts crm status",
+  "accounts crm check",
+  "accounts crm contract",
+  // Research and judgment, run as the workspace itself (never with --company).
+  // Not `research customers`, which writes into a company's Knowledge, nor
+  // `winning-ads fit`, which judges an ad against a company's own COMPANY.md.
+  "research web",
+  "research fetch",
+  "research linkedin-person",
+  "research transcript",
+  "research company",
+  "research google-ads",
+  "research reddit",
+  "research advertisers",
+  "research autocomplete",
+  "research countries",
+  "research intent",
+  "research keyword-metrics",
+  "research keywords-for-site",
+  "research keyword-gap",
+  "research languages",
+  "research lighthouse",
+  "research relevant-pages",
+  "decide",
+  "winning-ads search",
+  "winning-ads advertisers",
+  // Adds a brand to Baker's shared library with nobody following it, so a
+  // client being set up can be read there: its channels, ads and landings.
+  "winning-ads add",
+  "winning-ads discover",
+  "winning-ads following",
+  "winning-ads feed",
+  "winning-ads winners",
+  "winning-ads ads",
+  "winning-ads profile",
+  "winning-ads launches",
+  "winning-ads landings",
+  "winning-ads search-copy",
+  "winning-ads content",
+  "winning-ads hooks",
+  "winning-ads mechanisms",
+  "winning-ads formats"
+];
+function covers(entry, path) {
+  return path === entry || path.startsWith(`${entry} `);
+}
+function offers(profile, path) {
+  if (path === "") return true;
+  if (profile === "company") {
+    return !ORGANIZATION_ONLY.some((family) => covers(family, path));
+  }
+  return ORGANIZATION_COMMANDS.some((entry) => covers(entry, path) || covers(path, entry));
+}
+var ORGANIZATION_WRITE_FLAGS = {
+  "images extract": ["auto-ingest", "context"],
+  funnel: ["steps", "step", "add-trigger", "remove-trigger", "event", "remove-step", "preset"],
+  "analytics conversions": ["event", "name", "rename", "to", "remove-name", "count-mode", "remove"],
+  "analytics sends": [
+    "set",
+    "source-event",
+    "from",
+    "platform",
+    "tag",
+    "event",
+    "account",
+    "parameter",
+    "id",
+    "remove"
+  ],
+  "analytics sources": [
+    "server",
+    "create",
+    "create-hubspot",
+    "create-activecampaign",
+    "events",
+    "account",
+    "set-trigger",
+    "set-amount",
+    "amount-property",
+    "currency",
+    "write",
+    "name",
+    "map",
+    "field",
+    "pause",
+    "resume",
+    "remove"
+  ],
+  "analytics sites": ["add", "remove"]
+};
+function kebabCase(name) {
+  return name.replace(/[A-Z]/g, (letter) => `-${letter.toLowerCase()}`);
+}
+function refusedFlagIn(path, argv) {
+  const refused = ORGANIZATION_WRITE_FLAGS[path];
+  if (!refused) return null;
+  const end = argv.indexOf("--");
+  for (const token of end === -1 ? argv : argv.slice(0, end)) {
+    if (!token.startsWith("--")) continue;
+    const name = kebabCase(token.slice(2).split("=")[0] ?? "").replace(/^no-/, "");
+    if (refused.includes(name)) return name;
+  }
+  return null;
+}
+var ORGANIZATION_REFUSAL = "The organization workspace only reads its companies, and this command changes something. A change to a company is made in that company's own chat; here, read it and show it in a Report.";
+function hide(command) {
+  if (typeof command.meta === "object" && command.meta !== null) {
+    command.meta.hidden = true;
+  }
+}
+function describeOffered(root, command, profile, path) {
+  const meta = command.meta;
+  if (meta?.hidden === true) return;
+  const offered = (cited) => offers(profile, cited);
+  const refusedFlags = profile === "organization" ? ORGANIZATION_WRITE_FLAGS[path.join(" ")] ?? [] : [];
+  if (typeof meta?.description === "string") {
+    meta.description = describedFor(root, meta.description, path, command, profile, offered, refusedFlags);
+  }
+  const shaped = command;
+  if (typeof shaped.args === "object" && shaped.args !== null) {
+    shaped.args = Object.fromEntries(
+      Object.entries(shaped.args).flatMap(([name, arg]) => {
+        if (refusedFlags.includes(kebabCase(name))) return [];
+        const description = arg?.description;
+        return [
+          [
+            name,
+            typeof description === "string" ? { ...arg, description: withoutUnoffered(root, description, offered, refusedFlags) } : arg
+          ]
+        ];
+      })
+    );
+  }
+  const subCommands = command.subCommands;
+  if (typeof subCommands !== "object" || subCommands === null) return;
+  for (const [name, sub] of Object.entries(subCommands)) {
+    if (typeof sub === "object" && sub !== null)
+      describeOffered(root, sub, profile, [...path, name]);
+  }
+}
+function hideUnoffered(command, profile, path) {
+  const subCommands = command.subCommands;
+  if (typeof subCommands !== "object" || subCommands === null) return;
+  for (const [name, sub] of Object.entries(subCommands)) {
+    if (typeof sub !== "object" || sub === null) continue;
+    const subPath = [...path, name];
+    if (!offers(profile, subPath.join(" "))) hide(sub);
+    hideUnoffered(sub, profile, subPath);
+  }
+}
+function camelCase(name) {
+  return name.replace(/-([a-z0-9])/g, (_, letter) => letter.toUpperCase());
+}
+function aliases(of) {
+  return Array.isArray(of) ? of : of === void 0 ? [] : [of];
+}
+function takesValue(command, flag) {
+  if (flag.includes("=") || typeof command.args !== "object" || command.args === null) return false;
+  const name = flag.replace(/^-{1,2}/, "");
+  return Object.entries(command.args).some(
+    ([key, definition]) => (definition.type === "string" || definition.type === "enum") && (camelCase(key) === camelCase(name) || aliases(definition.alias).includes(name))
+  );
+}
+async function addressedCommand(root, argv) {
+  const path = [];
+  let command = root;
+  for (let index = 0; index < argv.length; index++) {
+    const token = argv[index] ?? "";
+    if (token === "--") break;
+    if (token.startsWith("-")) {
+      if (takesValue(command, token)) index++;
+      continue;
+    }
+    const next = await loadSubCommandNamed(command, token);
+    if (!next) break;
+    path.push(next[0]);
+    command = next[1];
+  }
+  return { path: path.join(" "), command };
+}
+async function applyAgentProfile(root, profile, argv) {
+  const { path, command } = await addressedCommand(root, argv);
+  await loadAllCommands(command);
+  const refused = profile === "organization" && (!offers(profile, path) || refusedFlagIn(path, argv) !== null);
+  hideUnoffered(root, profile, []);
+  describeOffered(root, root, profile, []);
+  return refused ? ORGANIZATION_REFUSAL : null;
+}
+
+export {
+  loadCommands,
+  agentProfile,
+  offers,
+  applyAgentProfile
+};
+//# sourceMappingURL=chunk-WSYQ6LWB.js.map