dotdo 0.0.1 → 0.0.2

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

@@ -0,0 +1,1488 @@
+/**
+ * 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