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

[StachuDotNet]

Very WIP, not sure where this will go.

Instead of dropping you at a bare prompt where you type a command and read the result, this evolves the default
dark CLI experience into a framed, keyboard-driven IDE over Dark Matter — the synced package space you
browse, read, author, version, and sync. dark with no args opens the workbench; the classic prompt is still
there for anyone who wants it (DARK_CLASSIC=1 at launch), and every arg'd command (dark status, dark eval, …) is untouched. Branch cli-ux-redux.

The old UX was super bare-bones — a prompt, a command, a wall of printed output, and you rebuild the picture in
your head across ls / view / status / commits / deps. This expands that into separate views and
panes over the same Matter: where you are, what's changed, what it depends on, what it looks like — on one
screen, and you stay in it through the whole author → edit → review → commit → sync loop. I'm less attached to
any single view than to the shape: a persistent home vs. a prompt.

---

The choices most worth reacting to: commit to it, don't hedge — no args opens the workbench, no chooser,
and the workbench is the experience: Esc (or q) just leaves, straight to the shell — there's no
classic-prompt fallback to back out into. The old world doesn't live behind an exit, it lives in the frame:
: is an inline command bar that runs any classic command (status, ls, agent ask, …) and shows its
output in-frame, so you never leave to reach it. And the noun under all of it is Dark Matter, which syncs —
the Matter view (below) is the home for its state.

---

The frame

Every view shares one frame: a tab bar (14 views, active one marked ◆), a breadcrumb with the current
path on the left and branch + sync status on the right, and a footer that only advertises the keys that
actually do something in the current view. All fourteen, real, from a running dark:

  ◆ Home   Matter   Inspect   Edit   Changes   History   Conflicts   Devices   AI   Runs   Apps   Values   Docs   SCM
  Home                                                              branch: main  ✓ synced

Navigation is uniform: 1-9 jump to a view, [ / ] cycle, ` opens a picker for all fourteen (the
number keys only reach the first nine), ↑↓ or j/k move, tab toggles the focused pane, / searches
(Enter jumps to a hit), ? is a keymap overlay, : is the command bar. The footer re-labels itself per view,
so the keys you see are the keys that work.

---

Views

A framed home over the same Matter, one angle per view. Most are a list + live preview split: the list on
the left, and whatever the selection is — source, ops, a diff, a rendered view — on the right.

Home — a dashboard: where you are, what's changed, who you are.

  Welcome back — you're on main
    ✓ working tree clean
    1 commit on this branch
    last commit: Init: packages loaded from disk
    3 top-level owners
    logged in as Stachu

Matter — browse the Matter tree; the selection's source is syntax-highlighted on the right. Icons carry the
kind: 🗂 module, # type, • value, ⚡ fn.

  /Darklang.Stdlib.List (module)
  ┌─ Tree ──────────────────────┐┌─ Inspect ──────────────────────────────┐
  │  🗂 SortByComparatorHelpers/ ││ /// Calls fn on every val in list, …    │
  │  # ChunkBySizeError          ││ let map<'a, 'b> (list: List<'a>)         │
  │  • empty                     ││     (fn: 'a -> 'b): List<'b> =           │
  │> ⚡ map                      ││   Stdlib.List.fold list [] (fun acc e -> │
  │  ⚡ filter                   ││     Stdlib.List.push acc (fn e))         │
  │  ⚡ fold                     ││   |> Stdlib.List.reverse                 │
  └──────────────────────────────┘└──────────────────────────────────────────┘
  ↑↓ move · → in · ⏎ open · n/t/v new · e edit · r rename · d deps

Inspect — with nothing drilled in, a live Package Statistics overview: totals and a per-module bar
chart, sortable and filterable.

  ┌─ Overview ──────────────────────────────────────────────┐
  │  Package Statistics  —  7 top-level modules             │
  │   629 fns    182 types    54 values    76 modules       │
  │  ─────────────────────────────────────────────────────  │
  │   MODULE                  FNS  TYPES  VALS  MODS  FNS    │
  │   Darklang.Stdlib         247    42    18    23  ██████  │
  │   Darklang.LanguageTools  156    67     8    19  ████░░  │
  │   Darklang.Cli             89    31    12    15  ███░░░  │
  │   Darklang.SCM             43    14     5     7  ██░░░░  │
  │  ─────────────────────────────────────────────────────  │
  │   [q] quit   [s] sort by column   [/] filter            │
  └──────────────────────────────────────────────────────────┘

Edit — author anything and apply it at once, no navigating first. Start a draft and you get a full editor
prefilled with a module <you>.Drafts header; write the module + declaration, ^s parses the whole thing and
applies it to the tree. Change the module line to save anywhere.

  ┌─ Edit ──────────────────────────────────────────────────┐
  │ Edit anything, apply at once.                           │
  │   n / ⏎   start a draft — a full editor prefilled with: │
  │               module <you>.Drafts                       │
  │               let example (x: Int): Int = x             │
  │           write the module + declaration, ^s applies it │
  │ Or from Matter: n/t/v new · e edit in place · r rename. │
  └──────────────────────────────────────────────────────────┘

Changes / History — your WIP, and the op log. History is a list of commits with the selected commit's detail
(and its ops, on Enter) on the right.

  ┌─ History · 1 ────────────────────────┐┌────────────────────────────┐
  │> • 9fa317f3  Init: packages loaded    ││ 9fa317f3…                   │
  │              from disk  (10908 ops)   ││ Init: packages loaded       │
  │                                       ││ 10908 ops  ·  ⏎ to view them │
  └───────────────────────────────────────┘└──────────────────────────────┘

Conflicts — incoming conflicts, resolvable right here: keep ours, keep theirs, or acknowledge. In sync, it
says so.

  ┌─ Conflicts ─────────────────────────────────────────────┐
  │ ✓ nothing to resolve — in sync                          │
  └──────────────────────────────────────────────────────────┘
  ↑↓ move · o keep ours · t keep theirs · a acknowledge

AI — a thread board: each agent thread with status/branch, and the selected thread's detail (cost, tokens,
what it's editing) on the right. a asks the agent a new prompt. (Board is demo data for now.)

  ┌─ AI · 6 ─────────────────────────────────┐┌─ detail ─────────────┐
  │> • [RUNNING]  Add binary serialization    ││ topic:  Add binary    │
  │  • [REVIEW]   Refactor HTTP error paths   ││ status: running       │
  │  • [RUNNING]  Write tests for pkg manager ││ branch: ai/sync       │
  │  • [REVIEW]   Design new DB migration     ││ cost: $4.82 · 128k tok │
  │  • [RUNNING]  Fix canvas render perf      ││ · 12m                 │
  │  • [DONE]     Update stdlib List docs     ││ editing sync/serialize │
  └───────────────────────────────────────────┘└────────────────────────┘

Apps & Views — the app registry + registered views; move onto a view and its render is captured live into
the preview pane, so you quick-peek a pretty view just by tabbing.

  ┌─ Apps & Views · 11 ──────────────┐┌─ Preview ─────────────┐
  │> • AI Chats                      ││  dark ai chats — 6     │
  │  • Package Stats                 ││  ID   STATUS   TOPIC   │
  │  • UI Components                 ││  #1   RUNNING  Add …   │
  │  • Heartbeat  — Demo daemon …    ││                        │
  └──────────────────────────────────┘└────────────────────────┘

Values — every package value (447 of them), browsable, with the value's definition on the right.

  ┌─ Values · 447 ────────────────────────┐┌──────────────────────┐
  │> • …UI.Core.…BoxChars.bottomLeft     ▐││ val bottomLeft = "└"  │
  │  • …UI.Core.…BoxChars.bottomRight     ││                       │
  │  • …UI.Core.…BoxChars.cross           ││                       │
  │  • …UI.Core.…BoxChars.doubleHorizontal││                       │
  └────────────────────────────────────────┘└───────────────────────┘

Docs — the doc set (for-ai, syntax, types, …), each rendered as markdown in the preview. Some are
live (the Stdlib overview computes its counts).

  ┌─ Docs · 18 ──────────────────────────┐┌─ for-ai ──────────────┐
  │> • for-ai  —  AI agent guide          ││ # Darklang AI Quick    │
  │  • syntax  —  Language syntax         ││ ## Darklang is Different│
  │  • types   —  Type system overview    ││ LIVE PROGRAMMING ENV…  │
  │  • pattern-matching — Match exprs      ││ - fn to CREATE         │
  │  • stdlib  —  Live: Stdlib counts      ││ - eval to TEST         │
  └────────────────────────────────────────┘└─────────────────────────┘

SCM — one SCM-centric home over Dark Matter: a status header (branch → parent, WIP, commits, conflicts,
peers — the always-true summary) over the change set, with every version-control action in the footer.

  SCM
  branch: main   →   (root)
  ✓ clean     1 commit     no conflicts     no peers
  ┌─ Changes ───────────────────────────────────────────────┐
  │ ✓ working tree clean — nothing to commit                │
  └──────────────────────────────────────────────────────────┘
  ↑↓ move · c commit · x discard · b branch · s switch · m merge · r rebase

Devices / Runs — the tailnet mesh, and recorded traces. Both report their real state honestly rather than
faking data:

  Devices:  tailnet unavailable — tailscale not running or not installed
  Runs:     no runs yet — eval, run a script, or serve to record traces

---

Views live in the tree

The nicer version of "peek at a view" isn't a separate registry — it's a renderable value lighting up where it
lives in the Matter tree. Cursor onto a render fn anywhere in the tree and its output renders live in the
preview, instead of source. Here, Apps.Views.AiChats.render selected in the tree, its board rendered live on
the right:

  /Darklang.Cli.Apps.Views.AiChats
  ┌─ Tree ────────────┐┌─ Inspect (live render) ─────────────────────┐
  │  🗂 …              ││  dark ai chats — 6 threads · 3 running · 2  │
  │> ⚡ render         ││  ID    STATUS    TOPIC             BRANCH   │
  │                   ││  #1   RUNNING  Add binary serial…  ai/sync  │
  │                   ││       ╰─ editing sync/serialize.dark        │
  │                   ││  #2   REVIEW   Refactor HTTP err…  ai/errs  │
  │                   ││       ╰─ ⚠ Awaiting review: 3 questions     │
  └────────────────────┘└──────────────────────────────────────────────┘

---

Overlays

Three modal overlays, reachable from any view.

? — a keymap, grouped and self-labeling per the keys that actually work:

  ┌─ Keys · any key closes ─────────────────────────────────┐
  │ Global     : cmd   / search   ` views   ? help   esc/q  │
  │ Views      1-9 jump   [ ] cycle                         │
  │ Move       ↑↓ or j/k   g/G top/bottom   tab focus pane  │
  │ Tree       →/l in   ←/h up   ⏎ open   n/t/v new   e edit │
  │ Changes    c commit   x discard                         │
  │ SCM        c commit · x discard · b branch · m merge …  │
  └──────────────────────────────────────────────────────────┘

` — a jumpable picker for all fourteen views (the number keys reach only the first nine):

  ┌─ Go to view ────────┐
  │    1  Home          │
  │ >  2  Matter  ◆     │
  │    3  Inspect       │
  │    4  Edit          │
  │    …                │
  │   14  SCM           │
  └─────────────────────┘

: — the command bar. Runs any classic command and shows its output in-frame, so the whole old CLI is
reachable without leaving the workbench:

  $ status
  On branch main
  No uncommitted changes.

The loop, end to end: navigate, read source or the op log, author or edit a fn/type/value (n/t/v + ^s,
from anywhere — no depth trap), rename (r, a real one-op rename), review the diff, commit, branch, merge,
rebase, resolve conflicts — without leaving the screen.

---

Reusable UI (generic — not workbench-specific)

Each is a small component with a typed input and a render. Worth a look on their own; any Dark TUI can mount
them.

UI.Box — a focus-aware bordered/titled pane. draw region title focused -> innerRegion.

┌─ Title ───────────────┐
│ inner content region  │
└───────────────────────┘

UI.SplitPane — two bordered panes; render region orientation firstPct focus titleA renderA titleB renderB. Composes Box; the focused pane gets the bright border.

┌─ Tree ──────────┐┌─ Inspect ───────┐
│> 🗂 Stdlib/      ││ type Expr =     │
│  ⚡ parse        ││   | EInt of Int │
└─────────────────┘└─────────────────┘

UI.ListView — a scrollable/selectable list body: render region (displayLines: List<String>) (selected: Int). Owns the bottom-anchored viewport + the overflow scrollbar; the caller styles its own rows.

> item one                    ▐   <- selection (cyan) + scrollbar thumb
  item two
  item three

UI.Editor — a pure multiline text buffer: Buf { lines: List<String>; row: Int; col: Int } with
insertText / newline / backspace / motion. Eval-testable (no I/O).

let newFunction (x: Int): Int =
  x█                                <- reverse-video cursor at (row, col)

UI.Layout — the region model (Region, printAt, vstack/hstack, distributeRows/Cols) plus
truncateVisible (s: String) (maxVisible: Int) : String — an ANSI-aware truncate that cuts a highlighted line
to a visible width without slicing through a color code. This is what lets highlighted source and captured
command output fit any pane cleanly.

One backend addition (the only non-.dark bit — worth review): NonBlockingConsole gains a capture buffer +
stdoutCaptureStart/Stop builtins, so the CLI can run a command (or a view's render) and collect its output
as a string instead of writing to the frame. That's what powers the : command bar, the AI ask surface, the
Apps & Views previews, and the tree-native render peek.

---

Honestly not done, with reasons

• Matter view is v1 — the status header + change set + actions. Folding History / Conflicts / Sync in as
  switchable sections, and a real +/- diff pane (the diff engine already exists in scm/review, just needs
  borrowing), is the fast-follow. See notes/scm-matter-view-design.md.
• AI is prompts, not chat sessions — a asks (agent ask, reply in-frame; needs a provider key or local
  Ollama) and the board is demo data; conversation history / multiple sessions is the real chat UX, still to
  come.
• View peek is convention-based, not by-type — the tree-native peek keys off a render-named fn. The real
  version is a by-type signal on the value ("this is renderable"), so any view lights up in the tree without a
  naming convention.
• A typed target vocabulary — rename is one SetName today, but a Location can only point at package
  content. notes/location-reference-design.md sketches LocationReference (content-by-hash / DB / alias /
  SqlDB / file) and the sync boundary — a name always syncs, its target may be Matter or a local handle. That
  informs the Matter view and the tree.
• layout.dark → resizeable.dark — considered and skipped: Layout is the accurate name for the region
  model; the rename would be narrower and risky. Flagging rather than doing it silently.

Devices/Runs show "unavailable/empty" honestly in this env (no tailnet, no traces). Rebase's success path isn't
exercised end-to-end (merge's is).