@sema-agent/core 7.17.7 → 7.19.0

package/dist/tools/fs/bash-lexer.js

@@ -0,0 +1,563 @@
+export const SUBSTITUTION_PLACEHOLDER = " subst";
+function quoteStep(open, ch) {
+    if (open === undefined)
+        return ch === '"' || ch === "'" ? ch : undefined;
+    return open === ch ? undefined : open;
+}
+export function quoteMask(s) {
+    const quoted = new Array(s.length).fill(false);
+    let open;
+    for (let i = 0; i < s.length; i++) {
+        const before = open;
+        open = quoteStep(open, s[i]);
+        quoted[i] = before !== undefined || open !== undefined;
+    }
+    return { quoted, balanced: open === undefined };
+}
+export function literalTildeSpelling(word) {
+    return word.startsWith("~") ? `./${word}` : word;
+}
+function tildeIsLiteral(raw) {
+    if (!raw.startsWith("~"))
+        return true;
+    for (let i = 1; i < raw.length; i++) {
+        const ch = raw[i];
+        if (ch === '"' || ch === "'")
+            return true;
+        if (ch === "/")
+            return false;
+    }
+    return false;
+}
+export function wordsOf(segment) {
+    const folded = [];
+    const raw = [];
+    for (const t of segment.tokens) {
+        if (t.kind !== "word")
+            continue;
+        folded.push(t.folded);
+        raw.push(t.raw);
+    }
+    return { folded, raw };
+}
+function past(text, j) {
+    let k = j;
+    while (text[k] === "\\" && text[k + 1] === "\n")
+        k += 2;
+    return k;
+}
+function parenBodyEnd(text, open) {
+    let depth = 0;
+    let quoted;
+    let wordStart = true;
+    let word = "";
+    for (let j = open; j < text.length; j++) {
+        const c = text[j];
+        if (quoted !== undefined) {
+            if (c === "\\" && quoted === '"')
+                j++;
+            else if (c === quoted)
+                quoted = undefined;
+            wordStart = false;
+            continue;
+        }
+        if (c === "\\") {
+            if (text[j + 1] === "\n") {
+                j++;
+                continue;
+            }
+            j++;
+            wordStart = false;
+            word = "";
+            continue;
+        }
+        if (c === "#" && wordStart) {
+            const nl = text.indexOf("\n", j);
+            if (nl < 0)
+                return undefined;
+            j = nl;
+            wordStart = true;
+            word = "";
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            quoted = c;
+            wordStart = false;
+            word = "";
+            continue;
+        }
+        if (c === "$" && text[past(text, j + 1)] === "{") {
+            const open2 = past(text, j + 1);
+            const close = braceExpansionEnd(text, open2);
+            if (close === undefined)
+                return undefined;
+            if (UNREADABLE_EXPANSION_TEXT.test(text.slice(open2 + 1, close - 1)))
+                return "unreadable";
+            j = close - 1;
+            wordStart = false;
+            word = "";
+            continue;
+        }
+        if (c === "<" && text[past(text, j + 1)] === "<" && text[past(text, past(text, j + 1) + 1)] !== "<")
+            return "unreadable";
+        if (c === "(")
+            depth++;
+        else if (c === ")") {
+            depth--;
+            if (depth === 0)
+                return j + 1;
+        }
+        const boundary = /[\s;|&()]/.test(c);
+        if (boundary && word === "case")
+            return "unreadable";
+        word = boundary ? "" : word + c;
+        wordStart = boundary;
+    }
+    return undefined;
+}
+function braceExpansionEnd(text, open) {
+    let quoted;
+    for (let j = open + 1; j < text.length; j++) {
+        const c = text[j];
+        if (quoted !== undefined) {
+            if (c === "\\" && quoted === '"')
+                j++;
+            else if (c === quoted)
+                quoted = undefined;
+            continue;
+        }
+        if (c === "\\") {
+            j++;
+            continue;
+        }
+        if (c === "'" || c === '"') {
+            quoted = c;
+            continue;
+        }
+        if (c === "}")
+            return j + 1;
+    }
+    return undefined;
+}
+const UNREADABLE_EXPANSION_TEXT = /[$`()<>{\\]/;
+function backtickBody(source, open) {
+    let body = "";
+    for (let j = open + 1; j < source.length; j++) {
+        const c = source[j];
+        if (c === "\\" && j + 1 < source.length) {
+            const next = source[j + 1];
+            if (next === "\n") {
+                j++;
+                continue;
+            }
+            body += next === "$" || next === "`" || next === "\\" ? next : c + next;
+            j++;
+            continue;
+        }
+        if (c === "`")
+            return { body, close: j };
+        body += c;
+    }
+    return undefined;
+}
+export function substitutionsInHeredocBody(body) {
+    const out = [];
+    for (let i = 0; i < body.length; i++) {
+        const ch = body[i];
+        if (ch === "\\") {
+            i++;
+            continue;
+        }
+        if (ch === "`") {
+            const tick = backtickBody(body, i);
+            if (tick === undefined)
+                return undefined;
+            out.push(tick.body);
+            i = tick.close;
+            continue;
+        }
+        if (ch === "$" && body[i + 1] === "(") {
+            const end = parenBodyEnd(body, i + 1);
+            if (typeof end !== "number")
+                return undefined;
+            out.push(body.slice(i + 2, end - 1));
+            i = end - 1;
+        }
+    }
+    return out;
+}
+const UNDELIMITED_SUBSTITUTION = "a command substitution carries a construct this lexer cannot delimit";
+const WHITESPACE = /\s/;
+const BLANK = /[ \t]/;
+const UNTERMINATED_HEREDOC = "a here-document body never terminates";
+function scan(source, opts, quotesLiteral) {
+    const lenient = opts.mode === "lenient";
+    const split = opts.connectors !== "text";
+    const segments = [{ start: 0, end: source.length, connector: "start", tokens: [], substitutions: [] }];
+    const current = () => segments[segments.length - 1];
+    const pendingHeredocs = [];
+    let pendingRedirect;
+    let pendingHeredoc;
+    let inSingle = false;
+    let inDouble = false;
+    let raw = "";
+    let folded = "";
+    let started = false;
+    let foldOpen;
+    const next = (j) => (lenient ? past(source, j + 1) : j + 1);
+    const foldChar = (ch) => {
+        if (ch === '"' || ch === "'") {
+            if (foldOpen === undefined) {
+                foldOpen = ch;
+                return;
+            }
+            if (foldOpen === ch) {
+                foldOpen = undefined;
+                return;
+            }
+        }
+        folded += ch;
+    };
+    const take = (ch) => { raw += ch; foldChar(ch); started = true; };
+    const endWord = () => {
+        if (!started)
+            return undefined;
+        const word = { raw, folded, tilde: tildeIsLiteral(raw) ? literalTildeSpelling(folded) : folded };
+        raw = "";
+        folded = "";
+        started = false;
+        foldOpen = undefined;
+        if (pendingHeredoc !== undefined) {
+            const header = pendingHeredoc;
+            pendingHeredoc = undefined;
+            if (word.folded === "" || /[$`]/.test(word.raw))
+                return "a here-document delimiter is not a plain word";
+            const token = { kind: "heredoc", delimiter: word.folded, quoted: /["'\\]/.test(word.raw), body: "" };
+            current().tokens.push(token);
+            pendingHeredocs.push({ delimiter: word.folded, quoted: token.quoted, dash: header.dash, token });
+            return undefined;
+        }
+        if (pendingRedirect !== undefined) {
+            const op = pendingRedirect;
+            pendingRedirect = undefined;
+            if (op === ">&" || op === "<&") {
+                if (word.raw === word.folded && /^(?:\d+-?|-)$/.test(word.folded)) {
+                    current().tokens.push({ kind: "redirect", op });
+                    return undefined;
+                }
+                current().tokens.push({ kind: "redirect", op: op === ">&" ? "&>" : "<", target: { kind: "word", raw: word.raw, folded: word.tilde } });
+                return undefined;
+            }
+            current().tokens.push({ kind: "redirect", op, target: { kind: "word", raw: word.raw, folded: word.tilde } });
+            return undefined;
+        }
+        current().tokens.push({ kind: "word", raw: word.raw, folded: word.tilde });
+        return undefined;
+    };
+    const operandOwed = () => pendingRedirect !== undefined ? "a redirection names no target" : pendingHeredoc !== undefined ? "a here-document operator names no delimiter" : undefined;
+    const closeSegment = (connector, at, from) => {
+        const refusal = endWord() ?? operandOwed();
+        if (refusal !== undefined)
+            return refusal;
+        current().end = at;
+        segments.push({ start: from, end: source.length, connector, tokens: [], substitutions: [] });
+        return undefined;
+    };
+    const substitution = (from, to, body) => {
+        raw += source.slice(from, to);
+        folded += SUBSTITUTION_PLACEHOLDER;
+        started = true;
+        current().substitutions.push(body);
+    };
+    const readHeredocBodies = (from) => {
+        let p = from;
+        for (const h of pendingHeredocs) {
+            const lines = [];
+            for (;;) {
+                if (p > source.length)
+                    return { reject: UNTERMINATED_HEREDOC };
+                let nl = source.indexOf("\n", p);
+                let line = nl < 0 ? source.slice(p) : source.slice(p, nl);
+                if (!h.quoted) {
+                    while (nl >= 0 && /(?<!\\)(?:\\\\)*\\$/.test(line)) {
+                        const after = source.indexOf("\n", nl + 1);
+                        line = line.slice(0, -1) + (after < 0 ? source.slice(nl + 1) : source.slice(nl + 1, after));
+                        nl = after;
+                    }
+                }
+                if ((h.dash ? line.replace(/^\t+/, "") : line) === h.delimiter) {
+                    p = nl < 0 ? source.length + 1 : nl + 1;
+                    break;
+                }
+                if (nl < 0)
+                    return { reject: UNTERMINATED_HEREDOC };
+                lines.push(line);
+                p = nl + 1;
+            }
+            h.token.body = lines.join("\n");
+        }
+        pendingHeredocs.length = 0;
+        return Math.min(p, source.length);
+    };
+    for (let i = 0; i < source.length; i++) {
+        if (lenient && !inSingle) {
+            const j = past(source, i);
+            if (j >= source.length)
+                break;
+            i = j;
+        }
+        const ch = source[i];
+        if (!quotesLiteral) {
+            if (ch === "'" && !inDouble) {
+                inSingle = !inSingle;
+                take(ch);
+                continue;
+            }
+            if (ch === '"' && !inSingle) {
+                inDouble = !inDouble;
+                take(ch);
+                continue;
+            }
+        }
+        if (inSingle) {
+            take(ch);
+            continue;
+        }
+        if (lenient) {
+            const n1 = next(i);
+            if (ch === "\\") {
+                const escaped = source[i + 1];
+                if (escaped === undefined) {
+                    take(ch);
+                    continue;
+                }
+                raw += ch + escaped;
+                folded += inDouble && !"$`\"\\".includes(escaped) ? ch + escaped : escaped;
+                started = true;
+                i++;
+                continue;
+            }
+            if (ch === "`") {
+                const tick = backtickBody(source, i);
+                if (tick === undefined)
+                    return { reject: "a command substitution never terminates" };
+                substitution(i, tick.close + 1, tick.body);
+                i = tick.close;
+                continue;
+            }
+            if (ch === "$" && source[n1] === "(") {
+                const end = parenBodyEnd(source, n1);
+                if (end === undefined)
+                    return { reject: "a command substitution never terminates" };
+                if (end === "unreadable")
+                    return { reject: UNDELIMITED_SUBSTITUTION };
+                substitution(i, end, source.slice(n1 + 1, end - 1));
+                i = end - 1;
+                continue;
+            }
+            if (ch === "$" && source[n1] === "{") {
+                const end = braceExpansionEnd(source, n1);
+                if (end === undefined)
+                    return { reject: "a parameter expansion never terminates" };
+                if (UNREADABLE_EXPANSION_TEXT.test(source.slice(n1 + 1, end - 1)))
+                    return { reject: "a parameter expansion carries text this lexer does not read" };
+                const text = source.slice(i, end);
+                raw += text;
+                folded += text;
+                started = true;
+                i = end - 1;
+                continue;
+            }
+            if (inDouble) {
+                take(ch);
+                continue;
+            }
+            if ((ch === "<" || ch === ">") && source[n1] === "(") {
+                const end = parenBodyEnd(source, n1);
+                if (end === undefined)
+                    return { reject: "a process substitution never terminates" };
+                if (end === "unreadable")
+                    return { reject: UNDELIMITED_SUBSTITUTION };
+                substitution(i, end, source.slice(n1 + 1, end - 1));
+                i = end - 1;
+                continue;
+            }
+            if (ch === "#" && !started) {
+                const nl = source.indexOf("\n", i);
+                i = nl < 0 ? source.length : nl - 1;
+                continue;
+            }
+            if (ch === "\n") {
+                if (!split) {
+                    const r = endWord();
+                    if (r !== undefined)
+                        return { reject: r };
+                    continue;
+                }
+                const refusal = closeSegment("\n", i, i + 1);
+                if (refusal !== undefined)
+                    return { reject: refusal };
+                if (pendingHeredocs.length > 0) {
+                    const resume = readHeredocBodies(i + 1);
+                    if (typeof resume !== "number")
+                        return resume;
+                    current().start = resume;
+                    i = resume - 1;
+                }
+                continue;
+            }
+            if (ch === "(" || ch === ")") {
+                const r = endWord() ?? operandOwed();
+                if (r !== undefined)
+                    return { reject: r };
+                current().tokens.push({ kind: "group", op: ch });
+                continue;
+            }
+            if (ch === "<" || ch === ">" || (ch === "&" && source[n1] === ">")) {
+                if (ch !== "&" && started && raw === folded && /^\d+$/.test(raw)) {
+                    raw = "";
+                    folded = "";
+                    started = false;
+                }
+                else {
+                    const r = endWord() ?? operandOwed();
+                    if (r !== undefined)
+                        return { reject: r };
+                }
+                const n2 = next(n1);
+                if (ch === "&") {
+                    if (source[n2] === ">") {
+                        pendingRedirect = "&>>";
+                        i = n2;
+                    }
+                    else {
+                        pendingRedirect = "&>";
+                        i = n1;
+                    }
+                    continue;
+                }
+                if (ch === "<" && source[n1] === "<") {
+                    if (source[n2] === "<") {
+                        pendingRedirect = "<<<";
+                        i = n2;
+                        continue;
+                    }
+                    const dash = source[n2] === "-";
+                    pendingHeredoc = { dash };
+                    i = dash ? n2 : n1;
+                    continue;
+                }
+                if (source[n1] === "&") {
+                    pendingRedirect = ch === ">" ? ">&" : "<&";
+                    i = n1;
+                    continue;
+                }
+                if (ch === ">" && (source[n1] === ">" || source[n1] === "|")) {
+                    pendingRedirect = source[n1] === ">" ? ">>" : ">";
+                    i = n1;
+                    continue;
+                }
+                pendingRedirect = ch;
+                continue;
+            }
+            if (split) {
+                let refusal;
+                if (ch === ";")
+                    refusal = closeSegment(";", i, i + 1);
+                else if (ch === "&") {
+                    if (source[n1] === "&") {
+                        refusal = closeSegment("&&", i, n1 + 1);
+                        i = n1;
+                    }
+                    else
+                        refusal = closeSegment("&", i, i + 1);
+                }
+                else if (ch === "|") {
+                    if (source[n1] === "|" || source[n1] === "&") {
+                        refusal = closeSegment(source[n1] === "|" ? "||" : "|", i, n1 + 1);
+                        i = n1;
+                    }
+                    else
+                        refusal = closeSegment("|", i, i + 1);
+                }
+                else if (BLANK.test(ch)) {
+                    refusal = endWord();
+                }
+                else {
+                    take(ch);
+                    continue;
+                }
+                if (refusal !== undefined)
+                    return { reject: refusal };
+                continue;
+            }
+            if (BLANK.test(ch)) {
+                const r = endWord();
+                if (r !== undefined)
+                    return { reject: r };
+                continue;
+            }
+            take(ch);
+            continue;
+        }
+        if (!inDouble && split) {
+            if (ch === "&") {
+                if (source[i + 1] === "&") {
+                    closeSegment("&&", i, i + 2);
+                    i++;
+                    continue;
+                }
+                return { reject: "`&` backgrounding is not allowed — a backgrounded process outlives the command" };
+            }
+            if (ch === "|") {
+                if (source[i + 1] === "|") {
+                    closeSegment("||", i, i + 2);
+                    i++;
+                }
+                else
+                    closeSegment("|", i, i + 1);
+                continue;
+            }
+            if (ch === ";") {
+                closeSegment(";", i, i + 1);
+                continue;
+            }
+        }
+        if (!inDouble && WHITESPACE.test(ch)) {
+            endWord();
+            continue;
+        }
+        take(ch);
+    }
+    const tail = endWord() ?? operandOwed();
+    if (tail !== undefined)
+        return { reject: tail };
+    if (pendingHeredocs.length > 0)
+        return { reject: UNTERMINATED_HEREDOC };
+    const out = segments.map((s) => ({
+        text: source.slice(s.start, s.end),
+        connector: s.connector,
+        tokens: s.tokens,
+        substitutions: s.substitutions,
+    }));
+    return { balanced: !inSingle && !inDouble, command: { segments: out, substitutions: out.flatMap((s) => s.substitutions) } };
+}
+export function lexShellText(source, opts) {
+    const honoured = scan(source, opts, false);
+    if ("reject" in honoured)
+        return honoured;
+    if (honoured.balanced)
+        return honoured.command;
+    const blind = scan(source, opts, true);
+    if ("reject" in blind)
+        return blind;
+    if (opts.mode === "lenient" || opts.connectors === "text")
+        return blind.command;
+    const segments = blind.command.segments.map((segment) => {
+        const own = scan(segment.text, { mode: "strict", connectors: "text" }, false);
+        if ("reject" in own || !own.balanced)
+            return segment;
+        return { ...segment, tokens: own.command.segments[0].tokens };
+    });
+    return { segments, substitutions: [] };
+}