Parser bridge, 79 parse tests, CLI parse/check commands, 6 new examples

Parser (parser.rs):
- Complete Pest→AST bridge with #[derive(Parser)]
- Handles all grammar rules: data, control, agents, protocols,
  supervisors, behaviours, functions, choreographies, locales,
  imports, type declarations, reversibility blocks
- parse_program() public API for .007 source → Program AST

Tests (parser_tests.rs):
- 79 new tests (105 total with existing 29 eval tests)
- Coverage: data expressions, agents, control statements, branches
  with given/traced/trace, protocols, supervisors, behaviours,
  functions (@total/@pure/@impure), choreographies (all step types),
  locales (all 5 constructors), imports, type declarations,
  reversibility, comments, error cases, example file integration

CLI (main.rs):
- `oo7 parse <file>` — parse and dump AST as JSON
- `oo7 check <file>` — validate syntax, report declaration count
- `oo7 demo` — existing demo preserved

Examples:
- type_system.007 — aliases, records, enums, generics
- choreography.007 — comm, parallel, branch, loop, decision
- locales.007 — Local, GPU, Remote, Edge, Cluster
- imports.007 — import, import...as, from...import
- reversibility.007 — reversible, irreversible, reverse blocks
- full_language.007 — comprehensive showcase of all features

Co-Authored-By: Claude Opus 4.6 (1M context) <noreply@anthropic.com>

Author: hyperpolymath

crates/oo7-cli/src/main.rs

@@ -4,17 +4,22 @@
 // 007 Agent Meta-Language — CLI Evaluator
 //
 // Usage:
-//   oo7 eval <file.007>        Evaluate a .007 file and print trace
-//   oo7 trace <file.007>       Evaluate and output decision trace as JSON
-//   oo7 demo                   Run a built-in demo that produces traces
+//   oo7 parse <file.007>     Parse a .007 file and print AST as JSON
+//   oo7 check <file.007>     Validate syntax (silent on success, errors on failure)
+//   oo7 eval <file.007>      Parse and evaluate (currently: parse only)
+//   oo7 demo                 Run a built-in demo that produces traces
 
 use oo7_core::ast::*;
 use oo7_core::eval::Evaluator;
+use oo7_core::parser;
 
 fn main() {
     let args: Vec<String> = std::env::args().collect();
 
     match args.get(1).map(|s| s.as_str()) {
+        Some("parse") => cmd_parse(&args),
+        Some("check") => cmd_check(&args),
+        Some("eval") => cmd_eval(&args),
         Some("demo") => run_demo(),
         Some("--help") | Some("-h") | None => print_usage(),
         Some(cmd) => {
@@ -29,12 +34,132 @@ fn print_usage() {
     println!("007 Agent Meta-Language — Reference Evaluator");
     println!();
     println!("Usage:");
-    println!("  oo7 demo      Run built-in demo producing decision traces");
-    println!("  oo7 --help    Show this help message");
+    println!("  oo7 parse <file.007>   Parse a .007 file and print AST as JSON");
+    println!("  oo7 check <file.007>   Validate syntax (no output on success)");
+    println!("  oo7 eval <file.007>    Parse and evaluate (parse-only for now)");
+    println!("  oo7 demo               Run built-in demo producing decision traces");
+    println!("  oo7 --help             Show this help message");
     println!();
     println!("The telescope is on. We're looking.");
 }
 
+/// Read a source file and return its contents, or exit with an error.
+fn read_source_file(args: &[String]) -> String {
+    let path = match args.get(2) {
+        Some(p) => p,
+        None => {
+            eprintln!("Error: missing file argument.");
+            eprintln!("Usage: oo7 {} <file.007>", args.get(1).unwrap());
+            std::process::exit(1);
+        }
+    };
+
+    match std::fs::read_to_string(path) {
+        Ok(src) => src,
+        Err(e) => {
+            eprintln!("Error: could not read '{}': {}", path, e);
+            std::process::exit(1);
+        }
+    }
+}
+
+/// Format a parse error with nice line/column information.
+fn format_parse_error(path: &str, err: &parser::ParseError) -> String {
+    // pest errors already include line/column, but we add the file path
+    format!("Parse error in '{}':\n{}", path, err)
+}
+
+/// `oo7 parse <file.007>` — parse and dump AST as JSON.
+fn cmd_parse(args: &[String]) {
+    let source = read_source_file(args);
+    let path = args.get(2).unwrap();
+
+    match parser::parse_program(&source) {
+        Ok(program) => {
+            let json = serde_json::to_string_pretty(&program).unwrap();
+            println!("{}", json);
+        }
+        Err(e) => {
+            eprintln!("{}", format_parse_error(path, &e));
+            std::process::exit(1);
+        }
+    }
+}
+
+/// `oo7 check <file.007>` — validate syntax, print declaration count on success.
+fn cmd_check(args: &[String]) {
+    let source = read_source_file(args);
+    let path = args.get(2).unwrap();
+
+    match parser::parse_program(&source) {
+        Ok(program) => {
+            println!("OK: {} declaration(s)", program.declarations.len());
+        }
+        Err(e) => {
+            eprintln!("{}", format_parse_error(path, &e));
+            std::process::exit(1);
+        }
+    }
+}
+
+/// `oo7 eval <file.007>` — parse and evaluate.
+///
+/// Currently this only parses and reports the structure, since the
+/// evaluator does not yet handle all constructs (it was built for
+/// the branch/trace system). Full evaluation is future work.
+fn cmd_eval(args: &[String]) {
+    let source = read_source_file(args);
+    let path = args.get(2).unwrap();
+
+    match parser::parse_program(&source) {
+        Ok(program) => {
+            println!("007 Evaluator — Parsed '{}' successfully", path);
+            println!("  {} top-level declaration(s)", program.declarations.len());
+            for decl in &program.declarations {
+                match decl {
+                    TopLevelDecl::DataBinding(d) => {
+                        println!("  - @total data {}", d.name);
+                    }
+                    TopLevelDecl::Agent(a) => {
+                        println!("  - agent {}", a.name);
+                    }
+                    TopLevelDecl::Supervisor(s) => {
+                        println!("  - supervisor {}", s.name);
+                    }
+                    TopLevelDecl::Protocol(p) => {
+                        println!("  - session protocol {}", p.name);
+                    }
+                    TopLevelDecl::Behaviour(b) => {
+                        println!("  - behaviour {}", b.name);
+                    }
+                    TopLevelDecl::Function(f) => {
+                        println!("  - fn {} ({:?})", f.name, f.purity);
+                    }
+                    TopLevelDecl::Choreography(c) => {
+                        println!("  - choreography {}", c.name);
+                    }
+                    TopLevelDecl::Locale(l) => {
+                        println!("  - locale {}", l.name);
+                    }
+                    TopLevelDecl::Import(i) => {
+                        println!("  - import {}", i.path.join("."));
+                    }
+                    TopLevelDecl::TypeDecl(t) => {
+                        println!("  - type {}", t.name);
+                    }
+                }
+            }
+            println!();
+            println!("Note: full evaluation not yet implemented for all constructs.");
+            println!("The telescope is on. We're looking.");
+        }
+        Err(e) => {
+            eprintln!("{}", format_parse_error(path, &e));
+            std::process::exit(1);
+        }
+    }
+}
+
 /// Run a built-in demo that exercises the branch/given/traced system
 /// and produces decision trace output.
 fn run_demo() {

crates/oo7-core/src/lib.rs

@@ -15,9 +15,13 @@ pub mod ast;
 pub mod eval;
 #[cfg(test)]
 mod eval_tests;
+pub mod parser;
+#[cfg(test)]
+mod parser_tests;
 pub mod trace;
 
 // Re-export key types for convenience.
 pub use ast::*;
 pub use eval::{BranchStrategy, Evaluator, PredicateFirstStrategy, RtValue};
+pub use parser::{parse_program, ParseError};
 pub use trace::{DecisionTrace, TraceRecord};