feat: implement control flow execution and fix parsing

Status	File	+	-
A	`.fackr/workspace.json`	29	0
M	`crates/rush-cli/src/main.rs`	46	25
A	`crates/rush-executor/src/control_flow.rs`	161	0
M	`crates/rush-executor/src/lib.rs`	2	0
M	`crates/rush-parser/src/ast.rs`	3	1
M	`crates/rush-parser/src/grammar.pest`	22	14
M	`crates/rush-parser/src/parser.rs`	44	2
A	`docs/RUSH.md`	10	0
A	`docs/roadmap_overview.md`	114	0
A	`docs/roadmap_phase0.md`	29	0
A	`docs/roadmap_phase1.md`	62	0

.fackr/workspace.jsonadded

++{
++  "active_tab": 0,
++  "tabs": [
++    {
++      "files": [
++        {
++          "path": "RUSH.md",
++          "is_orphan": false
++        }
++      ],
++      "active_pane": 0,
++      "panes": [
++        {
++          "buffer_idx": 0,
++          "cursor_line": 9,
++          "cursor_col": 71,
++          "viewport_line": 0,
++          "viewport_col": 0,
++          "bounds": {
++            "x_start": 0.0,
++            "y_start": 0.0,
++            "x_end": 1.0,
++            "y_end": 1.0
++          }
++        }
++      ]
++    }
++  ]
++}

crates/rush-cli/src/main.rsmodified

      };
      let mut context = Context::new();
--    let mut last_exit_code = 0;
++    // Parse and execute the entire file as one unit to support multi-line control flow
--    for line in content.lines() {
++    match execute_line(&content, &mut context, false) {
--        match execute_line(line, &mut context, false) {
++        Ok(code) => ExitCode::from(code as u8),
--            Ok(code) => last_exit_code = code,
++        Err(e) => {
--            Err(e) => {
++            eprintln!("rush: {}", e);
--                eprintln!("rush: {}", e);
++            ExitCode::from(1)
--                last_exit_code = 1;
--            }
+         }
+     }
--
--    ExitCode::from(last_exit_code as u8)
+ }
  /// Execute commands from stdin
  /// Execute a single line of shell input
  fn execute_line(line: &str, context: &mut Context, interactive: bool) -> Result<i32, String> {
--    use rush_executor::{execute_pipeline, execute_simple_with_redirects};
++    use rush_parser::{parse_line, Statement};
--    use rush_parser::{parse_line, CompleteCommand, Statement};
      let statement = parse_line(line).map_err(|e| e.to_string())?;
          Statement::Complete(complete_cmd) => {
              execute_complete_command(&complete_cmd, context, interactive)
+         }
++        Statement::Script(commands) => {
++            let mut last_exit_code = 0;
++            for cmd in commands {
++                last_exit_code = execute_complete_command(&cmd, context, interactive)?;
++            }
++            Ok(last_exit_code)
++        }
+     }
+ }
      context: &mut Context,
      interactive: bool,
  ) -> Result<i32, String> {
--    use rush_executor::{execute_and_or_list, execute_pipeline, execute_simple_with_redirects};
++    use rush_executor::{
++        execute_and_or_list, execute_case, execute_for, execute_if, execute_pipeline,
++        execute_simple_with_redirects, execute_while,
++    };
      use rush_parser::CompleteCommand;
      match cmd {
              context.set_exit_status(exit_code);
              Ok(exit_code)
+         }
--        CompleteCommand::If(_) => {
++        CompleteCommand::If(if_stmt) => {
--            // TODO: Implement if statement execution
++            let exit_code = execute_if(if_stmt, context)
--            Err("If statements not yet implemented".to_string())
++                .map(|result| result.exit_code())
++                .map_err(|e| e.to_string())?;
++
++            context.set_exit_status(exit_code);
++            Ok(exit_code)
+         }
--        CompleteCommand::While(_) => {
++        CompleteCommand::While(while_stmt) => {
--            // TODO: Implement while loop execution
++            let exit_code = execute_while(while_stmt, context)
--            Err("While loops not yet implemented".to_string())
++                .map(|result| result.exit_code())
++                .map_err(|e| e.to_string())?;
++
++            context.set_exit_status(exit_code);
++            Ok(exit_code)
+         }
--        CompleteCommand::For(_) => {
++        CompleteCommand::For(for_stmt) => {
--            // TODO: Implement for loop execution
++            let exit_code = execute_for(for_stmt, context)
--            Err("For loops not yet implemented".to_string())
++                .map(|result| result.exit_code())
++                .map_err(|e| e.to_string())?;
++
++            context.set_exit_status(exit_code);
++            Ok(exit_code)
+         }
--        CompleteCommand::Case(_) => {
++        CompleteCommand::Case(case_stmt) => {
--            // TODO: Implement case statement execution
++            let exit_code = execute_case(case_stmt, context)
--            Err("Case statements not yet implemented".to_string())
++                .map(|result| result.exit_code())
++                .map_err(|e| e.to_string())?;
++
++            context.set_exit_status(exit_code);
++            Ok(exit_code)
+         }
+     }
+ }

crates/rush-executor/src/control_flow.rsadded

++use rush_expand::Context;
++use rush_parser::{CaseStatement, CompleteCommand, ForStatement, IfStatement, WhileStatement};
++use crate::{ExecutionResult, PipelineError};
++
++/// Execute an if statement
++pub fn execute_if(
++    if_stmt: &IfStatement,
++    context: &mut Context,
++) -> Result<ExecutionResult, PipelineError> {
++    // Execute the condition and check if it succeeded
++    let condition_result = execute_complete_command(&if_stmt.condition, context)?;
++
++    if condition_result.success() {
++        // Condition was true, execute then body
++        execute_command_list(&if_stmt.then_body, context)
++    } else {
++        // Check elif clauses
++        for elif in &if_stmt.elif_clauses {
++            let elif_result = execute_complete_command(&elif.condition, context)?;
++            if elif_result.success() {
++                return execute_command_list(&elif.then_body, context);
++            }
++        }
++
++        // No elif matched, execute else body if present
++        if let Some(else_body) = &if_stmt.else_body {
++            execute_command_list(else_body, context)
++        } else {
++            // No else clause, return success (standard shell behavior)
++            Ok(crate::command::success_result())
++        }
++    }
++}
++
++/// Execute a while loop
++pub fn execute_while(
++    while_stmt: &WhileStatement,
++    context: &mut Context,
++) -> Result<ExecutionResult, PipelineError> {
++    let mut last_result = crate::command::success_result();
++
++    loop {
++        // Execute the condition
++        let condition_result = execute_complete_command(&while_stmt.condition, context)?;
++
++        if !condition_result.success() {
++            // Condition failed, exit loop
++            break;
++        }
++
++        // Execute the loop body
++        last_result = execute_command_list(&while_stmt.body, context)?;
++    }
++
++    Ok(last_result)
++}
++
++/// Execute a for loop
++pub fn execute_for(
++    for_stmt: &ForStatement,
++    context: &mut Context,
++) -> Result<ExecutionResult, PipelineError> {
++    use rush_expand::expand_word;
++
++    let mut last_result = crate::command::success_result();
++
++    // Expand all the words in the list
++    let mut values = Vec::new();
++    for word in &for_stmt.words {
++        let expanded = expand_word(word, context)
++            .map_err(|e| PipelineError::ExpansionError(e.to_string()))?;
++        values.push(expanded);
++    }
++
++    // Execute the loop body for each value
++    for value in values {
++        // Set the loop variable
++        context.set_var(&for_stmt.var_name, &value);
++
++        // Execute the loop body
++        last_result = execute_command_list(&for_stmt.body, context)?;
++    }
++
++    Ok(last_result)
++}
++
++/// Execute a case statement
++pub fn execute_case(
++    case_stmt: &CaseStatement,
++    context: &mut Context,
++) -> Result<ExecutionResult, PipelineError> {
++    use rush_expand::expand_word;
++
++    // Expand the word to match against
++    let word_value = expand_word(&case_stmt.word, context)
++        .map_err(|e| PipelineError::ExpansionError(e.to_string()))?;
++
++    // Try each case clause
++    for clause in &case_stmt.clauses {
++        // Check if any pattern matches
++        for pattern in &clause.patterns {
++            let pattern_value = expand_word(pattern, context)
++                .map_err(|e| PipelineError::ExpansionError(e.to_string()))?;
++
++            // TODO: Implement glob pattern matching
++            // For now, just do exact string matching
++            if word_value == pattern_value {
++                // Pattern matched, execute this clause's commands
++                return execute_command_list(&clause.body, context);
++            }
++        }
++    }
++
++    // No clause matched, return success (standard shell behavior)
++    Ok(crate::command::success_result())
++}
++
++/// Execute a complete command (helper for recursive execution)
++fn execute_complete_command(
++    cmd: &CompleteCommand,
++    context: &mut Context,
++) -> Result<ExecutionResult, PipelineError> {
++    match cmd {
++        CompleteCommand::Simple(simple_cmd) => {
++            Ok(crate::execute_simple_with_redirects(simple_cmd, context, false)?)
++        }
++        CompleteCommand::Pipeline(pipeline) => {
++            crate::execute_pipeline(pipeline, context)
++        }
++        CompleteCommand::AndOrList(and_or_list) => {
++            crate::execute_and_or_list(and_or_list, context)
++        }
++        CompleteCommand::If(if_stmt) => {
++            execute_if(if_stmt, context)
++        }
++        CompleteCommand::While(while_stmt) => {
++            execute_while(while_stmt, context)
++        }
++        CompleteCommand::For(for_stmt) => {
++            execute_for(for_stmt, context)
++        }
++        CompleteCommand::Case(case_stmt) => {
++            execute_case(case_stmt, context)
++        }
++    }
++}
++
++/// Execute a list of commands
++fn execute_command_list(
++    commands: &[CompleteCommand],
++    context: &mut Context,
++) -> Result<ExecutionResult, PipelineError> {
++    let mut last_result = crate::command::success_result();
++
++    for cmd in commands {
++        last_result = execute_complete_command(cmd, context)?;
++        context.set_exit_status(last_result.exit_code());
++    }
++
++    Ok(last_result)
++}

crates/rush-executor/src/lib.rsmodified

  // Rush executor - Command execution engine
  pub mod command;
++pub mod control_flow;
  pub mod pipeline;
  pub mod redirect;
  pub mod terminal;
  pub mod test_builtin;
  pub use command::{execute_command, ExecutionError, ExecutionResult};
++pub use control_flow::{execute_case, execute_for, execute_if, execute_while};
  pub use pipeline::{execute_and_or_list, execute_pipeline, execute_simple_with_redirects, PipelineError};
  pub use redirect::RedirectError;

crates/rush-parser/src/ast.rsmodified

  #[derive(Debug, Clone, PartialEq, Eq)]
  pub enum Statement {
--    /// Complete command (simple, pipeline, control flow, etc.)
++    /// Single complete command (simple, pipeline, control flow, etc.)
      Complete(CompleteCommand),
++    /// Multiple complete commands (for scripts with multiple top-level commands)
++    Script(Vec<CompleteCommand>),
      /// Empty line or comment
      Empty,
  }

crates/rush-parser/src/grammar.pestmodified

  COMMENT = _{ "#" ~ (!NEWLINE ~ ANY)* }
  // Top-level input
--input = { SOI ~ ws* ~ command_line ~ ws* ~ EOI }
++trailing_sep = _{ (NEWLINE | ";")* }
++input = { SOI ~ ws* ~ command_line ~ ws* ~ trailing_sep ~ ws* ~ EOI }
--// Command line: can be compound commands or pipelines
++// Command line: can be multiple complete commands separated by newlines/semicolons
--command_line = { complete_command? }
++command_line = { (complete_command ~ (separator ~ complete_command)* ~ separator?)? }
  // Complete command: can be a compound command or an and_or list
  complete_command = {
  pipeline = { simple_command ~ (ws* ~ "|" ~ ws* ~ simple_command)* }
  // Control flow statements
++// Keywords must be followed by whitespace, separator, or EOI (not word characters)
++keyword_boundary = _{ &(ws | NEWLINE | ";" | EOI) }
++
  if_statement = {
--    "if" ~ separator ~ complete_command ~ separator ~ "then" ~ separator ~ command_list ~ separator
++    "if" ~ keyword_boundary ~ separator ~ complete_command ~ separator ~ "then" ~ keyword_boundary ~ separator ~ command_list ~ separator
      ~ elif_clause*
      ~ else_clause?
--    ~ "fi"
++    ~ "fi" ~ keyword_boundary
+ }
  elif_clause = {
--    "elif" ~ separator ~ complete_command ~ separator ~ "then" ~ separator ~ command_list ~ separator
++    "elif" ~ keyword_boundary ~ separator ~ complete_command ~ separator ~ "then" ~ keyword_boundary ~ separator ~ command_list ~ separator
+ }
  else_clause = {
--    "else" ~ separator ~ command_list ~ separator
++    "else" ~ keyword_boundary ~ separator ~ command_list ~ separator
+ }
  while_statement = {
--    "while" ~ separator ~ complete_command ~ separator ~ "do" ~ separator ~ command_list ~ separator ~ "done"
++    "while" ~ keyword_boundary ~ separator ~ complete_command ~ separator ~ "do" ~ keyword_boundary ~ separator ~ command_list ~ separator ~ "done" ~ keyword_boundary
+ }
  for_statement = {
--    "for" ~ ws+ ~ var_name ~ ws+ ~ "in" ~ (ws+ ~ word)* ~ separator ~ "do" ~ separator ~ command_list ~ separator ~ "done"
++    "for" ~ keyword_boundary ~ ws+ ~ var_name ~ ws+ ~ "in" ~ keyword_boundary ~ (ws+ ~ word)* ~ separator ~ "do" ~ keyword_boundary ~ separator ~ command_list ~ separator ~ "done" ~ keyword_boundary
+ }
  case_statement = {
--    "case" ~ ws+ ~ word ~ ws+ ~ "in" ~ separator ~ case_clause* ~ "esac"
++    "case" ~ keyword_boundary ~ ws+ ~ word ~ ws+ ~ "in" ~ keyword_boundary ~ separator ~ case_clause* ~ "esac" ~ keyword_boundary
+ }
  case_clause = {
  pattern = { word }
  // Command list: one or more complete commands separated by newlines or semicolons
--command_list = { (complete_command ~ separator)* ~ complete_command? }
++command_list = { complete_command ~ (separator ~ complete_command)* }
  // Separator: newlines, semicolons, or whitespace
  separator = _{ (ws* ~ (NEWLINE | ";") ~ ws*)+ | ws+ }
  command_substitution = { "$(" ~ command_subst_content ~ ")" }
  command_subst_content = @{ (!(")" | NEWLINE) ~ ANY)* }
++// Reserved keywords that cannot be used as bare words
++keyword = { ("if" | "then" | "elif" | "else" | "fi" | "while" | "do" | "done" | "for" | "in" | "case" | "esac") ~ &(ws | NEWLINE | ";" | EOI) }
++
  // Bare word part: literal text (no special characters)
--// Note: We exclude $, |, &, <, > to handle expansion, pipes, operators, and redirects separately
++// Note: We exclude $, |, &, <, >, ; to handle expansion, pipes, operators, redirects, and separators
  // "=" is allowed in words (needed for test command), assignments use explicit var_name pattern
--bare_word_part = @{ (!(" " | "\t" | NEWLINE | "#" | "\"" | "'" | "$" | "|" | "&" | "<" | ">") ~ ANY)+ }
++// Keywords are reserved and cannot be used as bare words
++bare_word_part = @{ !keyword ~ (!(" " | "\t" | NEWLINE | "#" | "\"" | "'" | "$" | "|" | "&" | "<" | ">" | ";") ~ ANY)+ }
  // Quoted strings (single quotes prevent expansion, double quotes allow it)
  quoted_string = { double_quoted | single_quoted }
  // Single quotes: no expansion (literal)
  single_quoted = @{ "'" ~ (!"'" ~ ANY)* ~ "'" }
--NEWLINE = { "\n" | "\r\n" }
++NEWLINE = _{ "\n" | "\r\n" }

crates/rush-parser/src/parser.rsmodified

+ }
  fn parse_command_line(pair: pest::iterators::Pair<Rule>) -> Result<Statement, ParseError> {
++    let mut commands = Vec::new();
++
      for inner_pair in pair.into_inner() {
          match inner_pair.as_rule() {
              Rule::complete_command => {
--                return Ok(Statement::Complete(parse_complete_command(inner_pair)?));
++                commands.push(parse_complete_command(inner_pair)?);
+             }
              _ => return Err(ParseError::UnexpectedRule(inner_pair.as_rule())),
+         }
+     }
--    Ok(Statement::Empty)
++
++    match commands.len() {
++        0 => Ok(Statement::Empty),
++        1 => Ok(Statement::Complete(commands.into_iter().next().unwrap())),
++        _ => Ok(Statement::Script(commands)),
++    }
+ }
  fn parse_complete_command(pair: pest::iterators::Pair<Rule>) -> Result<CompleteCommand, ParseError> {
              _ => panic!("Expected Pipeline"),
+         }
+     }
++
++    #[test]
++    fn test_parse_if_statement_newlines() {
++        let input = "if test 5 -eq 5\nthen\necho equal\nfi";
++        let result = parse_line(input);
++        match result {
++            Ok(Statement::Complete(CompleteCommand::If(_))) => {}
++            Ok(other) => panic!("Expected If, got: {:?}", other),
++            Err(e) => panic!("Parse error: {}", e),
++        }
++    }
++
++    #[test]
++    fn test_parse_if_statement() {
++        let input = "if test 5 -eq 5; then echo equal; fi";
++        let result = parse_line(input);
++        match result {
++            Ok(Statement::Complete(CompleteCommand::If(_))) => {}
++            Ok(other) => panic!("Expected If, got: {:?}", other),
++            Err(e) => panic!("Parse error: {}", e),
++        }
++    }
++
++    #[test]
++    fn test_parse_multiline_script() {
++        let input = "echo hello\necho world\n";
++        let result = parse_line(input);
++        match result {
++            Ok(Statement::Script(cmds)) => {
++                assert_eq!(cmds.len(), 2);
++            }
++            Ok(other) => panic!("Expected Script, got: {:?}", other),
++            Err(e) => panic!("Parse error: {}", e),
++        }
++    }
+ }

docs/RUSH.mdadded

++# RUSH
++the rust shell
++
++rush aims to be a modern, friendly, and fast shell
++
++it should have 100% parity with bash, but also have some of the friendly features of fish.
++
++it should follow all standard shell protocols and follow other FOSS projects for guidance.
++
++we commit often and avoid coauthorship and Generated with ... messages.

docs/roadmap_overview.mdadded

++# Rush Shell - Development Roadmap
++
++## Vision
++
++A modern, friendly, and fast shell with 100% bash compatibility and fish-like features.
++
++## Development Approach
++
++**Incremental**: Start with minimal working REPL, add features iteratively. Each phase produces a working shell with progressively more capabilities.
++
++## Phases
++
++### Phase 0: Project Setup ✅
++**Status**: Completed
++**Goal**: Establish workspace structure
++- 7-crate workspace architecture
++- All dependencies configured
++- Directory structure established
++
++### Phase 1: Minimal REPL 🔜
++**Status**: Next
++**Goal**: Interactive shell that executes basic commands
++- Simple command parsing
++- External command execution
++- Basic REPL with reedline
++- **Validation**: Can run `ls`, `pwd`, `echo hello world`
++
++### Phase 2: Variables & Expansion
++**Goal**: Shell variables and expansions
++- Variable assignments and references
++- Parameter expansion (`${VAR}`, `${VAR:-default}`)
++- Command substitution `$(cmd)`
++- Word splitting
++
++### Phase 3: Pipelines & Redirection
++**Goal**: Pipelines and I/O redirection
++- Pipeline syntax: `cmd1 | cmd2 | cmd3`
++- Redirections: `<`, `>`, `>>`, `2>`, `2>&1`, `&>`
++- Pipe creation and management
++
++### Phase 4: Control Flow
++**Goal**: if/while/for/case statements
++- Conditional evaluation (if/then/else/fi)
++- Loop constructs (while/for)
++- Case statement matching
++- Built-in test command
++
++### Phase 5: Job Control
++**Goal**: Background jobs, fg/bg, signals
++- Job tracking and process groups
++- Terminal control
++- Signal handling (SIGCHLD, SIGTSTP, SIGINT)
++- Built-ins: `jobs`, `fg`, `bg`
++
++### Phase 6: Fish Features
++**Goal**: Syntax highlighting, suggestions, completions
++- Real-time syntax highlighting
++- History-based auto-suggestions
++- Smart tab completion
++- Better error messages
++
++### Phase 7: Bash Compatibility Hardening
++**Goal**: Close compatibility gaps
++- Extended glob patterns
++- Advanced parameter expansion
++- Brace expansion, arithmetic expansion
++- Here-documents, functions, arrays, subshells
++
++## Success Criteria
++
++- **Phase 1-3**: Daily command-line use (files, git, basic scripts)
++- **Phase 4-5**: Run moderately complex bash scripts unmodified
++- **Phase 6**: Better UX than bash for interactive use
++- **Phase 7**: 90%+ compatibility with common bash patterns
++
++## Key Features
++
++### Bash Compatibility
++- Command execution and pipelines
++- Variables and expansions
++- Control flow (if/while/for/case)
++- Job control
++- Full POSIX shell compliance
++
++### Fish-Inspired Features
++- Syntax highlighting
++- Autosuggestions from history
++- Better error messages
++- Improved tab completion
++
++## Architecture
++
++7-crate modular design:
++- **rush-cli**: Main binary and REPL orchestration
++- **rush-parser**: Pest PEG parser for shell syntax
++- **rush-expand**: Variable/glob expansion engine
++- **rush-executor**: Command execution and pipelines
++- **rush-job**: Job control and process management
++- **rush-eval**: Control flow evaluation engine
++- **rush-interactive**: Fish-like interactive features
++
++## Technology Stack
++
++- **Parser**: Pest (PEG)
++- **REPL**: reedline
++- **Terminal**: crossterm
++- **Unix APIs**: nix
++- **Glob**: globset
++- **Error handling**: thiserror
++
++## Current Status
++
++**Phase 0**: ✅ Complete - Workspace established and compiling
++**Phase 1**: 🔜 Ready to begin - Minimal REPL implementation next

docs/roadmap_phase0.mdadded

++# Phase 0: Project Setup
++
++**Status**: ✅ Completed
++**Goal**: Establish workspace structure
++
++## Tasks
++
++- [x] Initialize Cargo workspace with all 7 crates
++- [x] Add dependencies to each crate's Cargo.toml
++- [x] Create basic crate structure (lib.rs/main.rs files)
++- [x] Set up directory structure
++
++## Deliverable
++
++✅ Compiling workspace with placeholder code
++
++## Crates Created
++
++1. **rush-cli** - Main binary and REPL (binary crate)
++2. **rush-parser** - Lexer/parser (library)
++3. **rush-expand** - Variable/glob expansion (library)
++4. **rush-executor** - Command execution (library)
++5. **rush-job** - Job control (library)
++6. **rush-eval** - Control flow evaluation (library)
++7. **rush-interactive** - Fish-like features (library)
++
++## Next Steps
++
++Proceed to Phase 1: Minimal REPL

docs/roadmap_phase1.mdadded

++# Phase 1: Minimal Shell (Interactive + Non-Interactive)
++
++**Status**: 🚧 In Progress
++**Goal**: Full-featured shell that executes basic commands in both interactive and non-interactive modes
++
++## Tasks
++
++### rush-cli
++- [ ] Command-line argument parsing (clap)
++  - [ ] Interactive mode (default when terminal)
++  - [ ] `-c "command"` flag for command strings
++  - [ ] Script file execution
++  - [ ] Stdin detection (isatty)
++- [ ] Interactive mode with reedline
++  - [ ] Basic REPL loop (read → parse → execute → print)
++  - [ ] Prompt rendering
++  - [ ] Ctrl+C and Ctrl+D handling
++- [ ] Non-interactive mode
++  - [ ] Read from file
++  - [ ] Read from stdin
++  - [ ] Execute and exit with proper status code
++
++### rush-parser
++- [ ] Create minimal pest grammar (simple commands only)
++- [ ] Define AST types: `SimpleCommand { args: Vec<String> }`
++- [ ] Implement parser that handles: `ls`, `echo hello`, `cat file.txt`
++- [ ] Handle empty lines and comments (#)
++
++### rush-executor
++- [ ] Execute external commands via `std::process::Command`
++- [ ] PATH resolution
++- [ ] Return exit codes
++- [ ] Proper stdout/stderr handling
++- [ ] Environment variable inheritance
++
++## Validation Criteria
++
++### Interactive Mode
++Must be able to run interactively:
++- `ls`
++- `pwd`
++- `echo hello world`
++- Exit with Ctrl+D or `exit` command
++
++### Non-Interactive Mode
++Must work with:
++- `rush -c "ls"`
++- `echo "pwd" | rush`
++- `rush script.sh` (where script.sh contains commands)
++- Proper exit codes (0 on success, non-zero on failure)
++
++## Files to Create
++
++1. `crates/rush-parser/src/grammar.pest` - Pest PEG grammar
++2. `crates/rush-parser/src/ast.rs` - AST type definitions
++3. `crates/rush-parser/src/parser.rs` - Parser implementation
++4. `crates/rush-cli/src/repl.rs` - REPL loop
++5. `crates/rush-executor/src/command.rs` - Command execution
++
++## Next Steps
++
++After Phase 1 completion, proceed to Phase 2: Variables & Expansion

tenseleyflow/rush / `8a29037`

11 changed files