Experiment: Replace CLI UX with much broader TUI app/IDE

backend/src/Builtins/Builtins.Cli/Libs/Output.fs

@@ -70,6 +70,42 @@ let fns () : List<BuiltInFn> =
       deprecated = NotDeprecated }
 
 
+    { name = fn "stdoutCaptureStart" 0
+      typeParams = []
+      parameters = [ Param.make "unit" TUnit "A unit" ]
+      returnType = TUnit
+      description =
+        "Start capturing standard output into an in-memory buffer instead of printing it. Pair with <fn stdoutCaptureStop>. Used to run a command and show its output in-frame."
+      fn =
+        (function
+        | _, _, _, [ DUnit ] ->
+          NonBlockingConsole.startCapture ()
+          Ply DUnit
+        | _ -> incorrectArgs ())
+      sqlSpec = NotQueryable
+      previewable = Impure
+      capabilities = LibExecution.Capabilities.Needs.stdout
+      deprecated = NotDeprecated }
+
+
+    { name = fn "stdoutCaptureStop" 0
+      typeParams = []
+      parameters = [ Param.make "unit" TUnit "A unit" ]
+      returnType = TString
+      description =
+        "Stop capturing standard output and return everything written since <fn stdoutCaptureStart>."
+      fn =
+        (function
+        | _, _, _, [ DUnit ] ->
+          let captured = NonBlockingConsole.stopCapture ()
+          Ply(DString captured)
+        | _ -> incorrectArgs ())
+      sqlSpec = NotQueryable
+      previewable = Impure
+      capabilities = LibExecution.Capabilities.Needs.stdout
+      deprecated = NotDeprecated }
+
+
     { name = fn "debug" 0
       typeParams = []
       parameters =

backend/src/Prelude/NonBlockingConsole.fs

@@ -20,6 +20,11 @@ type private Private() =
 
   static let mQueue : BlockingCollection = new BlockingCollection()
 
+  // When capturing (non-null), writes go to this buffer instead of the console queue. Used by the CLI to run
+  // a command and show its output in-frame (the workbench's inline command bar) rather than to stdout. Capture
+  // is driven synchronously from the interactive loop's key handler, so the single-writer assumption holds.
+  static let mutable captureBuffer : System.Text.StringBuilder = null
+
   // Use a lock so that wait() doesn't return until the thread has actually printed
   // (it would finish once it was removed from the queue)
   static let mLock : obj = obj ()
@@ -54,11 +59,28 @@ type private Private() =
       lock mLock (fun () -> shouldWait <- mQueue.Count > 0)
 
   static member Write(value : string) : unit =
-    if isWasm then System.Console.Write value else mQueue.Add(value)
+    if isWasm then
+      System.Console.Write value
+    else
+      let cb = captureBuffer
+      if not (isNull cb) then cb.Append(value) |> ignore else mQueue.Add(value)
+
+  static member StartCapture() : unit = captureBuffer <- System.Text.StringBuilder()
+
+  static member StopCapture() : string =
+    let sb = captureBuffer
+    captureBuffer <- null
+    if isNull sb then "" else sb.ToString()
 
 
 let wait () : unit = Private.wait ()
 
 let writeInline (value : string) : unit = Private.Write value
 
 let writeLine (value : string) : unit = Private.Write(value + "\n")
+
+/// Route subsequent `print`/`printLine` output into an in-memory buffer instead of the console.
+let startCapture () : unit = Private.StartCapture()
+
+/// Stop capturing and return everything written since `startCapture`.
+let stopCapture () : string = Private.StopCapture()

dev-drive

@@ -0,0 +1,50 @@
+#!/usr/bin/env python3
+# dev-drive — visual-verify a full-screen CLI app under a PTY (host expect isn't installed; run-in-docker is
+# too slow). Spawns `./scripts/run-cli <args>`, optionally sends keystrokes, and prints the screen with ANSI
+# stripped so you can eyeball the frame.
+#   ./dev-drive workbench                       # dump the initial frame
+#   ./dev-drive workbench --keys 'DOWN DOWN RIGHT'   # send keys, then dump
+# Keys: UP DOWN LEFT RIGHT ENTER ESC TAB, a literal char, or \xNN. Waits ~1.5s between key and dump.
+import os, pty, subprocess, time, select, termios, struct, fcntl, sys, re
+
+args = sys.argv[1:]
+keys = []
+if "--keys" in args:
+    i = args.index("--keys"); keys = args[i+1].split(); args = args[:i]
+
+KEYMAP = {"UP":b"\x1b[A","DOWN":b"\x1b[B","RIGHT":b"\x1b[C","LEFT":b"\x1b[D",
+          "ENTER":b"\r","ESC":b"\x1b","TAB":b"\t","CTRLS":b"\x13","SP":b" "}
+
+master, slave = pty.openpty()
+ROWS = int(os.environ.get("DEV_DRIVE_ROWS", "40"))
+COLS = int(os.environ.get("DEV_DRIVE_COLS", "120"))
+fcntl.ioctl(slave, termios.TIOCSWINSZ, struct.pack("HHHH", ROWS, COLS, 0, 0))
+p = subprocess.Popen(["./scripts/run-cli"]+args, stdin=slave, stdout=slave, stderr=slave, close_fds=True)
+os.close(slave)
+
+def drain(t):
+    end=time.time()+t; buf=b""
+    while time.time()<end:
+        r,_,_=select.select([master],[],[],0.2)
+        if r:
+            try: buf+=os.read(master,65536)
+            except OSError: break
+    return buf
+
+raw = drain(6)                     # the initial frame
+for k in keys:
+    os.write(master, KEYMAP.get(k, k.encode())); time.sleep(0.4)
+if keys:
+    raw = drain(2)                  # the screen after the keystrokes
+try:
+    os.write(master, b"\x03"); time.sleep(0.2); p.terminate()
+except: pass
+
+# Keep only the LAST full redraw (each frame starts with a clear-screen), so multi-key drives show the
+# settled final frame instead of every intermediate repaint.
+frames = raw.split(b'\x1b[2J')
+raw = frames[-1] if len(frames) > 1 else raw
+txt = re.sub(rb'\x1b\[[0-9;?]*[a-zA-Z]', b'', raw)
+txt = re.sub(rb'\x1b[()=>][B0]?', b'', txt)
+sys.stdout.buffer.write(txt)
+print()

dev-ux-check

@@ -0,0 +1,28 @@
+#!/bin/bash
+# dev-ux-check — the tight inner loop for CLI-UX work. Reload packages, report PASS/FAIL + first error.
+# Usage: ./dev-ux-check            (reload + check)
+#        ./dev-ux-check twice      (reload twice — for .dark TYPE changes: embedded ref-hashes need 2 passes)
+set -uo pipefail
+cd "$(dirname "$0")"
+
+reload() { DARK_CONFIG_TRACE_DETAIL=off ./scripts/build/reload-packages 2>&1; }
+
+out="$(reload)"
+[ "${1:-}" = "twice" ] && out="$(reload)"
+
+# A clean reload prints only "Reloading packages …" and "Done reloading packages". Anything else that looks
+# like an error (a failed parse/name-resolution/load) is the real signal.
+errs="$(printf '%s\n' "$out" \
+  | grep -iE 'error|exception|fail|not found|unhandled|unexpected|cannot|abort|unresolved' \
+  | grep -vE 'reload-packages|logs/packages\.log' \
+  | head -6)"
+
+if printf '%s' "$out" | grep -q "Done reloading packages" && [ -z "$errs" ]; then
+  echo "PASS — packages reloaded clean"
+  exit 0
+else
+  echo "FAIL:"
+  [ -n "$errs" ] && printf '%s\n' "$errs" | sed 's/^/  /'
+  printf '%s' "$out" | grep -q "Done reloading packages" || echo "  (reload did not finish — see rundir/logs/packages.log)"
+  exit 1
+fi