feat: session stats dashboard, server log capture and TUI polish

Author: jkyberneees

.github/workflows/ci.yml

@@ -28,7 +28,7 @@ jobs:
         run: go vet ./...
 
       - name: Test (race + coverage)
-        run: go test -race -coverpkg=./internal/... -coverprofile=coverage.out ./internal/...
+        run: go test -race -coverpkg=./internal/... -coverprofile=coverage.out ./...
 
       - name: Coverage summary
         run: go tool cover -func=coverage.out | tail -1

cmd/bodek/log.go

@@ -0,0 +1,69 @@
+package main
+
+import (
+	"bytes"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+)
+
+// serverLogName is the fixed file the spawned server's stderr is captured to.
+// A stable, predictable path lets users `tail -f` it; it is truncated per run
+// so it never grows without bound.
+const serverLogName = "bodek-odek-serve.log"
+
+// openServerLog opens (truncating) the server log file. On failure it falls
+// back to a discarding writer so a missing temp dir never breaks startup.
+func openServerLog() (w io.Writer, path string, closeFn func()) {
+	path = filepath.Join(os.TempDir(), serverLogName)
+	f, err := os.OpenFile(path, os.O_CREATE|os.O_TRUNC|os.O_WRONLY, 0o600)
+	if err != nil {
+		return io.Discard, "", func() {}
+	}
+	return f, path, func() { _ = f.Close() }
+}
+
+// ringWriter keeps the most recent lines written to it. It backs the in-memory
+// tail of the spawned server's stderr, which we surface if the server dies
+// before (or instead of) the TUI ever starting.
+type ringWriter struct {
+	mu      sync.Mutex
+	maxLine int
+	lines   []string
+	partial []byte
+}
+
+func newRingWriter(maxLine int) *ringWriter {
+	return &ringWriter{maxLine: maxLine}
+}
+
+func (w *ringWriter) Write(p []byte) (int, error) {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	w.partial = append(w.partial, p...)
+	for {
+		i := bytes.IndexByte(w.partial, '\n')
+		if i < 0 {
+			break
+		}
+		w.lines = append(w.lines, string(w.partial[:i]))
+		w.partial = w.partial[i+1:]
+		if len(w.lines) > w.maxLine {
+			w.lines = w.lines[len(w.lines)-w.maxLine:]
+		}
+	}
+	return len(p), nil
+}
+
+// String returns the buffered tail, including any unterminated final line.
+func (w *ringWriter) String() string {
+	w.mu.Lock()
+	defer w.mu.Unlock()
+	lines := w.lines
+	if len(w.partial) > 0 {
+		lines = append(append([]string(nil), lines...), string(w.partial))
+	}
+	return strings.Join(lines, "\n")
+}

cmd/bodek/log_test.go

@@ -0,0 +1,76 @@
+package main
+
+import (
+	"os"
+	"path/filepath"
+	"strings"
+	"testing"
+)
+
+func TestRingWriterKeepsRecentLines(t *testing.T) {
+	w := newRingWriter(3)
+	for i := range 5 {
+		if _, err := w.Write([]byte("line" + string(rune('0'+i)) + "\n")); err != nil {
+			t.Fatalf("write: %v", err)
+		}
+	}
+	got := w.String()
+	want := "line2\nline3\nline4"
+	if got != want {
+		t.Fatalf("tail = %q, want %q", got, want)
+	}
+}
+
+func TestRingWriterPartialLine(t *testing.T) {
+	w := newRingWriter(5)
+	// Write a line split across calls, plus an unterminated tail.
+	for _, s := range []string{"hel", "lo\nwor", "ld"} {
+		if _, err := w.Write([]byte(s)); err != nil {
+			t.Fatalf("write: %v", err)
+		}
+	}
+	if got, want := w.String(), "hello\nworld"; got != want {
+		t.Fatalf("tail = %q, want %q", got, want)
+	}
+}
+
+func TestRingWriterEmpty(t *testing.T) {
+	if got := newRingWriter(3).String(); got != "" {
+		t.Fatalf("empty tail = %q, want \"\"", got)
+	}
+}
+
+func TestOpenServerLogTruncates(t *testing.T) {
+	// Redirect TempDir to an isolated location for the test.
+	t.Setenv("TMPDIR", t.TempDir())
+
+	w, path, closeLog := openServerLog()
+	if path == "" {
+		t.Fatal("openServerLog returned empty path")
+	}
+	if filepath.Base(path) != serverLogName {
+		t.Fatalf("log name = %q, want %q", filepath.Base(path), serverLogName)
+	}
+	if _, err := w.Write([]byte("first run\n")); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	closeLog()
+
+	// A second open must truncate the prior contents.
+	w2, _, closeLog2 := openServerLog()
+	if _, err := w2.Write([]byte("second")); err != nil {
+		t.Fatalf("write: %v", err)
+	}
+	closeLog2()
+
+	data, err := os.ReadFile(path)
+	if err != nil {
+		t.Fatalf("read log: %v", err)
+	}
+	if got := string(data); got != "second" {
+		t.Fatalf("log = %q, want %q (not truncated?)", got, "second")
+	}
+	if strings.Contains(string(data), "first run") {
+		t.Fatal("prior run's log was not truncated")
+	}
+}

cmd/bodek/main.go

@@ -6,8 +6,10 @@ package main
 import (
 	"flag"
 	"fmt"
+	"io"
 	"os"
 	"os/signal"
+	"strings"
 	"syscall"
 
 	tea "github.com/charmbracelet/bubbletea"
@@ -45,15 +47,44 @@ func run() error {
 
 	extraArgs := flag.Args()
 
+	// A spawned `odek serve` logs to stderr. Routing that to our own terminal
+	// would corrupt the Bubble Tea alt-screen (stray writes desync the diff
+	// renderer), so we capture it to a log file and keep a short in-memory tail
+	// to surface if the server dies during startup. When attaching to an
+	// external server (--url) there is no subprocess, so nothing is captured.
+	var (
+		logTail *ringWriter
+		logPath string
+	)
+	// io.Writer(io.Discard) keeps the interface type (serverErr is reassigned to
+	// io.MultiWriter / *ringWriter below) without the redundant typed-var
+	// declaration that staticcheck's QF1011 flags.
+	serverErr := io.Writer(io.Discard)
+	if *url == "" {
+		logTail = newRingWriter(50)
+		if f, path, closeLog := openServerLog(); path != "" {
+			defer closeLog()
+			logPath = path
+			serverErr = io.MultiWriter(f, logTail)
+		} else {
+			serverErr = logTail
+		}
+	}
+
 	// Spawn or attach to the odek serve backend.
 	srv, err := server.Connect(server.Options{
 		URL:       *url,
 		Bin:       *bin,
 		Sandbox:   *sandbox,
 		ExtraArgs: extraArgs,
-		Stderr:    os.Stderr,
+		Stderr:    serverErr,
 	})
 	if err != nil {
+		if logTail != nil {
+			if tail := strings.TrimSpace(logTail.String()); tail != "" {
+				return fmt.Errorf("%w\n\nodek serve output:\n%s", err, tail)
+			}
+		}
 		return err
 	}
 	defer srv.Stop()
@@ -76,9 +107,14 @@ func run() error {
 	model := tui.New(cl, tui.Options{
 		Sandbox: *sandbox,
 		CWD:     cwd,
+		LogPath: logPath,
 	})
 
-	p := tea.NewProgram(model, tea.WithAltScreen(), tea.WithMouseCellMotion())
+	// No mouse capture: with mouse reporting on, the terminal cannot do native
+	// click-drag text selection. Leaving it off lets users select & copy text
+	// (copy-on-select where the terminal supports it). Scrolling stays on the
+	// keyboard (PgUp/PgDn, ^U/^D).
+	p := tea.NewProgram(model, tea.WithAltScreen())
 	if _, err := p.Run(); err != nil {
 		return fmt.Errorf("TUI exited: %w", err)
 	}

internal/tui/banner.go

@@ -1,6 +1,7 @@
 package tui
 
 import (
+	"os"
 	"strings"
 
 	"github.com/charmbracelet/lipgloss"
@@ -22,38 +23,65 @@ var (
 )
 
 // welcome renders the splash shown in the conversation area before the first
-// prompt: the wordmark, a tagline, and a few key bindings.
-func welcome(th theme, width int) string {
+// prompt: the wordmark, a tagline, the working directory, and a few key
+// bindings — left-aligned with a gentle margin.
+func welcome(th theme, width int, cwd string) string {
 	var b strings.Builder
 	for _, line := range bannerArt {
 		b.WriteString(gradient(line, gradFrom, gradTo))
 		b.WriteByte('\n')
 	}
 	b.WriteByte('\n')
 	b.WriteString(th.tagline.Render("a beautiful terminal interface for the odek agent"))
-	b.WriteString("\n\n")
+	b.WriteByte('\n')
+	if dir := shortenHome(cwd); dir != "" {
+		b.WriteString(th.statsDim.Render(dir))
+		b.WriteByte('\n')
+	}
+	b.WriteByte('\n')
 
+	// key column is right-aligned to a fixed width so the descriptions line up.
 	tips := [][2]string{
 		{"type a task", "and press enter to run the agent"},
 		{"/ commands", "type / for commands, e.g. /help /sessions /model"},
+		{"/stats", "session metrics & live context-window gauge"},
 		{"@ to attach", "attach files, e.g. @main.go"},
 		{"⏎ send", "·  ^J newline  ·  ^T toggle thinking"},
 		{"^L clear", "·  PgUp/PgDn scroll  ·  ^C quit"},
 		{"approvals", "answer with [a]pprove [d]eny [t]rust"},
 	}
+	const keyW = 11
 	for _, t := range tips {
-		b.WriteString("  " + th.tipKey.Render(pad(t[0], 12)) + th.tipText.Render(t[1]) + "\n")
+		b.WriteString(th.tipKey.Render(padLeft(t[0], keyW)) + "  " + th.tipText.Render(t[1]) + "\n")
 	}
 
-	block := b.String()
-	// Center the splash block within the available width for a polished look.
-	return lipgloss.NewStyle().Width(width).Align(lipgloss.Center).Render(block)
+	block := strings.TrimRight(b.String(), "\n")
+	// Left-aligned (no centering) with a small left margin for breathing room.
+	return lipgloss.NewStyle().Width(width).PaddingLeft(2).Render(block)
 }
 
-// pad right-pads s with spaces to width n.
-func pad(s string, n int) string {
-	if lipgloss.Width(s) >= n {
+// padLeft left-pads s with spaces to width n (right-aligns within the column).
+func padLeft(s string, n int) string {
+	w := lipgloss.Width(s)
+	if w >= n {
 		return s
 	}
-	return s + strings.Repeat(" ", n-lipgloss.Width(s))
+	return strings.Repeat(" ", n-w) + s
+}
+
+// shortenHome replaces a leading $HOME with "~" for a compact, readable path.
+func shortenHome(p string) string {
+	p = strings.TrimSpace(p)
+	if p == "" {
+		return ""
+	}
+	if home, err := os.UserHomeDir(); err == nil && home != "" {
+		if p == home {
+			return "~"
+		}
+		if strings.HasPrefix(p, home+string(os.PathSeparator)) {
+			return "~" + p[len(home):]
+		}
+	}
+	return p
 }