@unbrained/pm-cli 2026.7.16 → 2026.7.17

package/dist/cli-bundle/chunks/chunk-XYJK6GIQ.js

@@ -0,0 +1,851 @@
+import {
+  EXECUTABLE_COMMAND_ALIASES,
+  resolveSubcommandFlagContractsForCommand
+} from "./chunk-S6FF7VW6.js";
+import {
+  writeStdout
+} from "./chunk-EHJFUOXL.js";
+import {
+  EXIT_CODE,
+  PmCliError,
+  levenshteinDistanceWithinLimit
+} from "./chunk-WACRQ26A.js";
+
+// dist/sdk/cli-bootstrap.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "a359a8f1-ea63-5579-b93b-3ebbfb2a89b8");
+  } catch (e2) {
+  }
+})();
+var GLOBAL_VALUE_CONSUMING_FLAGS = /* @__PURE__ */ new Set([
+  "--pm-path",
+  "--path",
+  "--author"
+]);
+var isInlineGlobalValueToken = (token) => {
+  const equalsIndex = token.indexOf("=");
+  return equalsIndex > 0 && GLOBAL_VALUE_CONSUMING_FLAGS.has(token.slice(0, equalsIndex));
+};
+var consumesBootstrapAuthorValue = (next) => {
+  return typeof next === "string" && !next.startsWith("-");
+};
+function parseBootstrapPathToken(token, next) {
+  if (token === "--path" || token === "--pm-path") {
+    if (typeof next === "string" && next.length > 0) {
+      return {
+        consumed: 2,
+        pathValue: next,
+        preferred: token === "--pm-path"
+      };
+    }
+    return {
+      consumed: 1,
+      preferred: token === "--pm-path"
+    };
+  }
+  const inlinePrefix = token.startsWith("--path=") ? "--path=" : token.startsWith("--pm-path=") ? "--pm-path=" : void 0;
+  if (!inlinePrefix) {
+    return null;
+  }
+  const value = token.slice(inlinePrefix.length);
+  if (value.length > 0) {
+    return {
+      consumed: 1,
+      pathValue: value,
+      preferred: inlinePrefix === "--pm-path="
+    };
+  }
+  return {
+    consumed: 1,
+    preferred: inlinePrefix === "--pm-path="
+  };
+}
+function parseBootstrapGlobalOptions(argv) {
+  let legacyPathValue;
+  let pmPathValue;
+  let noExtensions = false;
+  let noPager = false;
+  let json = false;
+  let quiet = false;
+  let author;
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--no-extensions") {
+      noExtensions = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--no-pager") {
+      noPager = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--json") {
+      json = true;
+      index += 1;
+      continue;
+    }
+    if (token === "--quiet") {
+      quiet = true;
+      index += 1;
+      continue;
+    }
+    const parsedPath = parseBootstrapPathToken(token, argv[index + 1]);
+    if (parsedPath) {
+      if (parsedPath.pathValue !== void 0) {
+        if (parsedPath.preferred) {
+          pmPathValue = parsedPath.pathValue;
+        } else {
+          legacyPathValue = parsedPath.pathValue;
+        }
+      }
+      index += parsedPath.consumed;
+      continue;
+    }
+    if (token === "--author") {
+      if (consumesBootstrapAuthorValue(argv[index + 1])) {
+        author = argv[index + 1];
+        index += 2;
+      } else {
+        author = "";
+        index += 1;
+      }
+      continue;
+    }
+    if (token.startsWith("--author=")) {
+      author = token.slice("--author=".length);
+      index += 1;
+      continue;
+    }
+    index += 1;
+  }
+  return {
+    path: pmPathValue ?? legacyPathValue,
+    noExtensions,
+    noPager,
+    json,
+    quiet,
+    ...author === "" ? { authorMissingValue: true } : author !== void 0 ? { author } : {}
+  };
+}
+function stripGlobalBootstrapTokens(argv) {
+  const remaining = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--json" || token === "--quiet" || token === "--no-extensions" || token === "--no-pager" || token === "--profile" || token === "--id-only" || token === "--explain") {
+      index += 1;
+      continue;
+    }
+    if (token === "--author") {
+      index += consumesBootstrapAuthorValue(argv[index + 1]) ? 2 : 1;
+      continue;
+    }
+    if (GLOBAL_VALUE_CONSUMING_FLAGS.has(token)) {
+      index += 2;
+      continue;
+    }
+    if (isInlineGlobalValueToken(token)) {
+      index += 1;
+      continue;
+    }
+    remaining.push(token);
+    index += 1;
+  }
+  return remaining;
+}
+function parseBootstrapHelpRequest(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  if (first === "help") {
+    const commandPathTokens2 = [];
+    for (let index = 1; index < stripped.length; index += 1) {
+      const token = stripped[index];
+      if (token.startsWith("-")) {
+        break;
+      }
+      commandPathTokens2.push(token.trim().toLowerCase());
+    }
+    return {
+      requested: true,
+      commandPathTokens: commandPathTokens2
+    };
+  }
+  const helpFlagIndex = stripped.findIndex((token) => token === "--help" || token === "-h");
+  if (helpFlagIndex < 0) {
+    return {
+      requested: false,
+      commandPathTokens: []
+    };
+  }
+  const commandPathTokens = [];
+  for (const token of stripped) {
+    if (token.startsWith("-")) {
+      break;
+    }
+    commandPathTokens.push(token.trim().toLowerCase());
+  }
+  return {
+    requested: true,
+    commandPathTokens
+  };
+}
+function findCommandTokenIndex(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      return void 0;
+    }
+    if (token === "--author") {
+      index += consumesBootstrapAuthorValue(argv[index + 1]) ? 1 : 0;
+      continue;
+    }
+    if (GLOBAL_VALUE_CONSUMING_FLAGS.has(token)) {
+      index += 1;
+      continue;
+    }
+    if (isInlineGlobalValueToken(token) || token === "--json" || token === "--quiet" || token === "--no-extensions" || token === "--no-pager" || token === "--profile" || token === "--id-only" || token === "--explain") {
+      continue;
+    }
+    if (token.startsWith("-")) {
+      continue;
+    }
+    return index;
+  }
+  return void 0;
+}
+function parseBootstrapCommandName(argv) {
+  const index = findCommandTokenIndex(argv);
+  return index === void 0 ? void 0 : argv[index].trim().toLowerCase();
+}
+function shouldDisablePagerForInvocation(argv, bootstrapGlobal) {
+  if (bootstrapGlobal.noPager) {
+    return true;
+  }
+  if (process.stdout.isTTY === true) {
+    return false;
+  }
+  const helpRequest = parseBootstrapHelpRequest(argv);
+  return helpRequest.requested;
+}
+function applyBootstrapPagerPolicy(argv) {
+  const pagerEnvironmentKeys = [
+    "PAGER",
+    "MANPAGER",
+    "GIT_PAGER",
+    "LESS"
+  ];
+  const previousValues = pagerEnvironmentKeys.map((key) => process.env[key]);
+  const restore = () => {
+    for (const [index, key] of pagerEnvironmentKeys.entries()) {
+      const value = previousValues[index];
+      if (value === void 0) {
+        delete process.env[key];
+      } else {
+        process.env[key] = value;
+      }
+    }
+  };
+  const bootstrapGlobal = parseBootstrapGlobalOptions(argv);
+  if (!shouldDisablePagerForInvocation(argv, bootstrapGlobal)) {
+    return restore;
+  }
+  process.env.PAGER = "cat";
+  process.env.MANPAGER = "cat";
+  process.env.GIT_PAGER = "cat";
+  if (typeof process.env.LESS !== "string" || process.env.LESS.trim().length === 0) {
+    process.env.LESS = "FRX";
+  }
+  return restore;
+}
+var EXTENSION_ACTION_SYNTAX_TOKENS = /* @__PURE__ */ new Set([
+  "install",
+  "uninstall",
+  "explore",
+  "manage",
+  "doctor",
+  "adopt",
+  "adopt-all",
+  "activate",
+  "deactivate"
+]);
+function normalizeLegacyExtensionActionSyntax(argv) {
+  const extensionIndex = findCommandTokenIndex(argv);
+  if (extensionIndex === void 0 || argv[extensionIndex] !== "extension") {
+    return [...argv];
+  }
+  const actionToken = argv[extensionIndex + 1];
+  if (!actionToken || actionToken.startsWith("-")) {
+    return [...argv];
+  }
+  if (!EXTENSION_ACTION_SYNTAX_TOKENS.has(actionToken)) {
+    return [...argv];
+  }
+  if (argv.includes("--help") || argv.includes("-h")) {
+    return [...argv];
+  }
+  const forcedActionFlag = `--${actionToken}`;
+  if (argv.includes(forcedActionFlag)) {
+    return [...argv];
+  }
+  return [
+    ...argv.slice(0, extensionIndex + 1),
+    forcedActionFlag,
+    ...argv.slice(extensionIndex + 2)
+  ];
+}
+function rewriteCommandAlias(argv, trace) {
+  const index = findCommandTokenIndex(argv);
+  if (index === void 0) {
+    return argv;
+  }
+  const token = argv[index];
+  const canonical = EXECUTABLE_COMMAND_ALIASES[token.trim().toLowerCase()];
+  if (!canonical) {
+    return argv;
+  }
+  const rewritten = [...argv];
+  rewritten[index] = canonical;
+  trace.push({
+    from: token,
+    to: [canonical],
+    reason: "command_alias",
+    confidence: "high"
+  });
+  return rewritten;
+}
+function normalizeFlagKeyToken(raw) {
+  const withoutPrefix = raw.replace(/^--?/, "");
+  return withoutPrefix.replace(/_/g, "-").replace(/([a-z0-9])([A-Z])/g, "$1-$2").toLowerCase();
+}
+function toComparableFlagKey(raw) {
+  return normalizeFlagKeyToken(raw).replace(/-/g, "");
+}
+function markUnambiguousFlag(map, key, canonicalFlag) {
+  const existing = map.get(key);
+  if (existing === void 0) {
+    map.set(key, canonicalFlag);
+    return;
+  }
+  if (existing !== canonicalFlag) {
+    map.set(key, null);
+  }
+}
+function collectLongFlagCandidates(contract) {
+  const candidates = [];
+  const pushLongFlag = (value) => {
+    if (typeof value !== "string") {
+      return;
+    }
+    if (!value.startsWith("--")) {
+      return;
+    }
+    candidates.push(value);
+  };
+  pushLongFlag(contract.flag);
+  for (const alias of contract.aliases ?? []) {
+    pushLongFlag(alias);
+  }
+  return candidates;
+}
+function buildFlagLookup(commandName, contractsOverride) {
+  const contracts = contractsOverride ?? resolveSubcommandFlagContractsForCommand(commandName);
+  const canonicalByNormalized = /* @__PURE__ */ new Map();
+  const canonicalByCompact = /* @__PURE__ */ new Map();
+  const canonicalComparablesMap = /* @__PURE__ */ new Map();
+  const listCanonicalFlags = /* @__PURE__ */ new Set();
+  for (const contract of contracts) {
+    const longCandidates = collectLongFlagCandidates(contract);
+    if (longCandidates.length === 0) {
+      continue;
+    }
+    const canonicalFlag = `--${normalizeFlagKeyToken(longCandidates[0])}`;
+    for (const candidate of longCandidates) {
+      markUnambiguousFlag(canonicalByNormalized, normalizeFlagKeyToken(candidate), canonicalFlag);
+      markUnambiguousFlag(canonicalByCompact, toComparableFlagKey(candidate), canonicalFlag);
+    }
+    const comparable = toComparableFlagKey(canonicalFlag);
+    if (!canonicalComparablesMap.has(canonicalFlag)) {
+      canonicalComparablesMap.set(canonicalFlag, comparable);
+    }
+    if (contract.list === true) {
+      listCanonicalFlags.add(canonicalFlag);
+    }
+  }
+  return {
+    canonicalByNormalized,
+    canonicalByCompact,
+    canonicalComparables: [...canonicalComparablesMap.entries()].map(([canonicalFlag, comparable]) => ({
+      canonicalFlag,
+      comparable
+    })),
+    listCanonicalFlags
+  };
+}
+function resolveCanonicalFlag(rawKey, lookup) {
+  const normalizedKey = normalizeFlagKeyToken(rawKey);
+  const direct = lookup.canonicalByNormalized.get(normalizedKey);
+  if (typeof direct === "string") {
+    return {
+      flag: direct,
+      reason: "flag_alias",
+      confidence: "high"
+    };
+  }
+  const comparableKey = normalizedKey.replace(/-/g, "");
+  const compactMatch = lookup.canonicalByCompact.get(comparableKey);
+  if (typeof compactMatch === "string") {
+    return {
+      flag: compactMatch,
+      reason: "flag_alias",
+      confidence: "high"
+    };
+  }
+  const maxDistance = comparableKey.length >= 8 ? 2 : 1;
+  let bestDistance = Number.POSITIVE_INFINITY;
+  let bestFlag;
+  let tied = false;
+  for (const candidate of lookup.canonicalComparables) {
+    const distance = levenshteinDistanceWithinLimit(comparableKey, candidate.comparable, maxDistance);
+    if (distance === null) {
+      continue;
+    }
+    if (distance < bestDistance) {
+      bestDistance = distance;
+      bestFlag = candidate.canonicalFlag;
+      tied = false;
+      continue;
+    }
+    if (distance === bestDistance && bestFlag !== candidate.canonicalFlag) {
+      tied = true;
+    }
+  }
+  if (!bestFlag || tied || !Number.isFinite(bestDistance) || bestDistance <= 0) {
+    return null;
+  }
+  return {
+    flag: bestFlag,
+    reason: "flag_typo",
+    confidence: bestDistance >= 2 ? "medium" : "high"
+  };
+}
+function listAliasPluralKeys(normalizedKey) {
+  const candidates = [`${normalizedKey}s`];
+  if (normalizedKey.endsWith("y") && normalizedKey.length > 1) {
+    candidates.push(`${normalizedKey.slice(0, -1)}ies`);
+  }
+  return candidates;
+}
+function parseBareKeyValueToken(token, preserve = false) {
+  if (preserve || token.includes("://")) {
+    return null;
+  }
+  const match = token.match(/^([A-Za-z][A-Za-z0-9_-]{1,63})([:=])(.*)$/);
+  if (!match) {
+    return null;
+  }
+  const key = match[1];
+  const value = match[3];
+  if (value.length === 0) {
+    return null;
+  }
+  return {
+    key,
+    value
+  };
+}
+function normalizeLongOptionToken(token, lookup, preserve = false) {
+  if (preserve || !token.startsWith("--")) {
+    return { tokens: [token] };
+  }
+  const equalsIndex = token.indexOf("=");
+  const key = equalsIndex >= 0 ? token.slice(0, equalsIndex) : token;
+  const inlineValue = equalsIndex >= 0 ? token.slice(equalsIndex + 1) : void 0;
+  const resolution = resolveCanonicalFlag(key, lookup);
+  if (!resolution) {
+    return { tokens: [token] };
+  }
+  const normalizedToken = inlineValue === void 0 ? resolution.flag : `${resolution.flag}=${inlineValue}`;
+  if (normalizedToken === token) {
+    return { tokens: [token] };
+  }
+  return {
+    tokens: [normalizedToken],
+    event: {
+      from: token,
+      to: [normalizedToken],
+      reason: resolution.reason,
+      confidence: resolution.confidence
+    }
+  };
+}
+function collectBootstrapPathValueIndices(argv) {
+  const indices = /* @__PURE__ */ new Set();
+  let expectsValue = false;
+  for (let index = 0; index < argv.length; index += 1) {
+    if (expectsValue) {
+      indices.add(index);
+      expectsValue = false;
+      continue;
+    }
+    const token = argv[index];
+    expectsValue = token === "--path" || token === "--pm-path";
+  }
+  return indices;
+}
+function splitCanonicalListToken(token) {
+  if (!token.startsWith("--")) {
+    return null;
+  }
+  const equalsIndex = token.indexOf("=");
+  if (equalsIndex < 0) {
+    return { flag: token };
+  }
+  return {
+    flag: token.slice(0, equalsIndex),
+    inlineValue: token.slice(equalsIndex + 1)
+  };
+}
+function copyValueConsumingFlag(argv, index, result) {
+  result.push(argv[index]);
+  const next = argv[index + 1];
+  if (typeof next === "string" && next !== "--") {
+    result.push(next);
+    return index + 2;
+  }
+  return index + 1;
+}
+function readListFlagOccurrence(argv, index, parsed, multiValueListFlags) {
+  if (parsed.inlineValue !== void 0) {
+    return {
+      originalTokens: [argv[index]],
+      value: parsed.inlineValue,
+      consumed: 1
+    };
+  }
+  const values = [];
+  let valueIndex = index + 1;
+  while (valueIndex < argv.length && argv[valueIndex] !== "--" && !argv[valueIndex].startsWith("-") && (values.length === 0 || multiValueListFlags.has(parsed.flag))) {
+    values.push(argv[valueIndex]);
+    valueIndex += 1;
+  }
+  const consumed = values.length === 0 ? 1 : 1 + values.length;
+  return {
+    originalTokens: argv.slice(index, index + consumed),
+    value: values.length === 0 ? void 0 : values.join(","),
+    consumed
+  };
+}
+function recordListFlagOccurrence(slots, result, flag, occurrence) {
+  const existing = slots.get(flag);
+  if (existing) {
+    existing.values.push(occurrence.value);
+    existing.occurrences += 1;
+    return;
+  }
+  slots.set(flag, {
+    outputIndex: result.length,
+    originalTokens: occurrence.originalTokens,
+    values: [occurrence.value],
+    occurrences: 1
+  });
+  result.push(null);
+}
+function buildListFlagCoalescingSplices(slots, multiValueListFlags) {
+  const events = [];
+  const splices = [];
+  for (const [flag, slot] of slots) {
+    const shouldMerge = slot.occurrences >= 2 || multiValueListFlags.has(flag) && slot.originalTokens.length > 2;
+    if (!shouldMerge) {
+      splices.push({
+        outputIndex: slot.outputIndex,
+        tokens: slot.originalTokens
+      });
+      continue;
+    }
+    const mergedToken = `${flag}=${slot.values.join(",")}`;
+    splices.push({ outputIndex: slot.outputIndex, tokens: [mergedToken] });
+    events.push({
+      from: `${flag} (x${slot.occurrences})`,
+      to: [mergedToken],
+      reason: "list_merge",
+      confidence: "high"
+    });
+  }
+  return { events, splices };
+}
+function applyListFlagSplices(result, splices) {
+  splices.sort((a, b) => b.outputIndex - a.outputIndex);
+  for (const splice of splices) {
+    result.splice(splice.outputIndex, 1, ...splice.tokens);
+  }
+}
+function coalesceRepeatedListFlags(argv, listFlags, valueConsumingFlags = /* @__PURE__ */ new Set(), multiValueListFlags = /* @__PURE__ */ new Set()) {
+  if (listFlags.size === 0) {
+    return { argv: [...argv], events: [] };
+  }
+  const result = [];
+  const slots = /* @__PURE__ */ new Map();
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      result.push(...argv.slice(index));
+      break;
+    }
+    if (valueConsumingFlags.has(token)) {
+      index = copyValueConsumingFlag(argv, index, result);
+      continue;
+    }
+    const parsed = splitCanonicalListToken(token);
+    if (!parsed || !listFlags.has(parsed.flag)) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    const occurrence = readListFlagOccurrence(argv, index, parsed, multiValueListFlags);
+    if (occurrence.value === void 0) {
+      result.push(token);
+      index += occurrence.consumed;
+      continue;
+    }
+    recordListFlagOccurrence(slots, result, parsed.flag, {
+      originalTokens: occurrence.originalTokens,
+      value: occurrence.value
+    });
+    index += occurrence.consumed;
+  }
+  const { events, splices } = buildListFlagCoalescingSplices(slots, multiValueListFlags);
+  applyListFlagSplices(result, splices);
+  return { argv: result, events };
+}
+var LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG = /* @__PURE__ */ new Map([
+  ["--add", /* @__PURE__ */ new Set(["command", "cmd", "path"])],
+  ["--remove", /* @__PURE__ */ new Set(["command", "path"])]
+]);
+function isLinkedTestTwoTokenValuePosition(commandName, emittedTokens) {
+  if (commandName !== "test" || emittedTokens.length < 2) {
+    return false;
+  }
+  const key = emittedTokens[emittedTokens.length - 1];
+  const flag = emittedTokens[emittedTokens.length - 2];
+  const keys = LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG.get(flag);
+  return keys !== void 0 && keys.has(key);
+}
+function shouldPreserveBareKeyValueToken(commandName, emittedTokens) {
+  return commandName === "search" || isLinkedTestTwoTokenValuePosition(commandName, emittedTokens);
+}
+function mergeLinkedTestTwoTokenEntries(argv, commandName, trace) {
+  if (commandName !== "test") {
+    return argv;
+  }
+  const result = [];
+  let index = 0;
+  while (index < argv.length) {
+    const token = argv[index];
+    if (token === "--") {
+      result.push(...argv.slice(index));
+      return result;
+    }
+    const keys = LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG.get(token);
+    const key = keys ? argv[index + 1] : void 0;
+    if (!keys || typeof key !== "string" || !keys.has(key)) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    let runEnd = index + 2;
+    while (runEnd < argv.length && !argv[runEnd].startsWith("-")) {
+      runEnd += 1;
+    }
+    if (runEnd - (index + 2) !== 1) {
+      result.push(token);
+      index += 1;
+      continue;
+    }
+    const value = argv[index + 2];
+    const mergedValue = `${key}=${value}`;
+    result.push(token, mergedValue);
+    trace.push({
+      from: `${token} ${key} ${value}`,
+      to: [token, mergedValue],
+      reason: "bare_key_value",
+      confidence: "high"
+    });
+    index += 3;
+  }
+  return result;
+}
+function normalizeBootstrapInvocation(argv) {
+  const trace = [];
+  const legacyNormalized = normalizeLegacyExtensionActionSyntax(argv);
+  if (legacyNormalized.length !== argv.length || legacyNormalized.some((token, index) => token !== argv[index])) {
+    trace.push({
+      from: argv.join(" "),
+      to: [...legacyNormalized],
+      reason: "legacy_extension_action",
+      confidence: "high"
+    });
+  }
+  const aliasNormalized = rewriteCommandAlias(legacyNormalized, trace);
+  const commandName = parseBootstrapCommandName(aliasNormalized);
+  const commandPathName = parseBootstrapCommandPathName(aliasNormalized);
+  const lookup = buildFlagLookup(commandPathName ?? commandName);
+  const normalizedArgv = [];
+  const pathValueIndices = collectBootstrapPathValueIndices(aliasNormalized);
+  for (let index = 0; index < aliasNormalized.length; index += 1) {
+    const token = aliasNormalized[index];
+    if (token === "--") {
+      normalizedArgv.push(...aliasNormalized.slice(index));
+      break;
+    }
+    const preserveCurrentToken = pathValueIndices.has(index);
+    const previous = normalizedArgv[normalizedArgv.length - 1];
+    if (token.startsWith("--")) {
+      const normalizedToken = normalizeLongOptionToken(token, lookup, preserveCurrentToken);
+      normalizedArgv.push(...normalizedToken.tokens);
+      if (normalizedToken.event) {
+        trace.push(normalizedToken.event);
+      }
+      continue;
+    }
+    const bareKeyValue = parseBareKeyValueToken(token, preserveCurrentToken);
+    if (bareKeyValue && !(typeof previous === "string" && previous.startsWith("-")) && !shouldPreserveBareKeyValueToken(commandName, normalizedArgv)) {
+      const resolution = resolveCanonicalFlag(bareKeyValue.key, lookup);
+      if (resolution) {
+        const replacement = [resolution.flag, bareKeyValue.value];
+        normalizedArgv.push(...replacement);
+        trace.push({
+          from: token,
+          to: replacement,
+          reason: "bare_key_value",
+          confidence: resolution.confidence
+        });
+        continue;
+      }
+    }
+    normalizedArgv.push(token);
+  }
+  const linkedTestNormalized = mergeLinkedTestTwoTokenEntries(normalizedArgv, commandName, trace);
+  const coalesced = coalesceRepeatedListFlags(linkedTestNormalized, lookup.listCanonicalFlags, GLOBAL_VALUE_CONSUMING_FLAGS, commandName === "create" ? /* @__PURE__ */ new Set(["--tags"]) : /* @__PURE__ */ new Set());
+  for (const event of coalesced.events) {
+    trace.push(event);
+  }
+  return {
+    argv: coalesced.argv,
+    commandName,
+    trace
+  };
+}
+function parseBootstrapCommandPathName(argv) {
+  const stripped = stripGlobalBootstrapTokens(argv);
+  const first = stripped[0]?.trim().toLowerCase();
+  const second = stripped[1]?.trim().toLowerCase();
+  if ((first === "extension" || first === "package" || first === "packages") && typeof second === "string" && second.length > 0 && !second.startsWith("-")) {
+    return `${first} ${second}`;
+  }
+  return first;
+}
+function parseBootstrapTypeValue(argv) {
+  for (let index = 0; index < argv.length; index += 1) {
+    const token = argv[index];
+    if (token === "--") {
+      break;
+    }
+    if (token === "--type") {
+      const candidate = argv[index + 1];
+      if (typeof candidate === "string" && candidate.trim().length > 0) {
+        return candidate.trim();
+      }
+      continue;
+    }
+    if (token.startsWith("--type=")) {
+      const candidate = token.slice("--type=".length).trim();
+      if (candidate.length > 0) {
+        return candidate;
+      }
+    }
+  }
+  return void 0;
+}
+
+// dist/sdk/invocation-author.js
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "83b4c8c6-db52-50a9-8bf7-97ed382927d6");
+  } catch (e2) {
+  }
+})();
+function applyInvocationAuthorOverride(author) {
+  if (author === void 0) {
+    return () => {
+    };
+  }
+  const normalizedAuthor = author.trim();
+  if (normalizedAuthor.length === 0) {
+    throw new PmCliError("--author requires a non-empty value.", EXIT_CODE.USAGE, {
+      code: "missing_required_argument",
+      nextSteps: ["Pass an explicit author identifier with --author <id>."]
+    });
+  }
+  const previousAuthor = process.env.PM_AUTHOR;
+  process.env.PM_AUTHOR = normalizedAuthor;
+  let restored = false;
+  return () => {
+    if (restored) {
+      return;
+    }
+    restored = true;
+    if (previousAuthor === void 0) {
+      delete process.env.PM_AUTHOR;
+    } else {
+      process.env.PM_AUTHOR = previousAuthor;
+    }
+  };
+}
+
+// dist/sdk/cli-program.js
+import { Command } from "commander";
+!(function() {
+  try {
+    var e = "undefined" != typeof window ? window : "undefined" != typeof global ? global : "undefined" != typeof globalThis ? globalThis : "undefined" != typeof self ? self : {}, n = new e.Error().stack;
+    n && (e._sentryDebugIds = e._sentryDebugIds || {}, e._sentryDebugIds[n] = "91531f42-f413-5b2b-8366-76068aade412");
+  } catch (e2) {
+  }
+})();
+function createPmCliProgram(version) {
+  return new Command().name("pm").description("Universal, flexible, extensible, agent-optimized project management CLI for any project or programming language.").version(version).showHelpAfterError(false).allowExcessArguments(false).allowUnknownOption(false).configureOutput({
+    writeOut: (value) => {
+      writeStdout(value);
+    },
+    writeErr: () => {
+    }
+  }).option("--json", "Output JSON instead of TOON").option("--quiet", "Suppress stdout output").option("--no-changed-fields", "Omit the changed_fields array from mutation output (keeps changed_field_count)").option("--id-only", "Print only id and status for single-item mutation output").option("--pm-path <dir>", "Explicit tracker storage path for this command (preferred over --path)").option("--path <dir>", "Backward-compatible alias for --pm-path; this is the tracker storage path, not a workspace cwd").option("--no-extensions", "Disable extension loading").option("--no-pager", "Disable pager integration for help and long output").option("--explain", "Render extended rationale and examples in help output").option("--profile", "Print deterministic timing diagnostics").option("--author <id>", "Override mutation author for this invocation").exitOverride();
+}
+
+export {
+  parseBootstrapGlobalOptions,
+  stripGlobalBootstrapTokens,
+  parseBootstrapHelpRequest,
+  parseBootstrapCommandName,
+  applyBootstrapPagerPolicy,
+  normalizeLegacyExtensionActionSyntax,
+  listAliasPluralKeys,
+  coalesceRepeatedListFlags,
+  mergeLinkedTestTwoTokenEntries,
+  normalizeBootstrapInvocation,
+  parseBootstrapTypeValue,
+  applyInvocationAuthorOverride,
+  createPmCliProgram
+};
+//# sourceMappingURL=chunk-XYJK6GIQ.js.map