@lannguyensi/harness 0.63.0 → 1.0.0

package/dist/runtime/bash-prefix-parse.js

@@ -1,576 +0,0 @@
-// Risk Gate resolver input — Bash command-prefix parser.
-//
-// Three normal POSIX shell idioms slip past the production environment
-// resolver when only `process.env` and the hook's starting cwd (and, for
-// the branch, its current `.git/HEAD`) are inspected:
-//
-//   DATABASE_URL=postgres://prod terraform destroy   # inline env
-//   cd /repos/prod-infra && terraform destroy        # working-dir hop
-//   git switch main && rm -rf node_modules && ...    # branch hop
-//
-// The hook intercept sees Claude Code's process env and starting cwd, so
-// `env_var_patterns` and `branch_patterns` miss all three signals and the
-// gate silently treats a prod mutation as non-prod.
-//
-// This parser extracts the leading idioms from a Bash command string so
-// the resolver layer can merge them into its inputs before
-// `environments.resolvers[]` runs. Three POSIX forms are supported in v1
-// (kept narrow on purpose, see follow-up scope in the originating tasks):
-//
-//   1. Inline env: leading `\w+=value` tokens. A value is read as one
-//      shell word (see `readWord`): unquoted text, backslash escapes,
-//      single-quoted parts (literal) and double-quoted parts (literal, no
-//      $ interpolation in v1) glued together up to unescaped whitespace,
-//      so `VAR="say \"hi\""` is `say "hi"` and `VAR='it'\''s'` is `it's`
-//      (task b093911d). NOT covered, pinned by tests: ANSI-C `$'...'`
-//      (kept as the raw text, not decoded), `$VAR` / `$(...)` (kept as
-//      literal text), and `;` / `&` inside an UNQUOTED value (they do not
-//      end it).
-//   2. cd prefix: a single leading `cd <path> [&&|;] ...`. The path is
-//      read as the same kind of shell word, ended at an unquoted `;` or
-//      `&`. No `pushd`, no subshell `(cd X && ...)`, no `bash -c`.
-//   3. git branch switch: a single leading `git [-C <path>]
-//      (switch|checkout) <branch> [&&|;] ...` (task 341e024b). The
-//      `<branch>` must be a plain, literal token, unquoted OR quoted
-//      (single- or double-quoted, surrounding quotes stripped — same
-//      quoted-literal handling `cd`'s path token gets, task 341e024b fix
-//      round 1: a quoted `"main"`/`'main'` used to read as the literal
-//      6-character string `"main"` including the quote characters,
-//      which never matches a `branch_patterns` entry like `main` and so
-//      silently defeated the gate). A `-`-prefixed first argument (`-`,
-//      `--`, `-b`, ...; this is how `git checkout -- <path>`'s
-//      file-restore form is excluded) or an unquoted `$VAR`/`${VAR}`
-//      shell variable is left unresolved (`branchTarget: null`) rather
-//      than guessed; a token that STARTS with a quote and carries an
-//      unescaped `$` in a double-quoted part (`"release/$V"`) is treated
-//      the same way (not guessed) since double quotes DO interpolate in
-//      real bash and this parser does not evaluate the shell
-//      environment. A token that does NOT start with a quote but carries
-//      such a `$` mid-word (`release/"$V"`) is read raw, quotes included,
-//      exactly as before the escape-aware reader: bash expands it, so the
-//      branch is unknown, but the raw word still matches a glob like
-//      `release/*` and the clauses behind it (a later `cd`, the kubectl
-//      remainder) stay reachable. A single-quoted token is always taken
-//      literally, since single quotes never interpolate. The optional
-//      `-C <path>` is recognized so it does not block the match, but its
-//      value is discarded: the ONLY thing this idiom feeds the resolver
-//      is the branch name being switched TO (see
-//      `src/cli/policy/intercept.ts`'s merge, which is upgrade-only —
-//      unlike the `cd` merge below, a resolved branch target here can
-//      only push the resolved environment to something MORE dangerous,
-//      never less).
-//
-//      LIMIT, stated so a maintainer does not over-trust this idiom's
-//      coverage: only the FIRST leading branch switch is captured. A
-//      chained `git switch dev && git switch main && rm ...` resolves
-//      `branchTarget` as `dev`, never `main` — multi-switch parsing
-//      (walking past the first `&&` to find a SECOND switch) is
-//      deliberately not built; it would widen the parser's surface
-//      toward the false-positive class task dbc6d303 already measured
-//      (branch-shaped tokens picked up from further into a command that
-//      is not actually a chained branch hop).
-//
-// The clauses may appear in any order relative to each other (`cd /x &&
-// VAR=v cmd`, `VAR=v cd /x && cmd`, `cd /x && git switch main && cmd`,
-// ...); the parser walks up to two passes before giving up.
-//
-// On a syntactically broken prefix (unterminated quote, missing `&&`
-// after `cd <path>` / a switch-or-checkout branch) the parser falls
-// through cleanly: the malformed prefix is not consumed, the
-// resolver-side fallback to process env / hook cwd holds. There are no
-// thrown errors from this module.
-//
-// ESCAPES VS FALL-THROUGH (task b093911d): for a gate that SEARCHES for
-// production indicators, falling through is not the safe direction, a
-// dropped `cd` target or env value hides the very signal being looked
-// for. So a quoted word is decoded the way bash reads it instead of
-// being abandoned when it contains a backslash. Two places keep the OLD
-// reading on purpose: a word whose quote only an escaped quote could
-// close (`VAR="abc\" cd /x && y`, an unterminated string for bash), where
-// the first matching quote ends the word, and a branch word that does not
-// start with a quote but has a `$` in a double-quoted part (form 3).
-//
-// ACCEPTANCE RULE (task b093911d): a reader that changes word boundaries
-// cannot promise "nothing extracted before is lost", so this change is
-// held to a signal-level rule instead, measured against the pre-change
-// parser: (i) no production signal (env value, branch, cd target,
-// kubectl remainder) that the old parser saw and this one does not, on a
-// named high-risk shape set (plain, quoted and escaped env values and cd
-// paths, literal, quoted and `release/"$V"` branches followed by a cd or
-// kubectl, `__proto__=`, the `'\''` idiom, `\"` in double quotes) and on
-// a replay of real agent commands; (ii) fewer missed signals than the old
-// parser on fixed-seed generated corpora with bash as referee, for env,
-// branch and cd from a non-prod cwd; (iii) every remaining new miss
-// belongs to a named residual class whose plain twin the old parser
-// already misses; (iv) the cd downgrades from a prod cwd are reported with
-// numbers. What was measured against that rule is in the CHANGELOG entry
-// and the pull request; the cd-target arms of
-// `scripts/measure-bash-prefix-parse.mjs` show no lost honest target
-// against master and the shipped release (11 of 17 arms prove nothing).
-// Known residuals, not covered. The old parser already gets the plain
-// twin of each of the first four wrong, so they are follow-up work for
-// the prefix walk; the last two are shapes outside the high-risk set,
-// pinned by tests:
-//   - OPERATOR SWALLOWED BY AN ENV WORD: an inline env word that does not
-//     start with a quote swallows unquoted `;`, `&`, `|` and `||` (the
-//     plain `A=x|| cd /t && y` always has; an escape-led or mid-quote word
-//     now does too, kept so `V=\"; W=/tmp cmd` still yields `W` and so a
-//     clause bash runs after a short circuit is still reached). So a `cd`
-//     or assignment behind the operator is read as a leading one: a
-//     phantom `cd` bash never runs (`A=a\ b|| cd /t && y`), or a later
-//     backgrounded assignment that overrides the value bash keeps
-//     (`D=a"b c"; D=dev&T` reads `dev&T`, plain twin `D=x; D=dev&T`);
-//   - PLAIN PATH ACROSS `|`: a plain `cd` path ends at whitespace, `;` or
-//     `&` only, so `cd /srv/p|rod; T` reads `/srv/p|rod` where bash runs
-//     `cd /srv/p` in a pipeline;
-//   - FIRST CD ONLY, AND-LIST BACKGROUNDED: only the first leading `cd` is
-//     read (a later `cd` wins in bash), and a `cd` in an and-list that a
-//     later `&` backgrounds is read although bash runs it in a subshell;
-//   - WORD FOLLOWED BY MORE WORDS: a cd or branch word with no `&&` / `;`
-//     right behind it yields no clause, which now also covers an escaped
-//     `;` inside the word (`git switch release/1.2\; cd dev && T` passes
-//     `release/1.2;`, `cd`, `dev` to git), plain twin
-//     `git switch release/1 checkout main && T`;
-//   - a `cd` path or branch word that carries a quote or an escape and is
-//     ended at an unquoted `|`, `<`, `>`, `(` or `)` (`cd /srv/p|ro"d"`)
-//     rejects its clause and stops the prefix walk;
-//   - ANSI-C `$'...'` and `$VAR` / `$(...)` are kept as raw text, so a
-//     value glued to an unset variable (`D='o'$d`) reads `o$d`.
-// Because this reader now reads more quoted and escaped `cd` paths, the
-// first three classes also produce more cd DOWNGRADES from a prod cwd
-// than the old parser did (a non-prod `cd` that bash does not end in);
-// that trade is measured and accepted in the pull request.
-//
-// MEASUREMENT RULE (task 47297478): any claim about this parser's
-// CD-TARGET extraction versus another build (lost or gained `cdTarget`
-// values) must come from scripts/measure-bash-prefix-parse.mjs, the
-// per-arm-gated corpus with real bash as referee. Three consecutive
-// ad-hoc corpora in the b093911d run reported "0 lost" while being
-// structurally unable to report a loss; that tool's self-test rebuilds
-// exactly that failure and demands the gate catch it. The tool does NOT
-// measure `inlineEnv` or `branchTarget` extraction — claims about those
-// have no instrument yet and need their own measurement.
-/**
- * Parse leading inline-env and `cd <path>` idioms from a Bash command
- * string. Returns an empty `inlineEnv` and `cdTarget:null` when neither
- * idiom matches. Never throws.
- */
-export function parseBashPrefix(command) {
-    if (typeof command !== "string" || command.length === 0) {
-        return { inlineEnv: newEnvMap(), cdTarget: null, branchTarget: null, remainderStart: 0 };
-    }
-    const inlineEnv = newEnvMap();
-    let cdTarget = null;
-    let branchTarget = null;
-    let cursor = 0;
-    // Two passes catch e.g. `cd /x && VAR=v cmd`, `VAR=v cd /x && cmd`, and
-    // `cd /x && git switch main && cmd` (the last resolves fully within a
-    // single pass — cd then switch are tried back to back below — the
-    // second pass just confirms nothing more is left to consume). A third
-    // pass would only fire on a redundant prefix; bail to keep this
-    // bounded.
-    for (let pass = 0; pass < 2; pass++) {
-        const before = cursor;
-        cursor = consumeInlineEnv(command, cursor, inlineEnv);
-        if (cdTarget === null) {
-            const cd = consumeLeadingCd(command, cursor);
-            if (cd !== null) {
-                cdTarget = cd.path;
-                cursor = cd.next;
-            }
-        }
-        if (branchTarget === null) {
-            const sw = consumeLeadingGitSwitch(command, cursor);
-            if (sw !== null) {
-                branchTarget = sw.branch;
-                cursor = sw.next;
-            }
-        }
-        if (cursor === before)
-            break;
-    }
-    return { inlineEnv, cdTarget, branchTarget, remainderStart: cursor };
-}
-const WS = /\s/;
-const VAR_START = /[A-Za-z_]/;
-const VAR_CONT = /[A-Za-z0-9_]/;
-/**
- * The `inlineEnv` map. A null-prototype object, so an assignment to a
- * name that exists on `Object.prototype` is kept instead of lost:
- * `into["__proto__"] = value` on a plain `{}` runs the prototype
- * setter, which ignores a string, so `__proto__=/prod cd /x && ...`
- * used to drop the assignment without a trace. The same shape also
- * means a lookup of a name that was never assigned (`constructor`,
- * `toString`) reads as `undefined` instead of an inherited function.
- * Spreading it into a plain object (what the resolver does) creates
- * own data properties, `__proto__` included.
- */
-function newEnvMap() {
-    return Object.create(null);
-}
-/** Unquoted, unescaped characters that end a word (see `readWord` for where the old reading is kept instead). */
-const WORD_STOPS = ";&|<>()";
-/** Extra word terminators of a plain inline env value (none) and of a plain `cd` path / branch token. */
-const ENV_PLAIN_STOPS = "";
-const PATH_PLAIN_STOPS = ";&";
-/**
- * Read one shell word starting at `start`, the way bash does: a run of
- * unquoted text, backslash escapes, single-quoted parts and double-quoted
- * parts, glued together until the first unquoted, unescaped whitespace
- * (task b093911d). `'it'\''s fine'` is therefore ONE word (`it's fine`),
- * and so is `"say \"hi\""`.
- *
- *   - Outside quotes `\x` is the literal `x`; a backslash-newline pair
- *     vanishes (line continuation); a backslash that ends the string is a
- *     literal backslash (bash does the same for `bash -c 'VAR=a\'`).
- *   - In single quotes nothing is special, a backslash included.
- *   - In double quotes a backslash escapes only `"`, `\`, `$`, `` ` `` and
- *     a newline; before any other character it stays a literal backslash.
- *     `$VAR` / `$(...)` are NOT evaluated: they stay literal text (v1).
- *   - An unquoted `$'...'` (ANSI-C quoting) is NOT decoded: the raw text
- *     including its `$'` and `'` is kept, so the value is no worse than
- *     before (explicitly not covered).
- *
- * Pre-existing behaviour that is kept to limit what the new reader can
- * lose (bash itself ends a word at every unquoted shell metacharacter;
- * this is not a no-loss guarantee, see the module doc's residuals):
- *   - a word with no quote and no backslash in it is read exactly as
- *     before (`readWordLegacy`): an inline env value ends at whitespace
- *     only, so it swallows an unquoted `;`, `&`, `|`, ...; a `cd` path or
- *     branch token (`plainStops` = `;&`) ends at whitespace or `;` / `&`;
- *   - an inline env word that carries an escape or a mid-word quote but
- *     does not START with a quote (`swallowOps`) keeps swallowing the
- *     same operators, because the old reading did and a later assignment
- *     behind them (`V=\"& W=/tmp cmd`) was extracted through it. That
- *     includes `|` and `||`, so `A=a\ b|| cd /x && y` reads the `cd` like
- *     the plain `A=x|| cd /x && y` always has (a known phantom, not
- *     covered); ending the word at `||` was tried and lost honest clauses
- *     that bash runs after the short circuit;
- *   - a word that STARTS with a quote, and every `cd` / branch word, ends
- *     at an unquoted, unescaped `;`, `&`, `|`, `<`, `>`, `(` or `)`, so
- *     `A='a b'|| cd /x && y` ends the value at `||` and never reads the
- *     `cd` behind a short-circuit or a pipe as a leading one (the old
- *     reading also stopped right after the closing quote).
- *
- * Returns null when a quote has no closing quote. Never throws.
- */
-function readWord(s, start, plainStops, swallowOps) {
-    let end = start;
-    while (end < s.length && !WS.test(s[end]) && !plainStops.includes(s[end]))
-        end++;
-    if (!/['"\\]/.test(s.slice(start, end)))
-        return readWordLegacy(s, start, plainStops);
-    const swallow = swallowOps && s[start] !== "'" && s[start] !== '"';
-    const stops = swallow ? "" : WORD_STOPS;
-    let i = start;
-    let value = "";
-    let interpolates = false;
-    while (i < s.length) {
-        const c = s[i];
-        if (WS.test(c) || stops.includes(c))
-            break;
-        if (c === "'") {
-            const end = s.indexOf("'", i + 1);
-            if (end < 0)
-                return null;
-            value += s.slice(i + 1, end);
-            i = end + 1;
-        }
-        else if (c === '"') {
-            i++;
-            let closed = false;
-            while (i < s.length) {
-                const d = s[i];
-                if (d === '"') {
-                    closed = true;
-                    i++;
-                    break;
-                }
-                if (d === "\\" && i + 1 < s.length) {
-                    const e = s[i + 1];
-                    if (e === '"' || e === "\\" || e === "$" || e === "`") {
-                        value += e;
-                        i += 2;
-                        continue;
-                    }
-                    if (e === "\n") {
-                        i += 2;
-                        continue;
-                    }
-                }
-                else if (d === "$") {
-                    interpolates = true;
-                }
-                value += d;
-                i++;
-            }
-            if (!closed)
-                return null;
-        }
-        else if (c === "\\") {
-            if (i + 1 < s.length) {
-                if (s[i + 1] !== "\n")
-                    value += s[i + 1];
-                i += 2;
-            }
-            else {
-                value += c;
-                i++;
-            }
-        }
-        else if (c === "$" && s[i + 1] === "'") {
-            let j = i + 2;
-            while (j < s.length && s[j] !== "'")
-                j += s[j] === "\\" ? 2 : 1;
-            if (j >= s.length)
-                return null;
-            value += s.slice(i, j + 1);
-            i = j + 1;
-        }
-        else {
-            value += c;
-            i++;
-        }
-    }
-    return { value, next: i, interpolates };
-}
-/**
- * The reading this module used before it knew about escapes: a word that
- * opens with a quote ends at the FIRST matching quote character, any
- * other word ends at whitespace (and at any character of `plainStops`).
- * Kept as the fall-back for a word `readWord` cannot terminate, so that
- * word still yields what the old reading yielded (`VAR="abc\" cd /x && y`
- * is an unterminated string for bash, but the old reading still yields
- * `VAR` and the `cd`). Null only for a quote with no closing quote at all.
- */
-function readWordLegacy(s, start, plainStops) {
-    const first = s[start];
-    if (first === "'" || first === '"') {
-        const end = s.indexOf(first, start + 1);
-        if (end < 0)
-            return null;
-        const value = s.slice(start + 1, end);
-        return { value, next: end + 1, interpolates: first === '"' && value.includes("$") };
-    }
-    let i = start;
-    while (i < s.length && !WS.test(s[i]) && !plainStops.includes(s[i]))
-        i++;
-    return { value: s.slice(start, i), next: i, interpolates: false };
-}
-/** `readWord`, else `readWordLegacy`; null only when no reading closes the quote. */
-function readWordOrLegacy(s, start, plainStops, swallowOps) {
-    return readWord(s, start, plainStops, swallowOps) ?? readWordLegacy(s, start, plainStops);
-}
-function skipWs(s, i) {
-    while (i < s.length && WS.test(s[i]))
-        i++;
-    return i;
-}
-/**
- * Consume zero or more leading `VAR=value` tokens. Each successful
- * consumption registers into `into`. Returns the cursor position after
- * the last consumed token, or the original cursor when nothing parsed
- * (so the caller can try another prefix kind).
- *
- * On a syntactically broken token (e.g. unterminated quote) the broken
- * token is NOT consumed and the function returns the cursor at the
- * start of that token, preserving the rest of the command for fallback.
- *
- * QUOTE-MODEL DIVERGENCE, recorded so the next change here starts from
- * the known state instead of rediscovering it (task 13e55484; updated
- * by task b093911d): `command-normalize.ts`'s
- * `consumeAssignment` is a SECOND quote model for the same leading
- * `VAR=value` construction. Both now handle backslash escapes (outside
- * single quotes) and chained quote runs (`'a b'"c d"`), but they stay
- * two separate implementations (not unified), and this function
- * extracts the VALUE (which the normaliser never needs). Neither model
- * handles ANSI-C `$'...'` escapes; the normaliser side carries a
- * one-directional guard so that divergence can only fall back to its
- * pre-continuation behaviour, never swallow a gated head token.
- */
-function consumeInlineEnv(s, start, into) {
-    let i = skipWs(s, start);
-    let lastGood = i;
-    while (i < s.length) {
-        const nameStart = i;
-        if (!VAR_START.test(s[i]))
-            break;
-        i++;
-        while (i < s.length && VAR_CONT.test(s[i]))
-            i++;
-        if (s[i] !== "=")
-            break;
-        const name = s.slice(nameStart, i);
-        i++;
-        // Read the value as one shell word: unquoted text, backslash escapes
-        // and quoted parts glued together up to unescaped whitespace.
-        const word = readWordOrLegacy(s, i, ENV_PLAIN_STOPS, true);
-        if (word === null)
-            return lastGood;
-        const value = word.value;
-        i = word.next;
-        into[name] = value;
-        i = skipWs(s, i);
-        lastGood = i;
-    }
-    return lastGood;
-}
-/**
- * Consume a single leading `cd <path> [&&|;]` clause. Returns
- * `{path, next}` on success (where `next` is the cursor after the
- * separator), or null when the prefix does not match. A path that is
- * missing the trailing `&&` / `;` separator is treated as not-a-prefix
- * (the operator typed `cd <path>` and nothing else — no useful resolver
- * override).
- */
-function consumeLeadingCd(s, start) {
-    let i = skipWs(s, start);
-    // Match `cd` followed by whitespace; do NOT match `cd&&` or `cdx`.
-    if (s[i] !== "c" || s[i + 1] !== "d")
-        return null;
-    if (i + 2 >= s.length || !WS.test(s[i + 2]))
-        return null;
-    i = skipWs(s, i + 2);
-    // Path: one shell word (quotes, escapes and quote runs as in an env value).
-    const word = readWordOrLegacy(s, i, PATH_PLAIN_STOPS, false);
-    if (word === null)
-        return null;
-    const path = word.value;
-    i = word.next;
-    if (path.length === 0)
-        return null;
-    i = skipWs(s, i);
-    if (s[i] === "&" && s[i + 1] === "&") {
-        return { path, next: i + 2 };
-    }
-    if (s[i] === ";") {
-        return { path, next: i + 1 };
-    }
-    return null;
-}
-/**
- * Match a literal keyword at `i` on a word boundary — immediately
- * followed by whitespace or end-of-string, never a partial-word match
- * (`"git"` must not match inside `"github"`, `"switch"` must not match
- * inside `"switching"`). Returns the cursor just past the keyword on
- * success, or null.
- */
-function matchKeyword(s, i, word) {
-    if (s.slice(i, i + word.length) !== word)
-        return null;
-    const after = i + word.length;
-    if (after < s.length && !WS.test(s[after]))
-        return null;
-    return after;
-}
-/**
- * Skip a single path token (quoted or unquoted) starting at `i`.
- * Returns the cursor just past it, or null on an unterminated quote or
- * an empty token. Reads the token with the same `readWordOrLegacy` rules
- * `consumeLeadingCd` uses for its path; this function's only caller
- * (`consumeLeadingGitSwitch`'s `-C <path>` skip) discards the value.
- */
-function skipPathToken(s, i) {
-    const word = readWordOrLegacy(s, i, PATH_PLAIN_STOPS, false);
-    return word !== null && word.next > i ? word.next : null;
-}
-/**
- * Consume a single leading `git [-C <path>] (switch|checkout) <branch>
- * [&&|;]` clause (task 341e024b). Returns `{branch, next}` on success,
- * or null when the prefix does not match — including these deliberate
- * exclusions, which return null WITHOUT guessing a branch:
- *
- *   - A `-`-prefixed first argument after `switch`/`checkout` (`-`,
- *     `--`, `-b`, `-c`, `-C`, `--force`, ...). This specifically covers
- *     `git checkout -- <path>` (git's file-restore form — no branch is
- *     switched at all) as one case of the general rule "a flag is not a
- *     branch name", rather than special-casing `--` alone.
- *   - An unquoted `$VAR` / `${VAR}` first argument: a shell variable,
- *     not a literal branch name. Resolving it would require evaluating
- *     the shell environment, which this parser does not do (see module
- *     doc). A token that STARTS with a quote and carries an unescaped `$`
- *     in a double-quoted part is excluded the same way (double quotes
- *     interpolate in real bash); a single-quoted token is never excluded
- *     on this basis (single quotes never interpolate, so its content is
- *     always the literal branch name). A token that does not start with a
- *     quote but has such a `$` mid-word (`release/"$V"`) is NOT excluded:
- *     it is read raw (quotes kept) as before, so a glob like `release/*`
- *     and the clauses behind it still resolve.
- *   - A missing trailing `&&` / `;` separator, mirroring
- *     `consumeLeadingCd`'s identical rule: `git switch main` alone, with
- *     nothing following, has no "rest of command" for the branch
- *     candidate to apply to.
- *
- * The branch token is read as ONE shell word, with the same rules as a
- * `cd` path (`readWordOrLegacy`, ended at whitespace / `;` / `&`): an
- * unquoted slashed name like `task/foo` or `release/1.2`, a quoted
- * literal with its quotes stripped (task 341e024b: a quote character
- * left inside the token would never match a plain `branch_patterns`
- * entry), and, since task b093911d, backslash escapes
- * and chained quote runs (`'it'\''s'`, `"ma\"in"`, `feat\ x`).
- *
- * The optional leading `-C <path>` is recognized so it does not block
- * the match, but its value is discarded — see the module doc's form 3
- * for why only the branch name matters to the caller.
- */
-function consumeLeadingGitSwitch(s, start) {
-    let i = skipWs(s, start);
-    const afterGit = matchKeyword(s, i, "git");
-    if (afterGit === null)
-        return null;
-    i = skipWs(s, afterGit);
-    const afterDashC = matchKeyword(s, i, "-C");
-    if (afterDashC !== null) {
-        i = skipWs(s, afterDashC);
-        const skipped = skipPathToken(s, i);
-        if (skipped === null)
-            return null;
-        i = skipWs(s, skipped);
-    }
-    let afterVerb = matchKeyword(s, i, "switch");
-    if (afterVerb === null)
-        afterVerb = matchKeyword(s, i, "checkout");
-    if (afterVerb === null)
-        return null;
-    i = skipWs(s, afterVerb);
-    if (i >= s.length)
-        return null;
-    // A `-`-prefixed or unquoted `$`-prefixed first argument is not a
-    // plain branch name — do not guess (see doc comment above).
-    if (s[i] === "-" || s[i] === "$")
-        return null;
-    // One shell word, quotes and escapes decoded like a `cd` path (task
-    // 341e024b for the quote stripping, task b093911d for the escapes). A word with an UNESCAPED `$` inside double quotes is left
-    // unresolved (real bash interpolates there; this parser does not
-    // evaluate the shell environment); a single-quoted `$` and an escaped
-    // `\$` are literal and kept.
-    let word = readWordOrLegacy(s, i, PATH_PLAIN_STOPS, false);
-    // A word that does NOT start with a quote but carries a `$` in a
-    // double-quoted part (`release/"$V"`): bash expands it, so the branch
-    // is unknown, but the pre-change reading kept the raw word (quotes
-    // included, which still matches a glob such as `release/*`) and went on
-    // to the clauses behind it (a later `cd`, the kubectl remainder). Fall
-    // back to that reading instead of dropping them. A word that starts
-    // with a double quote stays unresolved: the pre-change reading did the
-    // same. One that starts with a single quote cannot be saved either: the
-    // old reading ends it at the first closing quote, and a `$` part glued
-    // behind it means the next character is neither whitespace nor `;` / `&`.
-    if (word !== null && word.interpolates && s[i] !== '"') {
-        word = readWordLegacy(s, i, PATH_PLAIN_STOPS);
-    }
-    if (word === null || word.interpolates)
-        return null;
-    const branch = word.value;
-    if (branch.length === 0)
-        return null;
-    i = word.next;
-    i = skipWs(s, i);
-    if (s[i] === "&" && s[i + 1] === "&") {
-        return { branch, next: i + 2 };
-    }
-    if (s[i] === ";") {
-        return { branch, next: i + 1 };
-    }
-    return null;
-}
-//# sourceMappingURL=bash-prefix-parse.js.map

package/dist/runtime/bash-prefix-parse.js.map

@@ -1 +0,0 @@
-{"version":3,"file":"bash-prefix-parse.js","sourceRoot":"","sources":["../../src/runtime/bash-prefix-parse.ts"],"names":[],"mappings":"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"}