@indigoai-us/hq-cli 5.314.0 → 5.316.0

package/dist/lib/lanes/merge-command.js

@@ -0,0 +1,629 @@
+import * as path from "node:path";
+import { LanesError } from "./errors.js";
+const MAX_COMMAND_WRAPPER_DEPTH = 4;
+function fail(error, message, details = {}) {
+    throw new LanesError(error, message, details);
+}
+export function canonicalRepo(raw) {
+    const value = raw.trim();
+    const parts = value.split("/");
+    if (parts.length !== 2) {
+        return fail("repo_hold_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    const [owner, repository] = parts;
+    if (!owner || !repository ||
+        !/^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/.test(owner) ||
+        !/^[A-Za-z0-9][A-Za-z0-9._-]{0,99}$/.test(repository) ||
+        owner === "." || owner === ".." || repository === "." || repository === "..") {
+        return fail("repo_hold_repo_invalid", "Repository must be a safe owner/repo pair", { field: "repo" });
+    }
+    return `${owner.toLowerCase()}/${repository.toLowerCase()}`;
+}
+function splitCommandChain(command) {
+    const segments = [];
+    let current = "";
+    let quote = null;
+    let escaped = false;
+    for (let index = 0; index < command.length; index += 1) {
+        const character = command[index] ?? "";
+        if (escaped) {
+            current += character;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            current += character;
+            escaped = true;
+            continue;
+        }
+        if (quote) {
+            current += character;
+            if (character === quote)
+                quote = null;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            current += character;
+            continue;
+        }
+        if (character === ";" || character === "|" || character === "\n" || character === "\r") {
+            segments.push(current.trim());
+            current = "";
+            if (character === "|" && command[index + 1] === "|")
+                index += 1;
+            if (character === "\r" && command[index + 1] === "\n")
+                index += 1;
+            continue;
+        }
+        if (character === "&" && command[index + 1] === "&") {
+            segments.push(current.trim());
+            current = "";
+            index += 1;
+            continue;
+        }
+        current += character;
+    }
+    if (quote !== null || escaped) {
+        return fail("repo_hold_command_invalid", "Command has an unclosed quote or escape");
+    }
+    segments.push(current.trim());
+    return segments.filter(Boolean);
+}
+function shellWords(segment) {
+    const words = [];
+    let current = "";
+    let wordStarted = false;
+    let quote = null;
+    let escaped = false;
+    const finishWord = () => {
+        if (!wordStarted)
+            return;
+        words.push(current);
+        current = "";
+        wordStarted = false;
+    };
+    for (const character of segment) {
+        if (escaped) {
+            current += character;
+            wordStarted = true;
+            escaped = false;
+            continue;
+        }
+        if (character === "\\" && quote !== "'") {
+            escaped = true;
+            wordStarted = true;
+            continue;
+        }
+        if (quote) {
+            if (character === quote)
+                quote = null;
+            else
+                current += character;
+            wordStarted = true;
+            continue;
+        }
+        if (character === "'" || character === "\"") {
+            quote = character;
+            wordStarted = true;
+            continue;
+        }
+        if (/\s/.test(character)) {
+            finishWord();
+            continue;
+        }
+        current += character;
+        wordStarted = true;
+    }
+    if (quote !== null || escaped)
+        return fail("repo_hold_command_invalid", "Command has an unclosed quote or escape");
+    finishWord();
+    return words;
+}
+function optionRepo(words) {
+    for (let index = 0; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if ((word === "-R" || word === "--repo") && words[index + 1])
+            return words[index + 1] ?? null;
+        if (word.startsWith("--repo="))
+            return word.slice("--repo=".length);
+        if (word.startsWith("-R") && word.length > 2)
+            return word.slice(2);
+    }
+    return null;
+}
+function ghPrSubcommand(words) {
+    const groupIndex = words.indexOf("pr", 1);
+    if (groupIndex < 0)
+        return null;
+    for (let index = groupIndex + 1; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "-R" || word === "--repo" || word === "--hostname") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--repo=") || (word.startsWith("-R") && word.length > 2))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        return { subcommandIndex: index, subcommand: word };
+    }
+    return { subcommandIndex: words.length, subcommand: null };
+}
+const SHELL_ASSIGNMENT = /^[A-Za-z_][A-Za-z0-9_]*=/;
+const PR_MERGE_VALUE_OPTIONS = new Set([
+    "-A", "--author-email", "-b", "--body", "-F", "--body-file",
+    "--match-head-commit", "-t", "--subject",
+]);
+function skipEnvOptions(words, start) {
+    let index = start + 1;
+    while (index < words.length) {
+        const word = words[index] ?? "";
+        if (SHELL_ASSIGNMENT.test(word)) {
+            index += 1;
+            continue;
+        }
+        if (word === "-i" || word === "--ignore-environment") {
+            index += 1;
+            continue;
+        }
+        if (word === "-u" || word === "--unset" || word === "-C" || word === "--chdir") {
+            index += 2;
+            continue;
+        }
+        if (word.startsWith("--unset=") || word.startsWith("--chdir=")) {
+            index += 1;
+            continue;
+        }
+        if (word === "--")
+            return index + 1;
+        if (word.startsWith("-"))
+            return -1;
+        break;
+    }
+    return index;
+}
+function skipTimeoutOptions(words, start) {
+    let index = start + 1;
+    while (index < words.length) {
+        const word = words[index] ?? "";
+        if (word === "--") {
+            index += 1;
+            break;
+        }
+        if (word === "-k" || word === "--kill-after" || word === "-s" || word === "--signal") {
+            index += 2;
+            continue;
+        }
+        if (word.startsWith("--kill-after=") || word.startsWith("--signal=")) {
+            index += 1;
+            continue;
+        }
+        if (word === "--preserve-status" || word === "--foreground" || word === "--verbose" || word === "-v") {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("-"))
+            return -1;
+        break;
+    }
+    const duration = words[index];
+    if (!duration || !/^(?:\d+(?:\.\d*)?|\.\d+)(?:s|m|h|d)?$/.test(duration))
+        return -1;
+    index += 1;
+    if (words[index] === "--")
+        index += 1;
+    return index < words.length ? index : -1;
+}
+const SHELL_SHORT_OPTIONS = new Set(["a", "b", "B", "C", "e", "E", "f", "h", "H", "i", "k", "l", "m", "n", "p", "P", "r", "s", "t", "T", "u", "v", "x"]);
+const SHELL_LONG_OPTIONS = new Set([
+    "--interactive", "--login", "--noprofile", "--norc", "--posix", "--restricted",
+    "--verbose", "--noediting", "--debugger",
+]);
+const SHELL_LONG_VALUE_OPTIONS = new Set(["--rcfile", "--init-file", "--emulate"]);
+function shellCommandWrapper(words) {
+    let index = 1;
+    while (index < words.length) {
+        const option = words[index] ?? "";
+        if (option === "--")
+            return null;
+        if (SHELL_LONG_VALUE_OPTIONS.has(option)) {
+            if (!words[index + 1])
+                return { kind: "invalid" };
+            index += 2;
+            continue;
+        }
+        if ([...SHELL_LONG_VALUE_OPTIONS].some((name) => option.startsWith(`${name}=`))) {
+            index += 1;
+            continue;
+        }
+        if (SHELL_LONG_OPTIONS.has(option)) {
+            index += 1;
+            continue;
+        }
+        if (option.startsWith("--"))
+            return { kind: "invalid" };
+        if ((option.startsWith("-") || option.startsWith("+")) && option.length > 1) {
+            const flags = option.slice(1);
+            let consumedOptionValue = false;
+            for (let flagIndex = 0; flagIndex < flags.length; flagIndex += 1) {
+                const flag = flags[flagIndex] ?? "";
+                if (flag === "c") {
+                    const script = words[index + 1];
+                    return script === undefined ? { kind: "invalid" } : { kind: "script", script };
+                }
+                if (flag === "o" || flag === "O") {
+                    if (flagIndex + 1 < flags.length) {
+                        index += 1;
+                        consumedOptionValue = true;
+                        break;
+                    }
+                    if (!words[index + 1])
+                        return { kind: "invalid" };
+                    index += 2;
+                    consumedOptionValue = true;
+                    break;
+                }
+                if (!SHELL_SHORT_OPTIONS.has(flag))
+                    return { kind: "invalid" };
+            }
+            if (!consumedOptionValue)
+                index += 1;
+            continue;
+        }
+        return null;
+    }
+    return null;
+}
+function commandWrapper(words) {
+    const command = path.basename(words[0] ?? "").toLowerCase();
+    if (["bash", "sh", "zsh"].includes(command))
+        return shellCommandWrapper(words);
+    if (command === "sudo") {
+        let index = 1;
+        while (index < words.length) {
+            const option = words[index] ?? "";
+            if (option === "--") {
+                index += 1;
+                break;
+            }
+            if (option === "-u" || option === "--user") {
+                if (!words[index + 1])
+                    return { kind: "invalid" };
+                index += 2;
+                continue;
+            }
+            if (option.startsWith("--user=") || /^-u.+/.test(option)) {
+                index += 1;
+                continue;
+            }
+            if (["-A", "-b", "-E", "-H", "-K", "-k", "-n", "-P", "-S", "-V", "--askpass", "--background", "--preserve-env", "--set-home", "--remove-timestamp", "--reset-timestamp", "--non-interactive", "--preserve-groups", "--stdin", "--version"].includes(option)) {
+                index += 1;
+                continue;
+            }
+            if (option.startsWith("-"))
+                return { kind: "invalid" };
+            break;
+        }
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "command") {
+        let index = 1;
+        while (words[index] === "-p")
+            index += 1;
+        if (words[index] === "--")
+            index += 1;
+        if (words[index]?.startsWith("-"))
+            return { kind: "invalid" };
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "env") {
+        const index = skipEnvOptions(words, 0);
+        if (index < 0)
+            return { kind: "invalid" };
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "timeout") {
+        const index = skipTimeoutOptions(words, 0);
+        return index >= 0 ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "nice") {
+        let index = 1;
+        while (index < words.length) {
+            const option = words[index] ?? "";
+            if (option === "--") {
+                index += 1;
+                break;
+            }
+            if (option === "-n" || option === "--adjustment") {
+                if (!/^-?\d+$/.test(words[index + 1] ?? ""))
+                    return { kind: "invalid" };
+                index += 2;
+                continue;
+            }
+            if (/^--adjustment=-?\d+$/.test(option) || /^-\d+$/.test(option)) {
+                index += 1;
+                continue;
+            }
+            if (option.startsWith("-"))
+                return { kind: "invalid" };
+            break;
+        }
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    if (command === "nohup") {
+        const index = words[1] === "--" ? 2 : 1;
+        return index < words.length ? { kind: "words", words: words.slice(index) } : { kind: "invalid" };
+    }
+    return null;
+}
+function containsMergeCandidate(command) {
+    // This lossy scan only decides whether malformed input resembles a merge;
+    // the parser never uses it to recover a command or target.
+    const words = command.replace(/["'`\\]/g, " ").match(/\S+/g) ?? [];
+    const valueOptions = new Set([
+        "-R", "--repo", "--hostname", "--config", "--cache", "--jq", "--template",
+        "--preview", "--http-unix-socket", "--git-protocol",
+    ]);
+    for (let index = 0; index < words.length; index += 1) {
+        if (words[index]?.toLowerCase() !== "gh")
+            continue;
+        let subcommandIndex = index + 1;
+        while (subcommandIndex < words.length) {
+            const word = words[subcommandIndex] ?? "";
+            if (word === "--")
+                break;
+            if (valueOptions.has(word)) {
+                if (subcommandIndex + 1 >= words.length)
+                    break;
+                subcommandIndex += 2;
+                continue;
+            }
+            if (word.startsWith("--repo=") || word.startsWith("--hostname=") || /^-R.+/.test(word)) {
+                subcommandIndex += 1;
+                continue;
+            }
+            if (word.startsWith("-")) {
+                subcommandIndex += 1;
+                continue;
+            }
+            break;
+        }
+        const subcommand = words[subcommandIndex];
+        if (subcommand === "pr") {
+            let actionIndex = subcommandIndex + 1;
+            while (actionIndex < words.length) {
+                const word = words[actionIndex] ?? "";
+                if (word === "--")
+                    break;
+                if (valueOptions.has(word)) {
+                    if (actionIndex + 1 >= words.length)
+                        break;
+                    actionIndex += 2;
+                    continue;
+                }
+                if (word.startsWith("--repo=") || word.startsWith("--hostname=") || /^-R.+/.test(word)) {
+                    actionIndex += 1;
+                    continue;
+                }
+                if (word.startsWith("-")) {
+                    actionIndex += 1;
+                    continue;
+                }
+                break;
+            }
+            if (words[actionIndex] === "merge")
+                return true;
+        }
+        if (subcommand === "api" && words.slice(subcommandIndex + 1).some((word) => /\/merge\b/i.test(word) || /\bmergePullRequest\b/i.test(word))) {
+            return true;
+        }
+    }
+    return false;
+}
+function parsePullUrl(raw) {
+    if (!/^https?:\/\//i.test(raw))
+        return null;
+    let url;
+    try {
+        url = new URL(raw);
+    }
+    catch {
+        return null;
+    }
+    const match = /^\/([^/]+)\/([^/]+)\/pull\/(\d+)\/?$/.exec(url.pathname);
+    if (!match)
+        return null;
+    try {
+        const pr = Number(match[3]);
+        if (!Number.isSafeInteger(pr) || pr <= 0)
+            return null;
+        return { repo: canonicalRepo(`${decodeURIComponent(match[1] ?? "")}/${decodeURIComponent(match[2] ?? "")}`), pr };
+    }
+    catch (error) {
+        if (error instanceof LanesError && error.error === "repo_hold_repo_invalid") {
+            return fail("repo_hold_repo_invalid", "Pull request URL has an invalid repository", { field: "repo" });
+        }
+        throw error;
+    }
+}
+function pinnedHead(words, start = 0) {
+    for (let index = start; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (word === "--match-head-commit")
+            return words[index + 1]?.trim().toLowerCase() || null;
+        if (word.startsWith("--match-head-commit="))
+            return word.slice("--match-head-commit=".length).trim().toLowerCase() || null;
+        if (word === "-f" || word === "-F" || word === "--field" || word === "--raw-field") {
+            const value = words[index + 1] ?? "";
+            if (value.startsWith("sha="))
+                return value.slice(4).trim().toLowerCase() || null;
+            index += 1;
+            continue;
+        }
+        for (const prefix of ["-fsha=", "-Fsha=", "--field=sha=", "--raw-field=sha="]) {
+            if (word.startsWith(prefix))
+                return word.slice(prefix.length).trim().toLowerCase() || null;
+        }
+    }
+    return null;
+}
+function prMergeTarget(words, subcommandIndex) {
+    const rawRepo = optionRepo(words);
+    let rawNumber = null;
+    let urlTarget = null;
+    const start = subcommandIndex + 1;
+    for (let index = start; index < words.length; index += 1) {
+        const word = words[index] ?? "";
+        if (PR_MERGE_VALUE_OPTIONS.has(word)) {
+            index += 1;
+            continue;
+        }
+        if (["-R", "--repo", "--hostname"].includes(word)) {
+            index += 1;
+            continue;
+        }
+        if (word.startsWith("--repo=") || (word.startsWith("-R") && word.length > 2) || word.startsWith("--match-head-commit="))
+            continue;
+        if (word.startsWith("-"))
+            continue;
+        urlTarget = parsePullUrl(word);
+        if (urlTarget)
+            break;
+        rawNumber = word;
+        break;
+    }
+    const repo = rawRepo ? canonicalRepo(rawRepo) : urlTarget?.repo ?? null;
+    const pr = urlTarget?.pr ?? (rawNumber && /^\d+$/.test(rawNumber) && Number.isSafeInteger(Number(rawNumber)) && Number(rawNumber) > 0
+        ? Number(rawNumber)
+        : null);
+    const reason = repo === null
+        ? "repository could not be resolved without a pull request URL or --repo"
+        : pr === null
+            ? "pull request number could not be resolved"
+            : null;
+    return { kind: "pr", repo, pr, pinnedHead: pinnedHead(words, start), unresolvedReason: reason };
+}
+function apiMergeTarget(words, apiIndex) {
+    const rest = words.slice(apiIndex + 1);
+    const graphql = rest.includes("graphql");
+    if (graphql && rest.some((word) => word.includes("mergePullRequest"))) {
+        return {
+            kind: "graphql",
+            repo: null,
+            pr: null,
+            pinnedHead: pinnedHead(rest),
+            unresolvedReason: "GraphQL mergePullRequest identifies a node id, not a pull request number",
+        };
+    }
+    for (const word of rest) {
+        const match = /^(?:https?:\/\/api\.github\.com)?\/?repos\/([^/]+)\/([^/]+)\/pulls\/(\d+)\/merge\/?$/.exec(word);
+        if (!match)
+            continue;
+        const pr = Number(match[3]);
+        if (!Number.isSafeInteger(pr) || pr <= 0)
+            break;
+        return {
+            kind: "api",
+            repo: canonicalRepo(`${match[1]}/${match[2]}`),
+            pr,
+            pinnedHead: pinnedHead(rest),
+            unresolvedReason: null,
+        };
+    }
+    return null;
+}
+function parseSegmentWords(words) {
+    if (words[0] === "git" && words.slice(1).includes("merge")) {
+        return {
+            kind: "git",
+            repo: null,
+            pr: null,
+            pinnedHead: null,
+            unresolvedReason: "git merge does not identify a pull request",
+        };
+    }
+    if (words[0] !== "gh")
+        return null;
+    const pr = ghPrSubcommand(words);
+    if (pr?.subcommand === "merge")
+        return prMergeTarget(words, pr.subcommandIndex);
+    const apiIndex = words.indexOf("api", 1);
+    if (apiIndex < 0)
+        return null;
+    return apiMergeTarget(words, apiIndex);
+}
+function unparseableMergeTarget() {
+    return {
+        kind: "pr",
+        repo: null,
+        pr: null,
+        pinnedHead: null,
+        unresolvedReason: "merge command could not be parsed safely",
+    };
+}
+function recordUnparseableMerge(state) {
+    state.unparseableMerge = true;
+    state.targets.push(unparseableMergeTarget());
+}
+function parseCommandWords(words, source, depth, state) {
+    let commandWords = words;
+    while (SHELL_ASSIGNMENT.test(commandWords[0] ?? ""))
+        commandWords = commandWords.slice(1);
+    if (commandWords.length === 0)
+        return;
+    const wrapper = commandWrapper(commandWords);
+    if (wrapper) {
+        if (wrapper.kind === "invalid" || depth >= MAX_COMMAND_WRAPPER_DEPTH) {
+            if (containsMergeCandidate(source))
+                recordUnparseableMerge(state);
+            return;
+        }
+        if (wrapper.kind === "script") {
+            parseCommandList(wrapper.script, depth + 1, state);
+            return;
+        }
+        parseCommandWords(wrapper.words, source, depth + 1, state);
+        return;
+    }
+    const target = parseSegmentWords(commandWords);
+    if (target)
+        state.targets.push(target);
+}
+function parseCommandList(command, depth, state) {
+    let segments;
+    try {
+        segments = splitCommandChain(command);
+    }
+    catch (error) {
+        if (error instanceof LanesError && error.error === "repo_hold_command_invalid" && containsMergeCandidate(command)) {
+            recordUnparseableMerge(state);
+            return;
+        }
+        throw error;
+    }
+    for (const segment of segments) {
+        let words;
+        try {
+            words = shellWords(segment);
+        }
+        catch (error) {
+            if (error instanceof LanesError && error.error === "repo_hold_command_invalid" && containsMergeCandidate(segment)) {
+                recordUnparseableMerge(state);
+                continue;
+            }
+            throw error;
+        }
+        parseCommandWords(words, segment, depth, state);
+    }
+}
+export function parseMergeCommands(command) {
+    const state = { targets: [], unparseableMerge: false };
+    parseCommandList(command, 0, state);
+    return {
+        targets: state.targets,
+        unresolved: state.targets.some((target) => target.unresolvedReason !== null),
+        unparseableMerge: state.unparseableMerge,
+    };
+}
+//# sourceMappingURL=merge-command.js.map