feat(python-face): wire --face to all commands + fix tail-position semicolons

--face [canonical|python] is now accepted by check, eval, compile, fmt,
and lint — not just parse. The canonical face is the default for all
commands; `fmt --face python` warns that reverse transform is pending.

Tail-position fix in python_face.ml: a regular statement whose next
meaningful line has a smaller indent (i.e. the last expression in a
block) is now emitted WITHOUT a trailing `;`. Previously every statement
got `;`, making non-unit blocks return () and breaking type-checking.
The indexed lookahead in transform_source computes next_meaningful_indent
for each line and suppresses `;` when is_tail = next_ind < current_ind.

Seam check: `affinescript check --face python python_face_basic.pyaff`
now reaches the type checker and passes — end-to-end from Python-face
source through transform → lex → parse → resolve → typecheck.

73/73 E2E tests: 0 regressions.

Co-Authored-By: Claude Sonnet 4.6 <noreply@anthropic.com>

Author: hyperpolymath

bin/main.ml

@@ -59,6 +59,12 @@ let lex_file path =
     Format.eprintf "@[<v>%s:%d:%d: error: %s@]@." path pos.line pos.col msg;
     `Error (false, "Lexer error")
 
+(** Parse a file using the requested face. *)
+let parse_with_face face path =
+  match face with
+  | `Canonical -> Affinescript.Parse_driver.parse_file path
+  | `Python    -> Affinescript.Python_face.parse_file_python path
+
 (** Preview the Python-face text transform (debug tool). *)
 let preview_python_transform path =
   let ch = open_in_bin path in
@@ -87,14 +93,14 @@ let parse_file face path =
 
 (** Type-check a file.  With [--json], emits a structured diagnostic
     report on stderr. *)
-let check_file json path =
+let check_file face json path =
   if json then begin
     let diags = ref [] in
     let add d = diags := d :: !diags in
     let symbols_table = ref None in
     let resolve_refs = ref [] in
     begin try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -131,7 +137,7 @@ let check_file json path =
       json_finish final_diags)
   end else begin
     try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -160,12 +166,12 @@ let check_file json path =
 
 (** Evaluate a file with the interpreter.  With [--json], emits
     diagnostics on stderr instead of human-readable error text. *)
-let eval_file json path =
+let eval_file face json path =
   if json then begin
     let diags = ref [] in
     let add d = diags := d :: !diags in
     begin try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -194,7 +200,7 @@ let eval_file json path =
     json_finish (List.rev !diags)
   end else begin
     try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -242,12 +248,12 @@ let repl_cmd_fn () =
 (** Compile a file.  With [--json], emits diagnostics for any
     compilation errors.  With [--wasm-gc], targets the WebAssembly GC
     proposal instead of WASM 1.0 linear memory. *)
-let compile_file json wasm_gc path output =
+let compile_file face json wasm_gc path output =
   if json then begin
     let diags = ref [] in
     let add d = diags := d :: !diags in
     begin try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -298,7 +304,7 @@ let compile_file json wasm_gc path output =
     json_finish (List.rev !diags)
   end else begin
     try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -356,8 +362,16 @@ let compile_file json wasm_gc path output =
         `Error (false, "Parse error")
   end
 
-(** Format a file *)
-let fmt_file path =
+(** Format a file.  Only canonical face is supported — Python-face formatting
+    requires a reverse transform that is not yet implemented. *)
+let fmt_file face path =
+  (match face with
+  | `Python ->
+    Format.eprintf "fmt --face python is not yet supported \
+                    (reverse Python transform is pending).@.";
+    (* fall through; format the canonical parse anyway so the file still works *)
+    ()
+  | `Canonical -> ());
   try
     Affinescript.Formatter.format_file path;
     Format.printf "Formatted %s@." path;
@@ -373,12 +387,12 @@ let fmt_file path =
 
 (** Lint a file.  With [--json], emits lint diagnostics as structured
     JSON on stderr. *)
-let lint_file json path =
+let lint_file face json path =
   if json then begin
     let diags = ref [] in
     let add d = diags := d :: !diags in
     begin try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -398,7 +412,7 @@ let lint_file json path =
     json_finish (List.rev !diags)
   end else begin
     try
-      let prog = Affinescript.Parse_driver.parse_file path in
+      let prog = parse_with_face face path in
       let loader_config = Affinescript.Module_loader.default_config () in
       let loader = Affinescript.Module_loader.create loader_config in
       (match Affinescript.Resolve.resolve_program_with_loader prog loader with
@@ -467,12 +481,12 @@ let parse_cmd =
 let check_cmd =
   let doc = "Type check a file" in
   let info = Cmd.info "check" ~doc in
-  Cmd.v info Term.(ret (const check_file $ json_arg $ path_arg))
+  Cmd.v info Term.(ret (const check_file $ face_arg $ json_arg $ path_arg))
 
 let eval_cmd =
   let doc = "Evaluate a file with the interpreter" in
   let info = Cmd.info "eval" ~doc in
-  Cmd.v info Term.(ret (const eval_file $ json_arg $ path_arg))
+  Cmd.v info Term.(ret (const eval_file $ face_arg $ json_arg $ path_arg))
 
 let repl_cmd =
   let doc = "Start the interactive REPL" in
@@ -482,17 +496,17 @@ let repl_cmd =
 let compile_cmd =
   let doc = "Compile a file to WebAssembly (1.0 or GC proposal) or Julia" in
   let info = Cmd.info "compile" ~doc in
-  Cmd.v info Term.(ret (const compile_file $ json_arg $ wasm_gc_arg $ path_arg $ output_arg))
+  Cmd.v info Term.(ret (const compile_file $ face_arg $ json_arg $ wasm_gc_arg $ path_arg $ output_arg))
 
 let fmt_cmd =
   let doc = "Format a file" in
   let info = Cmd.info "fmt" ~doc in
-  Cmd.v info Term.(ret (const fmt_file $ path_arg))
+  Cmd.v info Term.(ret (const fmt_file $ face_arg $ path_arg))
 
 let lint_cmd =
   let doc = "Lint a file for code quality issues" in
   let info = Cmd.info "lint" ~doc in
-  Cmd.v info Term.(ret (const lint_file $ json_arg $ path_arg))
+  Cmd.v info Term.(ret (const lint_file $ face_arg $ json_arg $ path_arg))
 
 let preview_python_cmd =
   let doc = "Preview the Python-face text transform (debug)" in

lib/python_face.ml

@@ -218,10 +218,23 @@ let elif_condition stripped =
 
 (* ─── Main transformer ───────────────────────────────────────────────── *)
 
+(** True if [raw_line] is blank or comment-only (carries no code). *)
+let is_blank_line raw =
+  let (code, _) = strip_py_comment (String.trim raw) in
+  String.trim code = ""
+
 (** Transform Python-style AffineScript source text to canonical AffineScript.
-    The result is valid input for the standard lexer + Menhir parser. *)
+    The result is valid input for the standard lexer + Menhir parser.
+
+    Tail-position detection: a regular statement (non-block-opener) in the
+    last position of a block — i.e. the next meaningful line's indent is
+    strictly less than the current line's indent — is emitted WITHOUT a
+    trailing `;`.  This preserves the expression-as-return-value semantics
+    that AffineScript blocks require (a trailing `;` would make the block
+    yield unit rather than the expression's value). *)
 let transform_source source =
-  let lines = String.split_on_char '\n' source in
+  let lines = Array.of_list (String.split_on_char '\n' source) in
+  let n = Array.length lines in
   let out = Buffer.create (String.length source + 256) in
   (* Indentation stack: innermost level at head, outermost (0) at tail. *)
   let stack = ref [0] in
@@ -235,7 +248,16 @@ let transform_source source =
     done
   in
 
-  List.iter (fun raw_line ->
+  (* The indent level of the next non-blank/non-comment line after index [i],
+     or [-1] when there is no such line (EOF). *)
+  let next_meaningful_indent i =
+    let j = ref (i + 1) in
+    while !j < n && is_blank_line lines.(!j) do incr j done;
+    if !j >= n then -1 else indent_of lines.(!j)
+  in
+
+  for i = 0 to n - 1 do
+    let raw_line = lines.(i) in
     let ind = indent_of raw_line in
     let (code_part, comment_opt) = strip_py_comment (String.trim raw_line) in
     let stripped = String.trim code_part in
@@ -272,21 +294,28 @@ let transform_source source =
 
       let indent_str = String.make ind ' ' in
 
+      (* Tail-position check: the next meaningful line is less indented (or
+         EOF), meaning this is the last expression in its block.  Omit `;`
+         so the block's value is this expression, not unit. *)
+      let next_ind = next_meaningful_indent i in
+      let is_tail = next_ind < ind in (* -1 (EOF) satisfies this for ind > 0 *)
+
       let line_text = match transform_import_line stripped with
-        | Some s -> s
+        | Some s -> s  (* imports are always top-level statements *)
         | None ->
-          if is_block_opener stripped then begin
+          if is_block_opener stripped then
             (* Replace trailing `:` with ` {` *)
-            let body = apply_keywords (strip_block_colon stripped) in
-            body ^ " {"
-          end else begin
-            (* Regular statement: terminate with `;` *)
+            apply_keywords (strip_block_colon stripped) ^ " {"
+          else if is_tail then
+            (* Tail expression: no `;` — this is the block's return value *)
+            apply_keywords stripped
+          else
+            (* Mid-block statement: terminate with `;` *)
             apply_keywords stripped ^ ";"
-          end
       in
       Buffer.add_string out (indent_str ^ with_comment line_text)
     end
-  ) lines;
+  done;
 
   (* Close any blocks still open at EOF *)
   emit_dedents 0;