Subsystem · inspect

Build Inspect

curie inspect opens a terminal UI for browsing build logs interactively. Browse every project in a workspace side by side, drill into per-test output, and grep across all logs — all without leaving the terminal.

Launching

Run curie inspect from any project or workspace root after a build. Logs must already exist — inspect is a viewer, not a build trigger:

$ curie build && curie inspect

# workspace build runs first, then the TUI opens

When run inside a workspace member directory Curie still loads the full workspace log set but pre-selects that member. Use --project to target a specific member explicitly:

$ curie --project services/api inspect

# opens with services/api pre-selected

Layout

The UI is split into two panes. The Members pane on the left lists every project; the Log pane on the right shows the merged output:

curie inspect

curie inspect  ↑↓/jk select  Enter/→ expand  ← collapse  Tab log  m hide  / grep  f job  r reload  q quit
┌ Members ──────────────────┐┌ Log: all jobs ──────────────────────────────────────────┐
│ all jobs                  ││▌ hello-world  started 09:12:01  ✓ 1.2s                  │
│   hello-world  ✓ 1.2s     ││  Resolve deps    3 JAR(s)                               │
│   string-utils ✓ 0.8s     ││  Compile         4 source file(s)                       │
│ ▶ json-greeter  ✗ 0.4s    ││  Tests  ✔ 6 tests successful                            │
│                           ││  Package  hello-world-0.1.0.jar                         │
│                           ││▌ string-utils  started 09:12:02  ✓ 0.8s                 │
│                           ││  Resolve deps    1 JAR(s)                               │
│                           ││  Compile         2 source file(s)                       │
│                           ││▌ json-greeter  started 09:12:03  ✗ 0.4s                 │
│                           ││  Resolve deps    1 JAR(s)                               │
│                           ││  error: cannot find symbol                              │
│                           ││        import com.example.Missing;                      │
└───────────────────────────┘└─────────────────────────────────────────────────────────┘

Members pane

The left pane lists every workspace member in a tree that mirrors the member path hierarchy. Each entry shows a right-aligned badge:

✓ 1.2s — build succeeded, duration in seconds
✗ 0.4s — build failed
skipped — no metadata; the member was skipped by a parallel build
(no log) — curie build has not been run for this member yet

When a workspace build has been run more than once, jobs from an older run are dimmed and marked (prev) so you can tell at a glance which results are current.

Selecting all jobs at the top of the tree shows the merged log for every member.

Log pane

The right pane streams all log lines from the selected member (or all members) sorted by build-start time. Each job's output is preceded by a coloured header line showing the member name, start time, and outcome badge. ANSI colour codes from compiler output and test reporters are rendered faithfully.

Test tree

When a member has test results recorded in target/build.tests.json, the job node shows a ▸ marker. Press Enter or → to expand:

curie inspect — test tree expanded

│   string-utils ✓ 0.8s               │
│ ▶ json-greeter ▾ ✗ 0.4s             │
│     GreeterTest ▾                   │
│       testGreeting     ✓ 12ms       │
│       testMissingClass ✗ 8ms        │

Select a test method and press Enter to open that test's captured output in the log pane — including the failure message at the top and any System.out lines below. Press ← to collapse back to the class, then the job.

When curie inspect opens after a failed build it automatically jumps to the first failing test to minimise time-to-feedback.

Keyboard shortcuts

Key	Effect	Where
`↑` `↓` / `j` `k`	Move selection up / down	Members
`Enter` / `→`	Expand job → classes → test methods	Members
`←`	Collapse test method → class → job	Members
`Tab`	Cycle focus: Members → Log → Members	Both
`m`	Toggle Members pane visibility	Both
`j` `k` / `↑` `↓`	Scroll log one line	Log
`PgUp` `PgDn`	Scroll log one page	Log
`Ctrl-u` `Ctrl-d`	Scroll log half page	Log
`g` / `G`	Jump to top / bottom of log	Log
`/`	Open grep bar — filter log lines by content	Both
`f`	Open job filter bar — filter members by name	Both
`Esc`	Clear active search; quit when no search active	Both
`r`	Reload all logs from disk without restarting	Both
`q`	Quit	Both

Grep

Press / to open the grep bar at the bottom of the screen. As you type, the log pane filters to only jobs whose output contains the pattern (case-insensitive) and highlights every match in yellow. The Members pane dims jobs with no matching lines so you can spot the relevant member at a glance.

curie inspect — grep active

│ all jobs                  ││▌ json-greeter  started 09:12:03  ✗ 0.4s             │
│   hello-world  ✓ 1.2s    ││  error: cannot find symbol                          │
│   string-utils ✓ 0.8s    ││        import com.example.Missing;                     │
│ ▶ json-greeter  ✗ 0.4s   ││                                                        │
└───────────────────────────┘└────────────────────────────────────────────────────────┘
/ symbol█

Press Enter to confirm and return focus to the previous pane while keeping the filter active. Press Esc to clear and show all lines again.

Job filter

Press f to open the job filter bar. Typing narrows the Members tree to entries whose path contains the search string (case-insensitive). This is useful in large workspaces with many members — type svc to instantly focus all services/* members.

Reload

Press r to reload all logs from disk. Run curie build in a separate terminal, then press r in inspect to see the new results without closing the TUI. The stale-job detection updates on reload — members from the previous run are dimmed until the new build has also completed them.