@unbrained/pm-cli 2026.7.15 → 2026.7.17

package/dist/cli/bootstrap-args.js

@@ -1,837 +1,10 @@
 /**
  * @module cli/bootstrap-args
  *
- * Provides CLI runtime support for Bootstrap Args.
+ * Preserves the CLI compatibility path for SDK-owned bootstrap primitives.
  */
 
-!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]="c8537d1b-6df6-53b0-a308-f91e09d39cf3")}catch(e){}}();
-import { EXECUTABLE_COMMAND_ALIASES, resolveSubcommandFlagContractsForCommand, } from "../sdk/cli-contracts.js";
-export { EXECUTABLE_COMMAND_ALIASES };
-import { levenshteinDistanceWithinLimit } from "../core/shared/levenshtein.js";
-const GLOBAL_VALUE_CONSUMING_FLAGS = new Set([
-    "--pm-path",
-    "--path",
-    "--author",
-]);
-/** Whether a global value-consuming flag uses its inline `--flag=value` form. */
-const isInlineGlobalValueToken = (token) => {
-    const equalsIndex = token.indexOf("=");
-    return (equalsIndex > 0 &&
-        GLOBAL_VALUE_CONSUMING_FLAGS.has(token.slice(0, equalsIndex)));
-};
-/** Whether optional bootstrap author syntax consumes the following token. */
-const 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="
-            : undefined;
-    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=",
-    };
-}
-/** Implements parse bootstrap global options for the public runtime surface of this module. */
-export function parseBootstrapGlobalOptions(argv) {
-    let legacyPathValue;
-    let pmPathValue;
-    let noExtensions = false;
-    let noPager = false;
-    let json = false;
-    let quiet = false;
-    let author;
-    let authorMissingValue = false;
-    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 !== undefined) {
-                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 {
-                authorMissingValue = true;
-                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 !== undefined ? { author } : {}),
-        ...(authorMissingValue ? { authorMissingValue: true } : {}),
-    };
-}
-/** Implements strip global bootstrap tokens for the public runtime surface of this module. */
-export 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;
-}
-/** Implements parse bootstrap help request for the public runtime surface of this module. */
-export function parseBootstrapHelpRequest(argv) {
-    const stripped = stripGlobalBootstrapTokens(argv);
-    const first = stripped[0]?.trim().toLowerCase();
-    if (first === "help") {
-        const commandPathTokens = [];
-        for (let index = 1; index < stripped.length; index += 1) {
-            const token = stripped[index];
-            if (token.startsWith("-")) {
-                break;
-            }
-            commandPathTokens.push(token.trim().toLowerCase());
-        }
-        return {
-            requested: true,
-            commandPathTokens,
-        };
-    }
-    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,
-    };
-}
-/**
- * Index of the command token in argv — the first non-flag token, skipping the
- * value-consuming/global bootstrap flags. Returns undefined when there is none
- * (bare invocation, only global flags, or a leading `--`). Single source of truth
- * for command-position scanning shared by {@link parseBootstrapCommandName} and the
- * command-alias rewrite so their precedence rules can never drift apart.
- */
-function findCommandTokenIndex(argv) {
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        if (token === "--") {
-            return undefined;
-        }
-        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 undefined;
-}
-/** Implements parse bootstrap command name for the public runtime surface of this module. */
-export function parseBootstrapCommandName(argv) {
-    const index = findCommandTokenIndex(argv);
-    return index === undefined ? undefined : 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;
-}
-/** Implements apply bootstrap pager policy for the public runtime surface of this module. */
-export function applyBootstrapPagerPolicy(argv) {
-    const bootstrapGlobal = parseBootstrapGlobalOptions(argv);
-    if (!shouldDisablePagerForInvocation(argv, bootstrapGlobal)) {
-        return;
-    }
-    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";
-    }
-}
-const EXTENSION_ACTION_SYNTAX_TOKENS = new Set([
-    "install",
-    "uninstall",
-    "explore",
-    "manage",
-    "doctor",
-    "adopt",
-    "adopt-all",
-    "activate",
-    "deactivate",
-]);
-/** Implements normalize legacy extension action syntax for the public runtime surface of this module. */
-export function normalizeLegacyExtensionActionSyntax(argv) {
-    const extensionIndex = argv.findIndex((token) => token === "extension");
-    if (extensionIndex < 0) {
-        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),
-    ];
-}
-/** Executable command aliases: a leading command token here is rewritten to its canonical command BEFORE commander parses, so the alias actually runs instead of merely being suggested. These are the highest-frequency aliases real agents type (telemetry: `pm show <id>` alone is the single most common unknown-command) and each target takes the same positional/flags as the alias (with `--comment`/ `--note`/`--learning` flag-aliased to `--add` on the target command). Keeping this in one place means the alias is consistent across registration, commander dispatch, telemetry, and error handling — all of which read the normalized argv. */
-/**
- * Rewrite a leading command-alias token (e.g. `show` -> `get`) in place. Only the
- * command position is considered — the same token appearing later as an argument
- * (`pm get show`) is left untouched — and only when it is not preceded by `--` or a
- * value-consuming global flag, mirroring {@link parseBootstrapCommandName}.
- */
-function rewriteCommandAlias(argv, trace) {
-    const index = findCommandTokenIndex(argv);
-    if (index === undefined) {
-        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 === undefined) {
-        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 = new Map();
-    const canonicalByCompact = new Map();
-    const canonicalComparablesMap = new Map();
-    const listCanonicalFlags = 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",
-    };
-}
-/** Implements list alias plural keys for the public runtime surface of this module. */
-export 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) {
-    if (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) {
-    if (!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) : undefined;
-    const resolution = resolveCanonicalFlag(key, lookup);
-    if (!resolution) {
-        return { tokens: [token] };
-    }
-    const normalizedToken = inlineValue === undefined
-        ? 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,
-        },
-    };
-}
-// Global option flags whose value may legitimately begin with "--" (commander
-// accepts such values). Their value token must not be reinterpreted as a list
-// flag during coalescing. `--pm-path <dir>` and its legacy `--path <dir>`
-// alias are the documented cases; other globals
-// (--json/--quiet/--no-extensions/--no-pager/--profile) are boolean.
-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 !== undefined) {
-        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 ? undefined : 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,
-    });
-    // Reserve the anchor position; finalized after the walk so we know the full
-    // merged value or can restore the original token form for single uses.
-    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);
-    }
-}
-/**
- * Coalesce repeated occurrences of comma-separated list flags into a single
- * `--flag=v1,v2,v3` token anchored at the FIRST occurrence. Without this,
- * Commander treats these flags as scalars and silently keeps only the last
- * value (data loss). Both `--flag value` and `--flag=value` forms are merged;
- * a value-less occurrence is preserved untouched, and a `--` terminator stops
- * coalescing (remainder is passed through verbatim).
- *
- * `valueConsumingFlags` lists option flags (e.g. global `--path`) whose value
- * may itself begin with `--`. Their value token is emitted verbatim so a
- * list-flag-looking value (`--path --tags`) is never reinterpreted as a flag
- * nor allowed to swallow the following command/positional token.
- */
-export function coalesceRepeatedListFlags(argv, listFlags, valueConsumingFlags = new Set(), multiValueListFlags = new Set()) {
-    if (listFlags.size === 0) {
-        return { argv: [...argv], events: [] };
-    }
-    const result = [];
-    const slots = new Map();
-    let index = 0;
-    while (index < argv.length) {
-        const token = argv[index];
-        if (token === "--") {
-            result.push(...argv.slice(index));
-            break;
-        }
-        // A value-consuming option in space form owns the next token as its value,
-        // even when that value begins with "--". Emit both verbatim so the value is
-        // never misread as a list-flag occurrence.
-        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 === undefined) {
-            // Value-less occurrence: leave untouched, do not coalesce.
-            result.push(token);
-            index += occurrence.consumed;
-            continue;
-        }
-        recordListFlagOccurrence(slots, result, parsed.flag, {
-            originalTokens: occurrence.originalTokens,
-            value: occurrence.value,
-        });
-        index += occurrence.consumed;
-    }
-    // Apply anchor splices from the end so earlier indices stay valid when a
-    // single-occurrence anchor expands back into two tokens.
-    const { events, splices } = buildListFlagCoalescingSplices(slots, multiValueListFlags);
-    applyListFlagSplices(result, splices);
-    return { argv: result, events };
-}
-/** Linked-test entry keys accepted in the two-token form `pm test <id> --add command "npm test -- parser"` (GH-191). Only entry-identity keys are merged: `command`/`cmd` name the shell command and `path` names the test file, so a single key=value entry is meaningful for them. Other structured keys (scope, env_set, assertions, ...) cannot form a valid standalone entry and are left for the normal parser to reject. `--remove` matches existing entries by `command=`/`path=` only, so `cmd` is excluded there. Key names mirror STRUCTURED_LINKED_TEST_KEYS in src/cli/commands/linked-test-entry.ts. */
-const LINKED_TEST_TWO_TOKEN_KEYS_BY_FLAG = new Map([
-    ["--add", new Set(["command", "cmd", "path"])],
-    ["--remove", new Set(["command", "path"])],
-]);
-/** Sandbox-safe linked-test commands legitimately start with env assignments (`PM_PATH=... PM_GLOBAL_PATH=... vitest run -- parser`), which look like bare key=value settings tokens. When the two preceding tokens are a linked-test flag plus a bare two-token key (`--add command <value>`), the value must be left intact for mergeLinkedTestTwoTokenEntries instead of being rewritten into a canonical flag (e.g. PM_PATH= -> --pm-path), which would silently corrupt the command into `--add command --pm-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 !== undefined && keys.has(key);
-}
-function shouldPreserveBareKeyValueToken(commandName, emittedTokens) {
-    return (commandName === "search" ||
-        isLinkedTestTwoTokenValuePosition(commandName, emittedTokens));
-}
-/** Accept the two-token linked-test form `pm test <id> --add command "npm test -- parser"` by merging the bare key token and its single quoted value into the documented `--add command=...` shape. Without this merge Commander binds the bare key as the option value and treats the quoted command as an excess positional, failing with "too many arguments" (GH-191). The merge only fires when EXACTLY ONE non-flag token follows the bare key, i.e. the value was quoted into one shell token — an unquoted multi-token value stays ambiguous (it may swallow the item id), still fails fast, and is routed to targeted quoting guidance by the commander error classifier instead. */
-export 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] : undefined;
-        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;
-}
-/** Implements normalize bootstrap invocation for the public runtime surface of this module. */
-export 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 = [];
-    for (let index = 0; index < aliasNormalized.length; index += 1) {
-        const token = aliasNormalized[index];
-        if (token === "--") {
-            normalizedArgv.push(...aliasNormalized.slice(index));
-            break;
-        }
-        const previous = normalizedArgv[normalizedArgv.length - 1];
-        if (token.startsWith("--")) {
-            const normalizedToken = normalizeLongOptionToken(token, lookup);
-            normalizedArgv.push(...normalizedToken.tokens);
-            if (normalizedToken.event) {
-                trace.push(normalizedToken.event);
-            }
-            continue;
-        }
-        const bareKeyValue = parseBareKeyValueToken(token);
-        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" ? new Set(["--tags"]) : 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;
-}
-/** Implements parse bootstrap type value for the public runtime surface of this module. */
-export function parseBootstrapTypeValue(argv) {
-    for (let index = 0; index < argv.length; index += 1) {
-        const token = argv[index];
-        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 undefined;
-}
-/** Public contract for test only, shared by SDK and presentation-layer consumers. */
-export const _testOnly = {
-    buildFlagLookup,
-    collectLongFlagCandidates,
-    markUnambiguousFlag,
-    normalizeLongOptionToken,
-    resolveCanonicalFlag,
-};
+!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]="7ea0ba9e-0857-5090-9568-3432d518ac25")}catch(e){}}();
+export * from "../sdk/cli-bootstrap.js";
 //# sourceMappingURL=bootstrap-args.js.map
-//# debugId=c8537d1b-6df6-53b0-a308-f91e09d39cf3
+//# debugId=7ea0ba9e-0857-5090-9568-3432d518ac25