Elixir/OTP code generator — 007 compiles to BEAM

codegen_elixir.rs (~470 lines):
- Agents → GenServer modules (defstruct, start_link, init, handle_cast/call/info)
- Supervisors → Supervisor modules (strategy mapping, child specs)
- Branch with traced → cond + ETS trace recording
- Cached branch → ETS lookup wrapper
- Speculative branch → Task.async parallel evaluation
- Send/SendFinal → GenServer.cast + optional stop
- Spawn → start_link
- Exchange → GenServer.call
- Loop → Enum.reduce_while with throw/catch for break/continue
- Reversible → try/rescue
- Functions → collected module with @SPEC annotations
- Data bindings → collected module with pure functions
- Types → @type specs
- Protocols → Behaviour modules with @callback
- Application → ETS init + supervision tree
- mix.exs + config/config.exs

CLI: `oo7 compile <file.007> [project_name] [output_dir]`
Produces a complete runnable Elixir/OTP project.

207 tests (194 + 13 codegen). Zero clippy warnings.

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

Author: hyperpolymath

.gitignore

@@ -30,3 +30,4 @@ deps/
 pkg/
 *.wasm
 target/
+_build/

crates/oo7-cli/src/main.rs

@@ -10,6 +10,7 @@
 //   oo7 demo                 Run a built-in demo that produces traces
 
 use oo7_core::ast::*;
+use oo7_core::codegen_elixir;
 use oo7_core::eval::Evaluator;
 use oo7_core::parser;
 use oo7_core::typechecker;
@@ -21,6 +22,7 @@ fn main() {
         Some("parse") => cmd_parse(&args),
         Some("check") => cmd_check(&args),
         Some("typecheck") => cmd_typecheck(&args),
+        Some("compile") => cmd_compile(&args),
         Some("eval") => cmd_eval(&args),
         Some("demo") => run_demo(),
         Some("agent-parse") => cmd_agent_parse(&args),
@@ -44,6 +46,7 @@ fn print_usage() {
     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 typecheck <file.007>          Type-check a .007 file (L1-3, L7)");
+    println!("  oo7 compile <file.007> [--out DIR] Compile to Elixir/OTP project");
     println!("  oo7 eval <file.007>               Parse and evaluate (parse-only for now)");
     println!("  oo7 demo                          Run built-in demo producing decision traces");
     println!();
@@ -142,6 +145,101 @@ fn cmd_typecheck(args: &[String]) {
     }
 }
 
+/// `oo7 compile <file.007> [--out DIR]` — compile to Elixir/OTP project.
+///
+/// Parses the source file, runs the type checker (warnings only),
+/// then generates a complete Elixir/OTP project in the output directory.
+fn cmd_compile(args: &[String]) {
+    let source = read_source_file(args);
+    let path = args.get(2).unwrap();
+
+    // Determine output directory
+    let out_dir = if let Some(pos) = args.iter().position(|a| a == "--out") {
+        args.get(pos + 1)
+            .map(|s| s.as_str())
+            .unwrap_or("_build/elixir")
+    } else {
+        "_build/elixir"
+    };
+
+    // Determine project name from the source file stem
+    let project_name = std::path::Path::new(path)
+        .file_stem()
+        .and_then(|s| s.to_str())
+        .unwrap_or("oo7_project");
+
+    // Parse
+    let program = match parser::parse_program(&source) {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("{}", format_parse_error(path, &e));
+            std::process::exit(1);
+        }
+    };
+
+    // Type-check (warnings only — do not fail)
+    if let Err(errors) = typechecker::check_program(&program) {
+        for e in &errors {
+            eprintln!("Warning (typecheck): {}", e.message);
+        }
+    }
+
+    // Generate Elixir
+    let project = match codegen_elixir::generate_elixir(&program, project_name) {
+        Ok(p) => p,
+        Err(e) => {
+            eprintln!("Code generation error: {}", e);
+            std::process::exit(1);
+        }
+    };
+
+    // Write all files
+    let base = std::path::Path::new(out_dir);
+
+    // mix.exs
+    let mix_path = base.join("mix.exs");
+    write_file(&mix_path, &project.mix_exs);
+
+    // config/config.exs
+    let config_path = base.join("config").join("config.exs");
+    write_file(&config_path, &project.config);
+
+    // Source files
+    for file in &project.files {
+        let file_path = base.join(&file.path);
+        write_file(&file_path, &file.content);
+    }
+
+    // Summary
+    println!("007 Compiler — Elixir/OTP output");
+    println!("  Source: {}", path);
+    println!("  Output: {}", out_dir);
+    println!("  Project: {}", project_name);
+    println!("  Files generated: {}", project.files.len() + 2); // +2 for mix.exs + config
+    for file in &project.files {
+        println!("    {}", file.path);
+    }
+    println!("    mix.exs");
+    println!("    config/config.exs");
+    println!();
+    println!("To build: cd {} && mix deps.get && mix compile", out_dir);
+    println!("The telescope is on. We're looking.");
+}
+
+/// Write a file, creating parent directories as needed.
+fn write_file(path: &std::path::Path, content: &str) {
+    if let Some(parent) = path.parent() {
+        std::fs::create_dir_all(parent).unwrap_or_else(|e| {
+            eprintln!("Error: could not create directory '{}': {}", parent.display(), e);
+            std::process::exit(1);
+        });
+    }
+    std::fs::write(path, content).unwrap_or_else(|e| {
+        eprintln!("Error: could not write '{}': {}", path.display(), e);
+        std::process::exit(1);
+    });
+}
+
 /// `oo7 eval <file.007>` — parse and evaluate.
 ///
 /// Currently this only parses and reports the structure, since the