Phase 3: stack traces + REPL upgrades

* Stack traces. Errors raised inside a user function now carry the
  call chain, innermost frame first:
    Error: <msg>
      at inner
      at middle
      at outer
  Both engines produce identical traces. Tree-walk: each
  invoke_user_function appends its own frame on the error path. VM:
  run_function gained a wrapper that pushes a call frame on entry,
  pops on exit, and appends to the message on Err. Source line
  numbers are TODO (would require AST span threading).

  Bonus: VM run_function previously leaked a scope frame on `?`-style
  errors (vm_pop_scope was only reached on the success path). The
  new wrapper rescues the scope on the error path too.

* REPL upgrades. The interactive shell now:
  - Evaluates and prints bare expressions: `1 + 2` shows `3`. Parser
    error "Expected Semicolon" + balanced braces + no trailing `;`
    triggers re-parse with `;` appended.
  - Continues multi-line input until braces/parens are balanced. The
    is_balanced helper ignores chars inside string literals.
  - REPL meta-commands: :help, :quit, :reset.
  - Prompt switches to "...> " during continuation.

* Parser: `arr[idx]` / `dict[key]` work in expression position. The
  Statement::Assignment dispatch previously committed to Statement::
  IndexAssignment as soon as it saw `Ident[`, then unconditionally
  expected `=`. Now it lookaheads after `]` and falls back to
  expression-statement parsing if the `=` isn't there. Without this,
  bare `d["key"]` at the REPL hit "Expected Eq, got Eof".

41/41 functional examples produce identical output under tree-walk
and VM. 92/92 unit tests pass.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>

Author: RandomCoder-lab

omnimcode-core/src/interpreter.rs

@@ -35,6 +35,12 @@ pub struct Interpreter {
     /// reason as test_failures: a plain OMC global wouldn't propagate
     /// to nested assertion calls.
     test_current_name: std::cell::RefCell<String>,
+    /// Names of currently-executing user functions, innermost-last.
+    /// Pushed at the entry of invoke_user_function, popped on exit
+    /// (success OR failure). Used to render call traces on errors —
+    /// future work will also attach source line numbers via per-op
+    /// metadata in CompiledFunction.
+    call_stack: Vec<String>,
 }
 
 impl Interpreter {
@@ -57,6 +63,7 @@ impl Interpreter {
             lambda_counter: 0,
             test_failures: std::cell::RefCell::new(Vec::new()),
             test_current_name: std::cell::RefCell::new(String::new()),
+            call_stack: Vec::new(),
         }
     }
 
@@ -3337,15 +3344,34 @@ impl Interpreter {
             self.set_var(param.clone(), arg);
         }
 
+        // Push a call-stack frame so error messages can show
+        // who-called-whom. The frame is popped in BOTH the success
+        // and error paths so the trace doesn't leak across calls.
+        self.call_stack.push(name.to_string());
+
+        let mut exec_err: Option<String> = None;
         for stmt in body {
-            self.execute_stmt(stmt)?;
+            if let Err(e) = self.execute_stmt(stmt) {
+                exec_err = Some(e);
+                break;
+            }
             if self.return_value.is_some() {
                 break;
             }
         }
 
-        let result = self.return_value.take().unwrap_or(Value::Null);
+        self.call_stack.pop();
         self.locals.pop();
+
+        if let Some(e) = exec_err {
+            // Append our own frame and rethrow. Each invoke_user_function
+            // up the stack does the same, so the final message lists
+            // every frame innermost-first. Mirrors VM run_function's
+            // error-path formatting.
+            return Err(format!("{}\n  at {}", e, name));
+        }
+
+        let result = self.return_value.take().unwrap_or(Value::Null);
         Ok(result)
     }
 
@@ -3457,6 +3483,41 @@ impl Interpreter {
         self.return_value.take()
     }
 
+    /// Push a call-stack frame (function name only for now). The VM
+    /// calls this at the entry of run_function so error traces work
+    /// for VM-dispatched calls too, not just tree-walk.
+    pub fn push_call_frame(&mut self, name: &str) {
+        self.call_stack.push(name.to_string());
+    }
+
+    /// REPL-facing: evaluate a single expression in the current
+    /// interpreter state. Used to implement Python-style
+    /// "type-an-expression-and-see-the-value" at the prompt.
+    pub fn eval_for_repl(&mut self, expr: &Expression) -> Result<Value, String> {
+        self.eval_expr(expr)
+    }
+
+    /// Pop a call-stack frame. Counterpart to push_call_frame; called
+    /// in BOTH the success and error paths so the trace can't leak
+    /// across calls.
+    pub fn pop_call_frame(&mut self) {
+        self.call_stack.pop();
+    }
+
+    /// Format an error message with the current call stack appended.
+    /// Used by VM run_function on its error-return path to give the
+    /// same kind of trace tree-walk produces. Innermost frame first.
+    pub fn format_error_with_trace(&self, msg: &str) -> String {
+        if msg.contains("\n  at ") {
+            return msg.to_string();
+        }
+        let mut out = msg.to_string();
+        for fname in self.call_stack.iter().rev() {
+            out.push_str(&format!("\n  at {}", fname));
+        }
+        out
+    }
+
     /// VM-facing: same idea for break/continue flags. Returns and
     /// clears the flag.
     pub fn vm_take_break(&mut self) -> bool {

omnimcode-core/src/main.rs

@@ -254,56 +254,176 @@ fn execute_program(source: &str) -> Result<(), String> {
 }
 
 fn repl() {
-    println!("═══════════════════════════════════════════════════════════════");
-    println!("         OMNIcode Interactive Shell (v1.0.0-standalone)         ");
-    println!("═══════════════════════════════════════════════════════════════");
-    println!();
-    println!("Type OMNIcode statements. Press Ctrl+C to exit.");
+    println!("OMNIcode interactive shell");
+    println!("Type :help for commands, :quit to exit. Statements end with ;");
     println!();
 
     let stdin = io::stdin();
     let mut interpreter = Interpreter::new();
-    let mut input_buffer = String::new();
+    let mut buffer = String::new();
+    let mut continuing = false;
 
     loop {
-        print!("omc> ");
+        print!("{}", if continuing { "...> " } else { "omc> " });
         io::stdout().flush().unwrap();
 
-        input_buffer.clear();
-        match stdin.read_line(&mut input_buffer) {
-            Ok(0) => break, // EOF
-            Ok(_) => {
-                if input_buffer.trim().is_empty() {
+        let mut line = String::new();
+        match stdin.read_line(&mut line) {
+            Ok(0) => { println!(); break; }
+            Err(e) => { eprintln!("Error reading input: {}", e); break; }
+            Ok(_) => {}
+        }
+
+        let trimmed = line.trim();
+
+        // REPL meta-commands (only at the start of a fresh input).
+        if !continuing {
+            match trimmed {
+                "" => continue,
+                ":quit" | ":q" | ":exit" => break,
+                ":help" | ":h" | ":?" => {
+                    repl_print_help();
                     continue;
                 }
+                ":reset" => {
+                    interpreter = Interpreter::new();
+                    println!("interpreter state reset");
+                    continue;
+                }
+                _ => {}
+            }
+        }
+
+        buffer.push_str(&line);
+
+        // Heuristic for multi-line input: count unmatched braces/parens/brackets.
+        // If they're unbalanced (more openers than closers), keep reading.
+        // Skips characters inside string literals so `"{"` doesn't confuse us.
+        if !is_balanced(&buffer) {
+            continuing = true;
+            continue;
+        }
 
-                // Try to parse and execute
-                let trimmed = input_buffer.trim();
-                let mut parser = Parser::new(trimmed);
-                
-                match parser.parse() {
+        // First attempt: parse as-typed.
+        let trimmed_buffer = buffer.trim().to_string();
+        let mut parser = Parser::new(&trimmed_buffer);
+        match parser.parse() {
+            Ok(statements) => {
+                continuing = false;
+                let to_run = buffer.clone();
+                buffer.clear();
+                repl_execute(&mut interpreter, &to_run, statements);
+            }
+            Err(msg) if msg.contains("Semicolon") && !trimmed_buffer.ends_with(';') => {
+                // Bare-expression mode: parser wanted a `;` but the
+                // user hit enter without one. Try parsing with `;`
+                // appended; if that yields a single Expression
+                // statement, evaluate it and print the result. This
+                // is what makes `1 + 2` (no semicolon) print 3.
+                let with_semi = format!("{};", trimmed_buffer);
+                let mut p2 = Parser::new(&with_semi);
+                match p2.parse() {
                     Ok(statements) => {
-                        match interpreter.execute(statements) {
-                            Ok(()) => {},
-                            Err(e) => eprintln!("Error: {}", e),
-                        }
+                        continuing = false;
+                        let to_run = buffer.clone();
+                        buffer.clear();
+                        repl_execute(&mut interpreter, &to_run, statements);
                     }
-                    Err(e) => {
-                        eprintln!("Parse error: {}", e);
+                    Err(msg2) => {
+                        eprintln!("Parse error: {}", msg2);
+                        continuing = false;
+                        buffer.clear();
                     }
                 }
             }
-            Err(e) => {
-                eprintln!("Error reading input: {}", e);
-                break;
+            Err(msg) => {
+                // Other parse errors that look like "needs more input"
+                // (unterminated string, missing closing brace not caught
+                // by is_balanced) → ask for another line. Otherwise
+                // show the error and reset.
+                if msg.contains("Eof") || msg.contains("end of") {
+                    continuing = true;
+                } else {
+                    eprintln!("Parse error: {}", msg);
+                    continuing = false;
+                    buffer.clear();
+                }
             }
         }
     }
 
+    println!("bye");
+}
+
+fn repl_print_help() {
+    println!("REPL commands:");
+    println!("  :help, :h, :?   show this message");
+    println!("  :quit, :q       exit the REPL");
+    println!("  :reset          discard all defined variables and functions");
     println!();
-    println!("═══════════════════════════════════════════════════════════════");
-    println!("Thank you for using OMNIcode!");
-    println!("═══════════════════════════════════════════════════════════════");
+    println!("Tips:");
+    println!("  Statements need a trailing `;`. Multi-line input continues");
+    println!("  while braces/parens are unbalanced (use a closing `}}` or");
+    println!("  `)` to finish). Type a bare expression with `;` to see its");
+    println!("  result via println().");
+}
+
+/// Run a parsed REPL input. If the input is a single expression
+/// statement (with no trailing semicolon in the source), evaluate it
+/// and print the result — Python REPL style. Otherwise execute as
+/// normal statements.
+fn repl_execute(
+    interp: &mut Interpreter,
+    raw_source: &str,
+    statements: Vec<omnimcode_core::ast::Statement>,
+) {
+    use omnimcode_core::ast::Statement;
+    // Detect implicit-print case: exactly one Expression statement
+    // and the source has no trailing `;`. This makes `1 + 2` (no
+    // semicolon) print `3`, while `1 + 2;` runs silently.
+    let trimmed = raw_source.trim();
+    let is_bare_expr = !trimmed.ends_with(';')
+        && statements.len() == 1
+        && matches!(&statements[0], Statement::Expression(_));
+
+    if is_bare_expr {
+        if let Statement::Expression(e) = &statements[0] {
+            match interp.eval_for_repl(e) {
+                Ok(v) => println!("{}", v.to_display_string()),
+                Err(msg) => eprintln!("Error: {}", msg),
+            }
+            return;
+        }
+    }
+
+    if let Err(e) = interp.execute(statements) {
+        eprintln!("Error: {}", e);
+    }
+}
+
+/// Counts unmatched openers in `s`, ignoring contents of string
+/// literals. Returns true when all brackets/parens/braces are balanced
+/// — i.e. when the REPL can attempt to parse the input.
+fn is_balanced(s: &str) -> bool {
+    let mut depth: i32 = 0;
+    let mut in_str = false;
+    let mut prev = '\0';
+    for c in s.chars() {
+        if in_str {
+            // Honor backslash escapes so `"\""` doesn't end the string early.
+            if c == '"' && prev != '\\' { in_str = false; }
+            prev = c;
+            continue;
+        }
+        match c {
+            '"' => in_str = true,
+            '(' | '[' | '{' => depth += 1,
+            ')' | ']' | '}' => depth -= 1,
+            _ => {}
+        }
+        prev = c;
+    }
+    depth <= 0 && !in_str
 }
 
 #[cfg(test)]

omnimcode-core/src/parser.rs

@@ -779,17 +779,33 @@ impl Parser {
                         })
                     }
                     Token::LBracket => {
+                        // Could be `arr[idx] = value;` (IndexAssignment) or
+                        // `arr[idx];` / `arr[idx] + 1;` (expression statement).
+                        // Distinguish by what follows the `]`. If `=`, it's
+                        // an assignment; otherwise rewind and re-parse as
+                        // an expression statement so dict / array indexing
+                        // works in expression position too.
+                        let pre_lbracket = checkpoint.clone();
                         self.advance();
                         let index = self.parse_expression()?;
                         self.expect(Token::RBracket)?;
-                        self.expect(Token::Eq)?;
-                        let value = self.parse_expression()?;
-                        self.expect(Token::Semicolon)?;
-                        Ok(Statement::IndexAssignment {
-                            name: ident,
-                            index,
-                            value,
-                        })
+                        if self.current() == Token::Eq {
+                            self.advance();
+                            let value = self.parse_expression()?;
+                            self.expect(Token::Semicolon)?;
+                            Ok(Statement::IndexAssignment {
+                                name: ident,
+                                index,
+                                value,
+                            })
+                        } else {
+                            // Rewind and treat the whole thing as an
+                            // expression statement.
+                            self.tokens = pre_lbracket;
+                            let expr = self.parse_expression()?;
+                            self.expect(Token::Semicolon)?;
+                            Ok(Statement::Expression(expr))
+                        }
                     }
                     _ => {
                         // Parse as expression statement

omnimcode-core/src/vm.rs

@@ -34,11 +34,49 @@ impl Vm {
         self.run_function(&module.main, &[], module)
     }
 
+    /// Public wrapper around the bytecode interpreter loop. Adds
+    /// call-stack tracking and error-trace formatting on top of the
+    /// raw `run_function_inner` so VM-thrown errors get a "call at X"
+    /// trace just like tree-walk's invoke_user_function does.
+    /// Also rescues the operand-stack scope on error (the inner loop
+    /// uses `?` extensively, which would otherwise leak a scope frame).
     fn run_function(
         &mut self,
         func: &CompiledFunction,
         args: &[Value],
         module: &Module,
+    ) -> Result<Value, String> {
+        // Skip stack-frame tracking for __main__ — "in __main__" is
+        // noise; the top-level module isn't a user-issued call.
+        let track_frame = func.name != "__main__";
+        if track_frame {
+            self.interp.push_call_frame(&func.name);
+        }
+        let result = self.run_function_inner(func, args, module);
+        if track_frame {
+            self.interp.pop_call_frame();
+        }
+        match result {
+            Ok(v) => Ok(v),
+            Err(e) => {
+                // The inner loop's `?` skipped vm_pop_scope on error;
+                // restore balance here so subsequent calls don't see
+                // a leaked scope frame.
+                self.interp.vm_pop_scope();
+                if track_frame {
+                    Err(format!("{}\n  at {}", e, func.name))
+                } else {
+                    Err(e)
+                }
+            }
+        }
+    }
+
+    fn run_function_inner(
+        &mut self,
+        func: &CompiledFunction,
+        args: &[Value],
+        module: &Module,
     ) -> Result<Value, String> {
         let mut stack: Vec<Value> = Vec::with_capacity(32);
         let mut ip: usize = 0;