v2.0.0 — Rust interpreter, parser, parallel evaluator, benchmarks

Shape A complete:
- Rust tree-walking interpreter (codifide-interpreter crate)
  - All 49 primitives, 8 typed errors, cost-based dispatch
  - 70 conformance tests passing
  - 6-25x faster than Python reference
- Rust default runtime (codifide run delegates to Rust binary)
  - --runtime python falls back to reference
- Rust parser (fully self-contained, no Python subprocess)
  - 3 parser conformance tests, byte-for-byte agreement
  - codifide-run parse subcommand
- Criterion benchmark harness
  - Baseline: sort 23.6us, classify 5.9us, fizzbuzz 28.8us,
    balanced_brackets 98.3us, pipeline 17.4us
- Graph-native parallel evaluator infrastructure
  - Static effect analysis, disjointness check, rayon::scope
  - Declaration-order trace merge (PE-1)
  - Per-branch interpreter with inherited depth (PE-3)
  - Correct but needs larger programs to show speedup
- Three new example programs
  - batch_classify.cod: 8 independent model calls
  - recursive_sum.cod: recursive list sum with postcondition
  - text_stats.cod: multi-statistic text analysis
- 289 Python tests, 28 Rust canonical tests, 0 skipped
- Capability manifest unchanged: sha256:23fdde779...

Author: Douglas Jones

Cargo.toml

@@ -1,3 +1,3 @@
 [workspace]
 resolver = "2"
-members = ["crates/codifide-canonical"]
+members = ["crates/codifide-canonical", "crates/codifide-interpreter"]

codifide/__main__.py

@@ -73,11 +73,70 @@ def _read(path: str) -> str:
 
 
 def cmd_run(args: argparse.Namespace) -> int:
+    # Runtime selection: Rust is the default in v2.0.0; Python is the
+    # reference fallback via --runtime python.
+    runtime = getattr(args, "runtime", None) or os.environ.get("CODIFIDE_RUNTIME", "rust")
+
+    if runtime == "rust":
+        return _cmd_run_rust(args)
+    return _cmd_run_python(args)
+
+
+def _cmd_run_rust(args: argparse.Namespace) -> int:
+    """Delegate execution to the Rust interpreter binary."""
+    import shutil
+    import subprocess
+
+    # Locate the Rust binary: prefer the release build next to this repo,
+    # then fall back to PATH.
+    repo_root = Path(__file__).resolve().parent.parent
+    rust_bin = repo_root / "target" / "release" / "codifide-run"
+    if not rust_bin.exists():
+        rust_bin_path = shutil.which("codifide-run")
+        if rust_bin_path is None:
+            # Rust binary not available; fall back to Python silently.
+            return _cmd_run_python(args)
+        rust_bin = Path(rust_bin_path)
+
+    cmd = [str(rust_bin), "run", args.file]
+    if args.entry:
+        cmd += ["--entry", args.entry]
+
+    result = subprocess.run(cmd, capture_output=True, text=True)
+    # Forward stderr directly.
+    if result.stderr:
+        print(result.stderr.rstrip(), file=sys.stderr)
+    if result.returncode != 0:
+        return result.returncode
+
+    # The binary prints io.say output on earlier lines and the JSON result
+    # on the last line. Print io.say lines as-is; unwrap the JSON result
+    # for display (matching Python's `print(result)` behavior).
+    lines = result.stdout.splitlines()
+    if not lines:
+        return 0
+    # All lines except the last are io.say output — print them directly.
+    for line in lines[:-1]:
+        print(line)
+    # Last line is the JSON result — unwrap for display.
+    last = lines[-1]
+    try:
+        val = json.loads(last)
+        # Print like Python's print(): strings unquoted, everything else as repr.
+        if isinstance(val, str):
+            print(val)
+        elif val is None:
+            pass  # None result: print nothing (matches Python behavior)
+        else:
+            print(val)
+    except (json.JSONDecodeError, ValueError):
+        print(last)
+    return 0
+
+
+def _cmd_run_python(args: argparse.Namespace) -> int:
+    """Original Python tree-walking interpreter."""
     try:
-        # Parse first without the store; if the source uses `from`
-        # imports, the parser will return an error that names the
-        # missing store. We open the store then and retry, so modules
-        # that do not need a store do not pay for opening one.
         src = _read(args.file)
         store: Optional[SymbolStore] = None
         try:
@@ -86,12 +145,10 @@ def cmd_run(args: argparse.Namespace) -> int:
             store = SymbolStore(_store_root(args))
             module = parse(src, store=store)
         if store is None and module.imports:
-            # Plain `import` at runtime still needs a store.
             store = SymbolStore(_store_root(args))
         entry = args.entry or _default_entry(module)
         result = run(module, entry, store=store)
         if result is not None:
-            # Print the unwrapped result for scripting convenience.
             print(result)
         return 0
     except CodifideError as e:
@@ -523,6 +580,13 @@ def main(argv=None) -> int:
     p_run = sub.add_parser("run", help="execute a Codifide program")
     p_run.add_argument("file")
     p_run.add_argument("--entry", help="entry definition (default: main or sole definition)")
+    p_run.add_argument(
+        "--runtime",
+        choices=["rust", "python"],
+        default=None,
+        help="interpreter runtime: rust (default) or python (reference). "
+             "Override with CODIFIDE_RUNTIME env var.",
+    )
     p_run.add_argument(
         "--store",
         help="store root for import resolution (default: $CODIFIDE_STORE or ~/.codifide/store)",

crates/codifide-canonical/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "codifide-canonical"
-version = "1.0.0"
+version = "2.0.0"
 edition = "2021"
 description = "Codifide canonical form: typed hypergraph with JSON projection and content addressing."
 license = "MIT"

crates/codifide-interpreter/Cargo.toml

@@ -0,0 +1,26 @@
+[package]
+name = "codifide-interpreter"
+version = "2.0.0"
+edition = "2021"
+description = "Codifide tree-walking interpreter — Rust production runtime."
+license = "MIT"
+publish = false
+
+[lib]
+path = "src/lib.rs"
+
+[[bin]]
+name = "codifide-run"
+path = "src/bin/codifide_run.rs"
+
+[dependencies]
+codifide-canonical = { path = "../codifide-canonical" }
+serde_json = "1"
+rayon = "1.10"
+
+[dev-dependencies]
+criterion = { version = "0.5", features = ["html_reports"] }
+
+[[bench]]
+name = "interpreter"
+harness = false

crates/codifide-interpreter/benches/interpreter.rs

@@ -0,0 +1,41 @@
+//! Criterion benchmarks for the Codifide Rust interpreter.
+//!
+//! Measures pure interpreter throughput — parse once, run many times.
+//! This is the baseline for the graph-native parallel evaluator.
+//!
+//! Programs chosen to cover different dispatch patterns:
+//!   sort              — multi-candidate dispatch, postconditions, recursion
+//!   classify          — belief dispatch, model primitive
+//!   fizzbuzz          — cost-based dispatch, 15 recursive calls
+//!   balanced_brackets — deep recursion (indexed primitives)
+//!   pipeline          — multi-function composition, contracts, bind chains
+
+use criterion::{black_box, criterion_group, criterion_main, Criterion};
+use std::path::Path;
+
+fn load(path: &str) -> codifide_canonical::ast::Module {
+    let src = std::fs::read_to_string(path).expect("read source");
+    let stem = Path::new(path).file_stem().and_then(|s| s.to_str()).unwrap_or("main");
+    codifide_interpreter::parse(&src, stem).expect("parse")
+}
+
+fn bench_run(c: &mut Criterion, name: &str, path: &str) {
+    let module = load(path);
+    c.bench_function(name, |b| {
+        b.iter(|| {
+            codifide_interpreter::run(black_box(&module), "main", vec![])
+                .expect("run")
+        })
+    });
+}
+
+fn benchmarks(c: &mut Criterion) {
+    bench_run(c, "sort",             "../../examples/sort.cod");
+    bench_run(c, "classify",         "../../examples/classify.cod");
+    bench_run(c, "fizzbuzz",         "../../examples/assessment/03_fizzbuzz.cod");
+    bench_run(c, "balanced_brackets","../../examples/assessment/05_balanced_brackets.cod");
+    bench_run(c, "pipeline",         "../../examples/assessment/06_pipeline.cod");
+}
+
+criterion_group!(benches, benchmarks);
+criterion_main!(benches);

crates/codifide-interpreter/src/bin/codifide_run.rs

@@ -0,0 +1,114 @@
+//! `codifide-run` — CLI binary for the Rust interpreter.
+//!
+//! Subcommands:
+//!   run   <file.cod> [--entry <name>] [--args <json_array>]
+//!         Parse and run a .cod source file; print result to stdout.
+//!   parse <file.cod>
+//!         Parse a .cod source file and print canonical JSON to stdout.
+//!         Used by the Python conformance bridge and the Python CLI.
+
+use std::process;
+
+fn main() {
+    let args: Vec<String> = std::env::args().collect();
+    if args.len() < 3 {
+        eprintln!("usage: codifide-run <run|parse> <file.cod> [options]");
+        process::exit(1);
+    }
+    match args[1].as_str() {
+        "run"   => cmd_run(&args),
+        "parse" => cmd_parse(&args),
+        other   => {
+            eprintln!("unknown subcommand: {}", other);
+            process::exit(1);
+        }
+    }
+}
+
+fn read_source(path: &str) -> String {
+    match std::fs::read_to_string(path) {
+        Ok(s) => s,
+        Err(e) => {
+            eprintln!("error reading {:?}: {}", path, e);
+            process::exit(1);
+        }
+    }
+}
+
+fn parse_source(path: &str) -> codifide_canonical::ast::Module {
+    let source = read_source(path);
+    // Derive module name from filename stem.
+    let stem = std::path::Path::new(path)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("main");
+    match codifide_interpreter::parse(&source, stem) {
+        Ok(m) => m,
+        Err(e) => {
+            eprintln!("parse error: {}", e);
+            process::exit(1);
+        }
+    }
+}
+
+fn cmd_parse(args: &[String]) {
+    let path = &args[2];
+    let module = parse_source(path);
+    let json_val = codifide_canonical::to_canonical_json(&module);
+    match serde_json::to_string(&json_val) {
+        Ok(s) => println!("{}", s),
+        Err(e) => {
+            eprintln!("serialization error: {}", e);
+            process::exit(1);
+        }
+    }
+}
+
+fn cmd_run(args: &[String]) {
+    let path = &args[2];
+
+    // Parse optional flags: --entry <name> and --args <json_array>
+    let mut entry = "main".to_string();
+    let mut call_args: Vec<codifide_interpreter::Value> = vec![];
+    let mut i = 3;
+    while i < args.len() {
+        match args[i].as_str() {
+            "--entry" => {
+                i += 1;
+                if i < args.len() { entry = args[i].clone(); }
+            }
+            "--args" => {
+                i += 1;
+                if i < args.len() {
+                    match serde_json::from_str::<serde_json::Value>(&args[i]) {
+                        Ok(serde_json::Value::Array(arr)) => {
+                            call_args = arr.iter().map(|v| {
+                                codifide_interpreter::Value::concrete(
+                                    codifide_interpreter::value::payload_from_json(v)
+                                )
+                            }).collect();
+                        }
+                        _ => {
+                            eprintln!("--args must be a JSON array");
+                            process::exit(1);
+                        }
+                    }
+                }
+            }
+            _ => {}
+        }
+        i += 1;
+    }
+
+    let module = parse_source(path);
+
+    match codifide_interpreter::run(&module, &entry, call_args) {
+        Ok(result) => {
+            println!("{}", result.to_json());
+        }
+        Err(e) => {
+            eprintln!("runtime error: {}", e);
+            process::exit(1);
+        }
+    }
+}