dotdo 0.0.2 → 0.1.0

package/dist/primitives/bashx/src/ast/parser.js

@@ -1,1488 +0,0 @@
-/**
- * Bash AST Parser
- *
- * A lightweight parser for bash commands that detects common syntax errors.
- * Implements error detection for:
- * - Unclosed quotes (single and double)
- * - Missing terminators (fi, done, esac)
- * - Unbalanced brackets/braces
- * - Invalid pipe/redirect syntax
- */
-// ============================================================================
-// Lexer
-// ============================================================================
-class Lexer {
-    input;
-    pos = 0;
-    line = 1;
-    column = 1;
-    errors = [];
-    constructor(input) {
-        this.input = input;
-    }
-    peek(offset = 0) {
-        return this.input[this.pos + offset] ?? '';
-    }
-    advance() {
-        const ch = this.input[this.pos] ?? '';
-        this.pos++;
-        if (ch === '\n') {
-            this.line++;
-            this.column = 1;
-        }
-        else {
-            this.column++;
-        }
-        return ch;
-    }
-    skipWhitespace() {
-        while (this.pos < this.input.length) {
-            const ch = this.peek();
-            if (ch === ' ' || ch === '\t') {
-                this.advance();
-            }
-            else if (ch === '\\' && this.peek(1) === '\n') {
-                // Line continuation
-                this.advance();
-                this.advance();
-            }
-            else {
-                break;
-            }
-        }
-    }
-    isWordChar(ch) {
-        // Not a special character
-        return ch !== '' &&
-            ch !== ' ' && ch !== '\t' && ch !== '\n' &&
-            ch !== '|' && ch !== '&' && ch !== ';' &&
-            ch !== '(' && ch !== ')' && ch !== '{' && ch !== '}' &&
-            ch !== '<' && ch !== '>' && ch !== '#';
-    }
-    readQuotedString(quote) {
-        const startLine = this.line;
-        const startColumn = this.column;
-        let result = quote;
-        this.advance(); // consume opening quote
-        while (this.pos < this.input.length) {
-            const ch = this.peek();
-            if (ch === quote) {
-                result += this.advance();
-                return result;
-            }
-            if (ch === '\\' && quote === '"') {
-                result += this.advance();
-                if (this.pos < this.input.length) {
-                    result += this.advance();
-                }
-            }
-            else if (ch === '$' && quote === '"') {
-                // Handle parameter expansion and command/arithmetic substitution inside double quotes
-                result += this.readParameterExpansion();
-            }
-            else {
-                result += this.advance();
-            }
-        }
-        // Unclosed quote
-        const quoteType = quote === '"' ? 'double' : 'single';
-        this.errors.push({
-            message: `Unclosed ${quoteType} quote`,
-            line: startLine,
-            column: startColumn,
-            suggestion: `Add closing ${quote} at the end`,
-        });
-        return result;
-    }
-    /**
-     * Read a quoted string inside a parameter expansion - doesn't report errors itself
-     */
-    readQuotedStringInExpansion(quote) {
-        let result = quote;
-        this.advance(); // consume opening quote
-        while (this.pos < this.input.length) {
-            const ch = this.peek();
-            if (ch === quote) {
-                result += this.advance();
-                return result;
-            }
-            if (ch === '\\' && quote === '"') {
-                result += this.advance();
-                if (this.pos < this.input.length) {
-                    result += this.advance();
-                }
-            }
-            else {
-                result += this.advance();
-            }
-        }
-        // Return without the closing quote - parent will detect
-        return result;
-    }
-    readParameterExpansion() {
-        const startLine = this.line;
-        const startColumn = this.column;
-        let result = '$';
-        this.advance(); // consume $
-        const next = this.peek();
-        if (next === '(') {
-            // Command substitution $(...) or arithmetic $((...))
-            result += this.advance(); // consume (
-            if (this.peek() === '(') {
-                // Arithmetic expansion $((
-                result += this.advance(); // consume second (
-                let depth = 2;
-                let foundClosing = false;
-                while (this.pos < this.input.length) {
-                    const ch = this.peek();
-                    if (ch === '(') {
-                        depth++;
-                        result += this.advance();
-                    }
-                    else if (ch === ')') {
-                        depth--;
-                        result += this.advance();
-                        if (depth === 0) {
-                            foundClosing = true;
-                            break;
-                        }
-                    }
-                    else {
-                        result += this.advance();
-                    }
-                }
-                if (!foundClosing) {
-                    this.errors.push({
-                        message: 'Unclosed arithmetic expansion $((',
-                        line: startLine,
-                        column: startColumn,
-                        suggestion: 'Add closing )) at the end',
-                    });
-                }
-            }
-            else {
-                // Command substitution $(
-                let depth = 1;
-                let foundClosing = false;
-                while (this.pos < this.input.length) {
-                    const ch = this.peek();
-                    if (ch === '"' || ch === "'") {
-                        result += this.readQuotedString(ch);
-                    }
-                    else if (ch === '(') {
-                        depth++;
-                        result += this.advance();
-                    }
-                    else if (ch === ')') {
-                        depth--;
-                        result += this.advance();
-                        if (depth === 0) {
-                            foundClosing = true;
-                            break;
-                        }
-                    }
-                    else {
-                        result += this.advance();
-                    }
-                }
-                if (!foundClosing) {
-                    this.errors.push({
-                        message: 'Unclosed command substitution $(',
-                        line: startLine,
-                        column: startColumn,
-                        suggestion: 'Add closing ) at the end',
-                    });
-                }
-            }
-        }
-        else if (next === '{') {
-            // Parameter expansion ${...}
-            result += this.advance(); // consume {
-            let depth = 1;
-            let foundClosing = false;
-            let hasUnclosedQuote = false;
-            while (this.pos < this.input.length) {
-                const ch = this.peek();
-                if (ch === '"' || ch === "'") {
-                    const quotedStr = this.readQuotedStringInExpansion(ch);
-                    result += quotedStr;
-                    // Check if quote was unclosed (doesn't end with the same quote char it started with)
-                    if (!quotedStr.endsWith(ch)) {
-                        hasUnclosedQuote = true;
-                    }
-                }
-                else if (ch === '{') {
-                    depth++;
-                    result += this.advance();
-                }
-                else if (ch === '}') {
-                    depth--;
-                    result += this.advance();
-                    if (depth === 0) {
-                        foundClosing = true;
-                        break;
-                    }
-                }
-                else {
-                    result += this.advance();
-                }
-            }
-            if (!foundClosing) {
-                if (hasUnclosedQuote) {
-                    this.errors.push({
-                        message: 'Unclosed quote in parameter expansion',
-                        line: startLine,
-                        column: startColumn,
-                        suggestion: 'Add closing quote and } at the end',
-                    });
-                }
-                else {
-                    this.errors.push({
-                        message: 'Unclosed brace in parameter expansion ${',
-                        line: startLine,
-                        column: startColumn,
-                        suggestion: 'Add closing } at the end',
-                    });
-                }
-            }
-        }
-        else {
-            // Simple variable $VAR
-            while (this.pos < this.input.length) {
-                const ch = this.peek();
-                if (/[a-zA-Z0-9_]/.test(ch)) {
-                    result += this.advance();
-                }
-                else {
-                    break;
-                }
-            }
-        }
-        return result;
-    }
-    readWord() {
-        let result = '';
-        while (this.pos < this.input.length) {
-            const ch = this.peek();
-            if (ch === '"' || ch === "'") {
-                result += this.readQuotedString(ch);
-            }
-            else if (ch === '$') {
-                result += this.readParameterExpansion();
-            }
-            else if (ch === '\\' && this.peek(1) !== '') {
-                // Escape sequence
-                result += this.advance();
-                result += this.advance();
-            }
-            else if (ch === '`') {
-                // Backtick command substitution
-                const startLine = this.line;
-                const startColumn = this.column;
-                result += this.advance();
-                let foundClosing = false;
-                while (this.pos < this.input.length) {
-                    const c = this.peek();
-                    if (c === '`') {
-                        result += this.advance();
-                        foundClosing = true;
-                        break;
-                    }
-                    else if (c === '\\') {
-                        result += this.advance();
-                        if (this.pos < this.input.length) {
-                            result += this.advance();
-                        }
-                    }
-                    else {
-                        result += this.advance();
-                    }
-                }
-                if (!foundClosing) {
-                    this.errors.push({
-                        message: 'Unclosed backtick command substitution',
-                        line: startLine,
-                        column: startColumn,
-                        suggestion: 'Add closing ` at the end',
-                    });
-                }
-            }
-            else if (this.isWordChar(ch)) {
-                result += this.advance();
-            }
-            else {
-                break;
-            }
-        }
-        return result;
-    }
-    nextToken() {
-        this.skipWhitespace();
-        if (this.pos >= this.input.length) {
-            return { type: 'EOF', value: '', line: this.line, column: this.column };
-        }
-        const startLine = this.line;
-        const startColumn = this.column;
-        const ch = this.peek();
-        // Comments
-        if (ch === '#') {
-            while (this.pos < this.input.length && this.peek() !== '\n') {
-                this.advance();
-            }
-            return this.nextToken();
-        }
-        // Newline
-        if (ch === '\n') {
-            this.advance();
-            return { type: 'NEWLINE', value: '\n', line: startLine, column: startColumn };
-        }
-        // Semicolons and case pattern end
-        if (ch === ';') {
-            this.advance();
-            if (this.peek() === ';') {
-                this.advance();
-                return { type: 'CASE_PATTERN_END', value: ';;', line: startLine, column: startColumn };
-            }
-            return { type: 'SEMICOLON', value: ';', line: startLine, column: startColumn };
-        }
-        // Pipes and logical operators
-        if (ch === '|') {
-            this.advance();
-            if (this.peek() === '|') {
-                this.advance();
-                return { type: 'OR', value: '||', line: startLine, column: startColumn };
-            }
-            return { type: 'PIPE', value: '|', line: startLine, column: startColumn };
-        }
-        // And/background/combined redirect
-        if (ch === '&') {
-            this.advance();
-            if (this.peek() === '&') {
-                this.advance();
-                return { type: 'AND', value: '&&', line: startLine, column: startColumn };
-            }
-            if (this.peek() === '>') {
-                this.advance();
-                // &> redirects both stdout and stderr
-                return { type: 'REDIRECT_BOTH', value: '&>', line: startLine, column: startColumn };
-            }
-            return { type: 'BACKGROUND', value: '&', line: startLine, column: startColumn };
-        }
-        // Parentheses
-        if (ch === '(') {
-            this.advance();
-            return { type: 'LPAREN', value: '(', line: startLine, column: startColumn };
-        }
-        if (ch === ')') {
-            this.advance();
-            return { type: 'RPAREN', value: ')', line: startLine, column: startColumn };
-        }
-        // Braces
-        if (ch === '{') {
-            this.advance();
-            return { type: 'LBRACE', value: '{', line: startLine, column: startColumn };
-        }
-        if (ch === '}') {
-            this.advance();
-            return { type: 'RBRACE', value: '}', line: startLine, column: startColumn };
-        }
-        // Brackets
-        if (ch === '[') {
-            this.advance();
-            if (this.peek() === '[') {
-                this.advance();
-                return { type: 'DOUBLE_LBRACKET', value: '[[', line: startLine, column: startColumn };
-            }
-            return { type: 'LBRACKET', value: '[', line: startLine, column: startColumn };
-        }
-        if (ch === ']') {
-            this.advance();
-            if (this.peek() === ']') {
-                this.advance();
-                return { type: 'DOUBLE_RBRACKET', value: ']]', line: startLine, column: startColumn };
-            }
-            return { type: 'RBRACKET', value: ']', line: startLine, column: startColumn };
-        }
-        // Redirects
-        if (ch === '>') {
-            this.advance();
-            if (this.peek() === '>') {
-                this.advance();
-                return { type: 'REDIRECT_APPEND', value: '>>', line: startLine, column: startColumn };
-            }
-            if (this.peek() === '&') {
-                this.advance();
-                return { type: 'REDIRECT_OUT', value: '>&', line: startLine, column: startColumn };
-            }
-            return { type: 'REDIRECT_OUT', value: '>', line: startLine, column: startColumn };
-        }
-        if (ch === '<') {
-            this.advance();
-            if (this.peek() === '<') {
-                this.advance();
-                if (this.peek() === '<') {
-                    this.advance();
-                    return { type: 'REDIRECT_HERESTRING', value: '<<<', line: startLine, column: startColumn };
-                }
-                return { type: 'REDIRECT_HEREDOC', value: '<<', line: startLine, column: startColumn };
-            }
-            if (this.peek() === '&') {
-                this.advance();
-                return { type: 'REDIRECT_IN', value: '<&', line: startLine, column: startColumn };
-            }
-            return { type: 'REDIRECT_IN', value: '<', line: startLine, column: startColumn };
-        }
-        // Check for digit followed by redirect (e.g., 2>&1, 2>file, 1>out)
-        if (/[0-9]/.test(ch)) {
-            const nextCh = this.peek(1);
-            if (nextCh === '>' || nextCh === '<') {
-                const fd = parseInt(this.advance(), 10);
-                const redirectCh = this.advance();
-                if (redirectCh === '>') {
-                    if (this.peek() === '>') {
-                        this.advance();
-                        return { type: 'REDIRECT_APPEND', value: '>>', line: startLine, column: startColumn, fd };
-                    }
-                    if (this.peek() === '&') {
-                        this.advance();
-                        return { type: 'REDIRECT_OUT', value: '>&', line: startLine, column: startColumn, fd };
-                    }
-                    return { type: 'REDIRECT_OUT', value: '>', line: startLine, column: startColumn, fd };
-                }
-                else {
-                    // <
-                    if (this.peek() === '<') {
-                        this.advance();
-                        if (this.peek() === '<') {
-                            this.advance();
-                            return { type: 'REDIRECT_HERESTRING', value: '<<<', line: startLine, column: startColumn, fd };
-                        }
-                        return { type: 'REDIRECT_HEREDOC', value: '<<', line: startLine, column: startColumn, fd };
-                    }
-                    if (this.peek() === '&') {
-                        this.advance();
-                        return { type: 'REDIRECT_IN', value: '<&', line: startLine, column: startColumn, fd };
-                    }
-                    return { type: 'REDIRECT_IN', value: '<', line: startLine, column: startColumn, fd };
-                }
-            }
-        }
-        // Words (including keywords)
-        const word = this.readWord();
-        if (word === '') {
-            // Unknown character, try to recover
-            const badChar = this.advance();
-            this.errors.push({
-                message: `Unexpected character '${badChar}'`,
-                line: startLine,
-                column: startColumn,
-            });
-            return { type: 'ERROR', value: badChar, line: startLine, column: startColumn };
-        }
-        // Check for keywords
-        const keywords = {
-            if: 'IF',
-            then: 'THEN',
-            else: 'ELSE',
-            elif: 'ELIF',
-            fi: 'FI',
-            for: 'FOR',
-            while: 'WHILE',
-            until: 'UNTIL',
-            do: 'DO',
-            done: 'DONE',
-            case: 'CASE',
-            esac: 'ESAC',
-            in: 'IN',
-        };
-        const keywordType = keywords[word];
-        if (keywordType) {
-            return { type: keywordType, value: word, line: startLine, column: startColumn };
-        }
-        // Check for assignment (VAR=value)
-        const assignMatch = word.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(=|\+=)(.*)$/);
-        if (assignMatch) {
-            return { type: 'ASSIGNMENT', value: word, line: startLine, column: startColumn };
-        }
-        return { type: 'WORD', value: word, line: startLine, column: startColumn };
-    }
-    tokenize() {
-        const tokens = [];
-        let token;
-        while ((token = this.nextToken()).type !== 'EOF') {
-            if (token.type !== 'ERROR') {
-                tokens.push(token);
-            }
-        }
-        tokens.push(token); // Include EOF
-        return tokens;
-    }
-}
-// ============================================================================
-// Parser
-// ============================================================================
-class Parser {
-    tokens;
-    pos = 0;
-    errors = [];
-    constructor(tokens, lexerErrors) {
-        this.tokens = tokens;
-        this.errors = [...lexerErrors];
-    }
-    peek(offset = 0) {
-        const idx = this.pos + offset;
-        if (idx < 0 || idx >= this.tokens.length) {
-            return { type: 'EOF', value: '', line: 0, column: 0 };
-        }
-        return this.tokens[idx];
-    }
-    advance() {
-        const token = this.tokens[this.pos];
-        if (this.pos < this.tokens.length) {
-            this.pos++;
-        }
-        return token;
-    }
-    /** @internal Reserved for future use */
-    expect(type, message) {
-        const token = this.peek();
-        if (token.type !== type) {
-            if (message) {
-                this.errors.push({
-                    message,
-                    line: token.line,
-                    column: token.column,
-                });
-            }
-            return null;
-        }
-        return this.advance();
-    }
-    skipNewlines() {
-        while (this.peek().type === 'NEWLINE') {
-            this.advance();
-        }
-    }
-    isCommandTerminator(token) {
-        return token.type === 'NEWLINE' ||
-            token.type === 'SEMICOLON' ||
-            token.type === 'PIPE' ||
-            token.type === 'AND' ||
-            token.type === 'OR' ||
-            token.type === 'BACKGROUND' ||
-            token.type === 'RPAREN' ||
-            token.type === 'RBRACE' ||
-            token.type === 'EOF';
-    }
-    isRedirectToken(token) {
-        return token.type === 'REDIRECT_OUT' ||
-            token.type === 'REDIRECT_APPEND' ||
-            token.type === 'REDIRECT_IN' ||
-            token.type === 'REDIRECT_HEREDOC' ||
-            token.type === 'REDIRECT_HERESTRING' ||
-            token.type === 'REDIRECT_BOTH';
-    }
-    parseRedirect() {
-        const token = this.peek();
-        if (!this.isRedirectToken(token)) {
-            return null;
-        }
-        this.advance();
-        this.skipWhitespaceTokens();
-        const targetToken = this.peek();
-        // Check for consecutive redirects (like > >)
-        if (this.isRedirectToken(targetToken)) {
-            this.errors.push({
-                message: `Consecutive redirects: unexpected ${targetToken.value} after ${token.value}`,
-                line: targetToken.line,
-                column: targetToken.column,
-                suggestion: 'Remove one of the redirect operators',
-            });
-            return null;
-        }
-        // Accept WORD, ASSIGNMENT, or IN (which can be a filename like 'in')
-        if (targetToken.type !== 'WORD' && targetToken.type !== 'ASSIGNMENT' && targetToken.type !== 'IN') {
-            this.errors.push({
-                message: `Redirect incomplete: missing file after ${token.value}`,
-                line: token.line,
-                column: token.column,
-                suggestion: 'Specify a file name after the redirect operator',
-            });
-            return null;
-        }
-        const target = this.advance();
-        const opMap = {
-            '>': '>',
-            '>&': '>&',
-            '>>': '>>',
-            '<': '<',
-            '<&': '<&',
-            '<<': '<<',
-            '<<<': '<<<',
-            '&>': '>&', // &> is equivalent to >& for redirecting both stdout and stderr
-        };
-        const redirect = {
-            type: 'Redirect',
-            op: opMap[token.value] ?? '>',
-            target: { type: 'Word', value: target.value },
-        };
-        // Include file descriptor if present
-        if (token.fd !== undefined) {
-            redirect.fd = token.fd;
-        }
-        return redirect;
-    }
-    skipWhitespaceTokens() {
-        // No explicit whitespace tokens in our lexer, but keep for consistency
-    }
-    parseWord() {
-        const token = this.peek();
-        if (token.type === 'WORD' || token.type === 'ASSIGNMENT') {
-            this.advance();
-            let quoted = undefined;
-            // Check if quoted
-            if (token.value.startsWith('"') || token.value.includes('"')) {
-                quoted = 'double';
-            }
-            else if (token.value.startsWith("'") || token.value.includes("'")) {
-                quoted = 'single';
-            }
-            return {
-                type: 'Word',
-                value: token.value,
-                quoted,
-            };
-        }
-        return null;
-    }
-    parseSimpleCommand() {
-        const prefix = [];
-        const args = [];
-        const redirects = [];
-        let name = null;
-        // Parse assignments at the start
-        while (this.peek().type === 'ASSIGNMENT') {
-            const token = this.advance();
-            const match = token.value.match(/^([a-zA-Z_][a-zA-Z0-9_]*)(=|\+=)(.*)$/);
-            if (match) {
-                prefix.push({
-                    type: 'Assignment',
-                    name: match[1],
-                    operator: match[2],
-                    value: match[3] ? { type: 'Word', value: match[3] } : null,
-                });
-            }
-        }
-        // Handle single [ test command
-        if (this.peek().type === 'LBRACKET') {
-            const startToken = this.advance();
-            name = { type: 'Word', value: '[' };
-            // Parse test expression arguments until ]
-            while (this.peek().type !== 'RBRACKET' && this.peek().type !== 'EOF' &&
-                !this.isCommandTerminator(this.peek())) {
-                const token = this.peek();
-                if (token.type === 'WORD') {
-                    const word = this.parseWord();
-                    if (word) {
-                        args.push(word);
-                    }
-                }
-                else {
-                    break;
-                }
-            }
-            // Expect closing ]
-            if (this.peek().type !== 'RBRACKET') {
-                this.errors.push({
-                    message: 'Unclosed [ test bracket: missing ]',
-                    line: startToken.line,
-                    column: startToken.column,
-                    suggestion: 'Add ] to close the test bracket',
-                });
-            }
-            else {
-                this.advance(); // consume ]
-                args.push({ type: 'Word', value: ']' });
-            }
-            return { type: 'Command', name, prefix, args, redirects };
-        }
-        // Parse command name and arguments
-        while (true) {
-            const token = this.peek();
-            if (this.isRedirectToken(token)) {
-                // Check for consecutive redirects (like > >)
-                const prevToken = this.peek(-1);
-                if (prevToken && this.isRedirectToken(prevToken)) {
-                    this.errors.push({
-                        message: `Consecutive redirects: unexpected ${token.value} after ${prevToken.value}`,
-                        line: token.line,
-                        column: token.column,
-                        suggestion: 'Remove one of the redirect operators',
-                    });
-                }
-                const redirect = this.parseRedirect();
-                if (redirect) {
-                    redirects.push(redirect);
-                }
-            }
-            else if (token.type === 'WORD') {
-                const word = this.parseWord();
-                if (word) {
-                    if (!name) {
-                        name = word;
-                    }
-                    else {
-                        args.push(word);
-                    }
-                }
-            }
-            else if (token.type === 'IN') {
-                // 'in' can appear as a filename (e.g., cmd < in), treat as word in command context
-                this.advance();
-                const word = { type: 'Word', value: 'in' };
-                if (!name) {
-                    name = word;
-                }
-                else {
-                    args.push(word);
-                }
-            }
-            else if (this.isCommandTerminator(token) || token.type === 'THEN' || token.type === 'DO' ||
-                token.type === 'ELSE' || token.type === 'ELIF' || token.type === 'FI' ||
-                token.type === 'DONE' || token.type === 'ESAC' || token.type === 'CASE_PATTERN_END') {
-                break;
-            }
-            else {
-                break;
-            }
-        }
-        if (!name && prefix.length === 0 && redirects.length === 0) {
-            return null;
-        }
-        return {
-            type: 'Command',
-            name,
-            prefix,
-            args,
-            redirects,
-        };
-    }
-    parseSubshell() {
-        if (this.peek().type !== 'LPAREN') {
-            return null;
-        }
-        const startToken = this.advance(); // consume (
-        this.skipNewlines();
-        const body = [];
-        while (this.peek().type !== 'RPAREN' && this.peek().type !== 'EOF') {
-            const node = this.parseCompoundList();
-            if (node) {
-                body.push(node);
-            }
-            this.skipNewlines();
-            if (this.peek().type === 'SEMICOLON') {
-                this.advance();
-                this.skipNewlines();
-            }
-        }
-        if (this.peek().type !== 'RPAREN') {
-            this.errors.push({
-                message: 'Unclosed subshell: missing )',
-                line: startToken.line,
-                column: startToken.column,
-                suggestion: 'Add ) to close the subshell',
-            });
-            return { type: 'Subshell', body };
-        }
-        this.advance(); // consume )
-        return { type: 'Subshell', body };
-    }
-    parseBraceGroup() {
-        if (this.peek().type !== 'LBRACE') {
-            return null;
-        }
-        const startToken = this.advance(); // consume {
-        this.skipNewlines();
-        const body = [];
-        while (this.peek().type !== 'RBRACE' && this.peek().type !== 'EOF') {
-            const node = this.parseCompoundList();
-            if (node) {
-                body.push(node);
-            }
-            this.skipNewlines();
-            if (this.peek().type === 'SEMICOLON') {
-                this.advance();
-                this.skipNewlines();
-            }
-        }
-        if (this.peek().type !== 'RBRACE') {
-            this.errors.push({
-                message: 'Unclosed brace group: missing }',
-                line: startToken.line,
-                column: startToken.column,
-                suggestion: 'Add } to close the brace group',
-            });
-            return { type: 'CompoundCommand', kind: 'brace', body };
-        }
-        this.advance(); // consume }
-        return { type: 'CompoundCommand', kind: 'brace', body };
-    }
-    parseIfStatement() {
-        if (this.peek().type !== 'IF') {
-            return null;
-        }
-        const startToken = this.advance(); // consume 'if'
-        this.skipNewlines();
-        const body = [];
-        // Parse condition
-        const condition = this.parseCondition();
-        if (condition) {
-            body.push(condition);
-        }
-        this.skipNewlines();
-        // Skip semicolon before 'then' (common in one-line if statements)
-        if (this.peek().type === 'SEMICOLON') {
-            this.advance();
-            this.skipNewlines();
-        }
-        // Expect 'then'
-        if (this.peek().type !== 'THEN') {
-            this.errors.push({
-                message: "Missing 'then' in if statement",
-                line: this.peek().line,
-                column: this.peek().column,
-                suggestion: "Add 'then' after the condition",
-            });
-        }
-        else {
-            this.advance();
-        }
-        this.skipNewlines();
-        // Parse 'then' body
-        while (this.peek().type !== 'ELSE' && this.peek().type !== 'ELIF' &&
-            this.peek().type !== 'FI' && this.peek().type !== 'EOF') {
-            const node = this.parseCompoundList();
-            if (node) {
-                body.push(node);
-            }
-            else {
-                break;
-            }
-            this.skipNewlines();
-            if (this.peek().type === 'SEMICOLON') {
-                this.advance();
-                this.skipNewlines();
-            }
-        }
-        // Parse 'elif' or 'else'
-        while (this.peek().type === 'ELIF' || this.peek().type === 'ELSE') {
-            this.advance();
-            this.skipNewlines();
-            if (this.peek(-1).type === 'ELIF') {
-                // Parse elif condition
-                const elifCondition = this.parseCondition();
-                if (elifCondition) {
-                    body.push(elifCondition);
-                }
-                this.skipNewlines();
-                // Skip semicolon before 'then'
-                if (this.peek().type === 'SEMICOLON') {
-                    this.advance();
-                    this.skipNewlines();
-                }
-                if (this.peek().type === 'THEN') {
-                    this.advance();
-                }
-                this.skipNewlines();
-            }
-            // Parse else/elif body
-            while (this.peek().type !== 'ELSE' && this.peek().type !== 'ELIF' &&
-                this.peek().type !== 'FI' && this.peek().type !== 'EOF') {
-                const node = this.parseCompoundList();
-                if (node) {
-                    body.push(node);
-                }
-                else {
-                    break;
-                }
-                this.skipNewlines();
-                if (this.peek().type === 'SEMICOLON') {
-                    this.advance();
-                    this.skipNewlines();
-                }
-            }
-        }
-        // Expect 'fi'
-        if (this.peek().type !== 'FI') {
-            this.errors.push({
-                message: "Missing 'fi' to close if statement",
-                line: startToken.line,
-                column: startToken.column,
-                suggestion: "Add 'fi' at the end",
-            });
-        }
-        else {
-            this.advance();
-        }
-        return { type: 'CompoundCommand', kind: 'if', body };
-    }
-    parseForLoop() {
-        if (this.peek().type !== 'FOR') {
-            return null;
-        }
-        const startToken = this.advance(); // consume 'for'
-        this.skipNewlines();
-        const body = [];
-        // Check for C-style for loop: for ((...))
-        if (this.peek().type === 'LPAREN' && this.peek(1).type === 'LPAREN') {
-            this.advance(); // consume first (
-            this.advance(); // consume second (
-            // Parse the arithmetic expression until ))
-            let depth = 2;
-            let exprContent = '';
-            while (depth > 0 && this.peek().type !== 'EOF') {
-                const currentToken = this.peek();
-                if (currentToken.type === 'LPAREN') {
-                    depth++;
-                    exprContent += '(';
-                    this.advance();
-                }
-                else if (currentToken.type === 'RPAREN') {
-                    depth--;
-                    if (depth > 0) {
-                        exprContent += ')';
-                    }
-                    this.advance();
-                }
-                else {
-                    exprContent += currentToken.value;
-                    this.advance();
-                }
-                // Add space between tokens (simplified)
-                if (depth > 0) {
-                    exprContent += ' ';
-                }
-            }
-            // Store the C-style expression
-            if (exprContent.trim()) {
-                body.push({
-                    type: 'Command',
-                    name: { type: 'Word', value: exprContent.trim() },
-                    prefix: [],
-                    args: [],
-                    redirects: []
-                });
-            }
-            this.skipNewlines();
-            // Allow semicolon before do
-            if (this.peek().type === 'SEMICOLON') {
-                this.advance();
-                this.skipNewlines();
-            }
-            // Expect 'do'
-            if (this.peek().type !== 'DO') {
-                this.errors.push({
-                    message: "Missing 'do' in for loop",
-                    line: this.peek().line,
-                    column: this.peek().column,
-                    suggestion: "Add 'do' before the loop body",
-                });
-            }
-            else {
-                this.advance();
-            }
-            this.skipNewlines();
-            // Parse loop body
-            while (this.peek().type !== 'DONE' && this.peek().type !== 'EOF') {
-                const node = this.parseCompoundList();
-                if (node) {
-                    body.push(node);
-                }
-                else {
-                    break;
-                }
-                this.skipNewlines();
-                if (this.peek().type === 'SEMICOLON') {
-                    this.advance();
-                    this.skipNewlines();
-                }
-            }
-            // Expect 'done'
-            if (this.peek().type !== 'DONE') {
-                this.errors.push({
-                    message: "Missing 'done' to close for loop",
-                    line: startToken.line,
-                    column: startToken.column,
-                    suggestion: "Add 'done' at the end",
-                });
-            }
-            else {
-                this.advance();
-            }
-            return { type: 'CompoundCommand', kind: 'for', body };
-        }
-        // Standard for loop: for var in list
-        // Parse variable name
-        if (this.peek().type === 'WORD') {
-            body.push({ type: 'Command', name: this.parseWord(), prefix: [], args: [], redirects: [] });
-        }
-        this.skipNewlines();
-        // Expect 'in' (optional)
-        if (this.peek().type === 'IN') {
-            this.advance();
-            this.skipNewlines();
-            // Parse word list
-            while (this.peek().type === 'WORD') {
-                body.push({ type: 'Command', name: this.parseWord(), prefix: [], args: [], redirects: [] });
-            }
-        }
-        this.skipNewlines();
-        // Allow semicolon before do
-        if (this.peek().type === 'SEMICOLON') {
-            this.advance();
-            this.skipNewlines();
-        }
-        // Expect 'do'
-        if (this.peek().type !== 'DO') {
-            this.errors.push({
-                message: "Missing 'do' in for loop",
-                line: this.peek().line,
-                column: this.peek().column,
-                suggestion: "Add 'do' before the loop body",
-            });
-        }
-        else {
-            this.advance();
-        }
-        this.skipNewlines();
-        // Parse loop body
-        while (this.peek().type !== 'DONE' && this.peek().type !== 'EOF') {
-            const node = this.parseCompoundList();
-            if (node) {
-                body.push(node);
-            }
-            else {
-                break;
-            }
-            this.skipNewlines();
-            if (this.peek().type === 'SEMICOLON') {
-                this.advance();
-                this.skipNewlines();
-            }
-        }
-        // Expect 'done'
-        if (this.peek().type !== 'DONE') {
-            this.errors.push({
-                message: "Missing 'done' to close for loop",
-                line: startToken.line,
-                column: startToken.column,
-                suggestion: "Add 'done' at the end",
-            });
-        }
-        else {
-            this.advance();
-        }
-        return { type: 'CompoundCommand', kind: 'for', body };
-    }
-    parseWhileLoop() {
-        const tokenType = this.peek().type;
-        if (tokenType !== 'WHILE' && tokenType !== 'UNTIL') {
-            return null;
-        }
-        const startToken = this.advance(); // consume 'while' or 'until'
-        const kind = tokenType === 'WHILE' ? 'while' : 'until';
-        this.skipNewlines();
-        const body = [];
-        // Parse condition
-        const condition = this.parseCondition();
-        if (condition) {
-            body.push(condition);
-        }
-        this.skipNewlines();
-        // Allow semicolon before do
-        if (this.peek().type === 'SEMICOLON') {
-            this.advance();
-            this.skipNewlines();
-        }
-        // Expect 'do'
-        if (this.peek().type !== 'DO') {
-            this.errors.push({
-                message: `Missing 'do' in ${kind} loop`,
-                line: this.peek().line,
-                column: this.peek().column,
-                suggestion: "Add 'do' before the loop body",
-            });
-        }
-        else {
-            this.advance();
-        }
-        this.skipNewlines();
-        // Parse loop body
-        while (this.peek().type !== 'DONE' && this.peek().type !== 'EOF') {
-            const node = this.parseCompoundList();
-            if (node) {
-                body.push(node);
-            }
-            else {
-                break;
-            }
-            this.skipNewlines();
-            if (this.peek().type === 'SEMICOLON') {
-                this.advance();
-                this.skipNewlines();
-            }
-        }
-        // Expect 'done'
-        if (this.peek().type !== 'DONE') {
-            this.errors.push({
-                message: `Missing 'done' to close ${kind} loop`,
-                line: startToken.line,
-                column: startToken.column,
-                suggestion: "Add 'done' at the end",
-            });
-        }
-        else {
-            this.advance();
-        }
-        return { type: 'CompoundCommand', kind, body };
-    }
-    parseCaseStatement() {
-        if (this.peek().type !== 'CASE') {
-            return null;
-        }
-        const startToken = this.advance(); // consume 'case'
-        this.skipNewlines();
-        const body = [];
-        // Parse word
-        if (this.peek().type === 'WORD') {
-            body.push({ type: 'Command', name: this.parseWord(), prefix: [], args: [], redirects: [] });
-        }
-        this.skipNewlines();
-        // Expect 'in'
-        if (this.peek().type === 'IN') {
-            this.advance();
-        }
-        this.skipNewlines();
-        // Parse case items
-        while (this.peek().type !== 'ESAC' && this.peek().type !== 'EOF') {
-            // Parse pattern
-            if (this.peek().type === 'WORD' || this.peek().type === 'LPAREN') {
-                // Skip optional (
-                if (this.peek().type === 'LPAREN') {
-                    this.advance();
-                }
-                // Parse pattern word(s)
-                while (this.peek().type === 'WORD') {
-                    this.advance();
-                    if (this.peek().type === 'PIPE') {
-                        this.advance(); // pattern separator
-                    }
-                    else {
-                        break;
-                    }
-                }
-                // Expect )
-                if (this.peek().type === 'RPAREN') {
-                    this.advance();
-                }
-                this.skipNewlines();
-                // Parse case body until ;;
-                while (this.peek().type !== 'CASE_PATTERN_END' &&
-                    this.peek().type !== 'ESAC' &&
-                    this.peek().type !== 'EOF') {
-                    const node = this.parseCompoundList();
-                    if (node) {
-                        body.push(node);
-                    }
-                    else {
-                        break;
-                    }
-                    this.skipNewlines();
-                    if (this.peek().type === 'SEMICOLON') {
-                        this.advance();
-                        this.skipNewlines();
-                    }
-                }
-                // Consume ;;
-                if (this.peek().type === 'CASE_PATTERN_END') {
-                    this.advance();
-                }
-                this.skipNewlines();
-            }
-            else {
-                break;
-            }
-        }
-        // Expect 'esac'
-        if (this.peek().type !== 'ESAC') {
-            this.errors.push({
-                message: "Missing 'esac' to close case statement",
-                line: startToken.line,
-                column: startToken.column,
-                suggestion: "Add 'esac' at the end",
-            });
-        }
-        else {
-            this.advance();
-        }
-        return { type: 'CompoundCommand', kind: 'case', body };
-    }
-    parseTestCommand() {
-        const token = this.peek();
-        // [[ test ]]
-        if (token.type === 'DOUBLE_LBRACKET') {
-            const startToken = this.advance();
-            const body = [];
-            // Parse test expression - [[ ]] can contain && and || as operators within the test
-            while (this.peek().type !== 'DOUBLE_RBRACKET' && this.peek().type !== 'EOF') {
-                const currentToken = this.peek();
-                // Handle && and || inside [[ ]]
-                if (currentToken.type === 'AND' || currentToken.type === 'OR') {
-                    const opToken = this.advance();
-                    body.push({ type: 'Command', name: { type: 'Word', value: opToken.value }, prefix: [], args: [], redirects: [] });
-                }
-                else {
-                    const word = this.parseWord();
-                    if (word) {
-                        body.push({ type: 'Command', name: word, prefix: [], args: [], redirects: [] });
-                    }
-                    else {
-                        break;
-                    }
-                }
-            }
-            if (this.peek().type !== 'DOUBLE_RBRACKET') {
-                this.errors.push({
-                    message: 'Unclosed [[ test: missing ]]',
-                    line: startToken.line,
-                    column: startToken.column,
-                    suggestion: 'Add ]] to close the test',
-                });
-            }
-            else {
-                this.advance();
-            }
-            return { type: 'CompoundCommand', kind: 'arithmetic', body };
-        }
-        // [ test ] - this is handled as a regular command
-        return null;
-    }
-    parseCompoundCommand() {
-        const token = this.peek();
-        switch (token.type) {
-            case 'IF':
-                return this.parseIfStatement();
-            case 'FOR':
-                return this.parseForLoop();
-            case 'WHILE':
-            case 'UNTIL':
-                return this.parseWhileLoop();
-            case 'CASE':
-                return this.parseCaseStatement();
-            case 'LPAREN':
-                return this.parseSubshell();
-            case 'LBRACE':
-                return this.parseBraceGroup();
-            case 'DOUBLE_LBRACKET':
-                return this.parseTestCommand();
-            default:
-                return null;
-        }
-    }
-    parsePipeline() {
-        const commands = [];
-        let negated = false;
-        // Check for negation (! at start of pipeline)
-        if (this.peek().type === 'WORD' && this.peek().value === '!') {
-            negated = true;
-            this.advance(); // consume !
-            this.skipWhitespaceTokens();
-        }
-        // Check for leading pipe (error)
-        if (this.peek().type === 'PIPE') {
-            this.errors.push({
-                message: 'Pipe at start of command: command expected before |',
-                line: this.peek().line,
-                column: this.peek().column,
-                suggestion: 'Add a command before the pipe',
-            });
-            this.advance(); // consume the pipe and continue
-        }
-        // Try compound command first
-        const compound = this.parseCompoundCommand();
-        if (compound) {
-            // Check for pipe after compound
-            this.skipNewlines();
-            if (this.peek().type === 'PIPE') {
-                // Compound commands in pipelines - for now, return as-is
-                return compound;
-            }
-            return compound;
-        }
-        // Parse first simple command
-        const firstCmd = this.parseSimpleCommand();
-        if (!firstCmd) {
-            return null;
-        }
-        commands.push(firstCmd);
-        // Parse pipeline continuation
-        while (this.peek().type === 'PIPE') {
-            const pipeToken = this.advance();
-            // Check for consecutive pipes
-            if (this.peek().type === 'PIPE') {
-                this.errors.push({
-                    message: 'Consecutive pipes: remove extra |',
-                    line: this.peek().line,
-                    column: this.peek().column,
-                    suggestion: 'Remove one of the consecutive pipes',
-                });
-                this.advance(); // consume extra pipe
-            }
-            this.skipNewlines();
-            // Check for missing command after pipe
-            if (this.isCommandTerminator(this.peek()) || this.peek().type === 'EOF') {
-                this.errors.push({
-                    message: 'Pipe incomplete: missing command after |',
-                    line: pipeToken.line,
-                    column: pipeToken.column,
-                    suggestion: 'Add a command after the pipe',
-                });
-                break;
-            }
-            const nextCmd = this.parseSimpleCommand();
-            if (nextCmd) {
-                commands.push(nextCmd);
-            }
-            else {
-                break;
-            }
-        }
-        if (commands.length === 1 && !negated) {
-            return commands[0];
-        }
-        return {
-            type: 'Pipeline',
-            negated,
-            commands,
-        };
-    }
-    parseAndOr() {
-        let left = this.parsePipeline();
-        if (!left) {
-            return null;
-        }
-        while (this.peek().type === 'AND' || this.peek().type === 'OR') {
-            const opToken = this.advance();
-            const operator = opToken.type === 'AND' ? '&&' : '||';
-            this.skipNewlines();
-            // Check for missing command after && or ||
-            if (this.isCommandTerminator(this.peek()) || this.peek().type === 'EOF') {
-                this.errors.push({
-                    message: `Incomplete ${operator === '&&' ? 'AND' : 'OR'} list: missing command after ${operator}`,
-                    line: opToken.line,
-                    column: opToken.column,
-                    suggestion: `Add a command after ${operator}`,
-                });
-                return left;
-            }
-            const right = this.parsePipeline();
-            if (!right) {
-                return left;
-            }
-            left = {
-                type: 'List',
-                operator,
-                left,
-                right,
-            };
-        }
-        return left;
-    }
-    /**
-     * Parse a condition for if/while/until statements.
-     * Unlike parseCompoundList, this doesn't report "unexpected semicolon" errors
-     * since conditions are typically followed by semicolons in one-line syntax.
-     */
-    parseCondition() {
-        this.skipNewlines();
-        return this.parseAndOr();
-    }
-    parseCompoundList() {
-        this.skipNewlines();
-        // Check for unexpected token at start
-        if (this.peek().type === 'SEMICOLON') {
-            const token = this.peek();
-            this.errors.push({
-                message: 'Unexpected semicolon at start of command',
-                line: token.line,
-                column: token.column,
-                suggestion: 'Remove the leading semicolon',
-            });
-            this.advance();
-            this.skipNewlines();
-        }
-        return this.parseAndOr();
-    }
-    parse() {
-        const body = [];
-        while (this.peek().type !== 'EOF') {
-            this.skipNewlines();
-            if (this.peek().type === 'EOF') {
-                break;
-            }
-            const node = this.parseCompoundList();
-            if (node) {
-                body.push(node);
-            }
-            // Consume terminators
-            const nextToken = this.peek();
-            if (nextToken.type === 'SEMICOLON' || nextToken.type === 'NEWLINE' || nextToken.type === 'BACKGROUND') {
-                this.advance();
-            }
-            else if (nextToken.type !== 'EOF' && !node) {
-                // Stuck, skip token to avoid infinite loop
-                this.advance();
-            }
-        }
-        return {
-            type: 'Program',
-            body,
-            errors: this.errors.length > 0 ? this.errors : undefined,
-        };
-    }
-}
-// ============================================================================
-// Public API
-// ============================================================================
-/**
- * Parse a bash command string into an AST
- *
- * @example
- * ```typescript
- * const ast = parse('ls -la | grep foo')
- * // Returns Program with Pipeline containing two Commands
- * ```
- */
-export function parse(input) {
-    // Handle empty or whitespace-only input
-    const trimmed = input.trim();
-    if (trimmed === '') {
-        return {
-            type: 'Program',
-            body: [],
-            errors: undefined,
-        };
-    }
-    const lexer = new Lexer(input);
-    const tokens = lexer.tokenize();
-    const parser = new Parser(tokens, lexer.errors);
-    return parser.parse();
-}
-/**
- * Check if input is syntactically valid bash
- */
-export function isValidSyntax(input) {
-    const ast = parse(input);
-    return !ast.errors || ast.errors.length === 0;
-}
-//# sourceMappingURL=parser.js.map