TUI markdown rendering, escape sanitization, and test infrastructure (#242)

## Summary

- Add glamour-based markdown rendering to TUI review and prompt views
with caching, scroll fixes, and configurable tab width
- Sanitize non-SGR terminal escape sequences (OSC, DCS, private-mode
CSI) in rendered output to prevent terminal injection from untrusted
content
- Implement CommonMark-compliant fence detection for code block
pre-truncation
- Move slow CLI tests behind `//go:build integration` tag (unit tests:
35s -> 12s)
- Separate Postgres tests into `//go:build postgres` tag to avoid CI
failures in jobs without Postgres
- Restructure Makefile test targets: `test` (unit), `test-integration`
(unit+slow), `test-postgres` (postgres), `test-all` (everything)
- Update CI to pass correct build tags per job

## Test plan

- [x] Unit tests pass (`go test ./...`)
- [x] Integration tests pass (`go test -tags integration ./...`)
- [x] Postgres tests pass (`make test-postgres`)
- [x] Escape sanitization covers SGR preservation, OSC/DCS/CSI
stripping, private-mode CSI, and incomplete sequences
- [x] Fence detection handles CommonMark edge cases (indented fences,
tilde fences, invalid closers)
- [x] Fallback render path applies sanitization

🤖 Generated with [Claude Code](https://claude.com/claude-code)

---------

Co-authored-by: Claude Opus 4.6 <noreply@anthropic.com>

Author: wesm

.github/workflows/ci.yml

@@ -29,11 +29,11 @@ jobs:
 
       - name: Test with race detection (Linux/macOS)
         if: matrix.os != 'windows-latest'
-        run: go test -race ./...
+        run: go test -race -tags integration ./...
 
       - name: Test (Windows)
         if: matrix.os == 'windows-latest'
-        run: go test ./...
+        run: go test -tags integration ./...
 
       - name: Build with CGO disabled
         run: go build ./...
@@ -52,7 +52,7 @@ jobs:
       - name: Test with coverage
         # -p 1 serializes package execution to avoid ROBOREV_DATA_DIR race conditions
         # between tests in different packages that modify this environment variable
-        run: go test -race -p 1 -coverprofile=coverage.out ./...
+        run: go test -race -tags integration -p 1 -coverprofile=coverage.out ./...
 
       - name: Upload coverage
         uses: codecov/codecov-action@v4
@@ -84,7 +84,7 @@ jobs:
           go-version: '1.24'
 
       - name: Run integration tests
-        run: go test -tags=integration -v ./internal/storage/... -run Integration
+        run: go test -tags=postgres -v ./internal/storage/... -run Integration
         env:
           TEST_POSTGRES_URL: postgres://roborev_test:roborev_test_password@localhost:5433/roborev_test
 

AGENTS.md

@@ -46,7 +46,8 @@ Runtime:
 
 - Tests should be fast and isolated; use `t.TempDir()`.
 - Use the `agent = "test"` path to avoid calling real AI agents.
-- Suggested commands: `go test ./...`, `go build ./...`, `make install`.
+- Slow integration tests use `//go:build integration` and are excluded by default.
+- Suggested commands: `go test ./...` (unit), `go test -tags integration ./...` (all), `go build ./...`, `make install`.
 
 ## Review/Refine Guidance
 

CLAUDE.md

@@ -51,13 +51,19 @@ CLI (roborev) → HTTP API → Daemon (roborev daemon run) → Worker Pool → A
 ## Commands
 
 ```bash
-go build ./...           # Build
-go test ./...            # Test
-make install             # Install to ~/.local/bin
-roborev init             # Initialize in a repo
-roborev status           # Check daemon/queue
+go build ./...                       # Build
+go test ./...                        # Test (unit tests only)
+go test -tags integration ./...      # Test (unit + integration)
+make install                         # Install to ~/.local/bin
+roborev init                         # Initialize in a repo
+roborev status                       # Check daemon/queue
 ```
 
+Slow integration tests use the `//go:build integration` tag and are excluded
+from `go test ./...` by default. They run in CI and can be run locally with
+`-tags integration`. Postgres tests use `//go:build postgres` and require a
+running Postgres instance (`TEST_POSTGRES_URL` env var).
+
 ## Adding a New Agent
 
 1. Create `internal/agent/newagent.go`

Makefile

@@ -3,7 +3,7 @@
 VERSION := $(shell git describe --tags --always --dirty 2>/dev/null || echo "dev")
 LDFLAGS := -X github.com/roborev-dev/roborev/internal/version.Version=$(VERSION)
 
-.PHONY: build install clean test test-integration test-all postgres-up postgres-down
+.PHONY: build install clean test test-integration test-postgres test-all postgres-up postgres-down test-postgres-ci
 
 build:
 	@mkdir -p bin
@@ -19,28 +19,32 @@ install:
 clean:
 	rm -rf bin/
 
-# Unit tests only (excludes integration tests)
+# Unit tests only (excludes integration and postgres tests)
 test:
 	go test ./...
 
-# Start postgres for integration tests
+# Unit + slow integration tests (no postgres required)
+test-integration:
+	go test -tags=integration ./...
+
+# Start postgres for postgres tests
 postgres-up:
 	docker compose -f docker-compose.test.yml up -d --wait
 
 # Stop postgres
 postgres-down:
 	docker compose -f docker-compose.test.yml down
 
-# Integration tests (requires postgres running)
-test-integration: postgres-up
+# Postgres tests (requires postgres running)
+test-postgres: postgres-up
 	@echo "Waiting for postgres to be ready..."
 	@sleep 2
 	TEST_POSTGRES_URL="postgres://roborev_test:roborev_test_password@localhost:5433/roborev_test" \
-		go test -tags=integration -v ./internal/storage/... -run Integration
+		go test -tags=postgres -v ./internal/storage/... -run Integration
 
-# Run all tests including integration
-test-all: test test-integration
+# Run all tests (unit + integration + postgres)
+test-all: test-integration test-postgres
 
-# CI target: run integration tests without managing docker (assumes postgres is running)
-test-integration-ci:
-	go test -tags=integration -v ./internal/storage/... -run Integration
+# CI target: run postgres tests without managing docker (assumes postgres is running)
+test-postgres-ci:
+	go test -tags=postgres -v ./internal/storage/... -run Integration

cmd/roborev/analyze_integration_test.go

@@ -0,0 +1,172 @@
+//go:build integration
+
+package main
+
+import (
+	"context"
+	"encoding/json"
+	"net/http"
+	"net/http/httptest"
+	"strings"
+	"sync/atomic"
+	"testing"
+	"time"
+
+	"github.com/roborev-dev/roborev/internal/prompt/analyze"
+	"github.com/roborev-dev/roborev/internal/storage"
+)
+
+func TestWaitForAnalysisJob(t *testing.T) {
+	tests := []struct {
+		name       string
+		responses  []jobResponse // sequence of responses
+		wantErr    bool
+		wantErrMsg string
+	}{
+		{
+			name: "immediate success",
+			responses: []jobResponse{
+				{status: "done", review: "Analysis complete: found 3 issues"},
+			},
+		},
+		{
+			name: "queued then done",
+			responses: []jobResponse{
+				{status: "queued"},
+				{status: "running"},
+				{status: "done", review: "All good"},
+			},
+		},
+		{
+			name: "job failed",
+			responses: []jobResponse{
+				{status: "failed", errMsg: "agent crashed"},
+			},
+			wantErr:    true,
+			wantErrMsg: "agent crashed",
+		},
+		{
+			name: "job canceled",
+			responses: []jobResponse{
+				{status: "canceled"},
+			},
+			wantErr:    true,
+			wantErrMsg: "canceled",
+		},
+		{
+			name: "job not found",
+			responses: []jobResponse{
+				{notFound: true},
+			},
+			wantErr:    true,
+			wantErrMsg: "not found",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			var callCount int32
+			ts := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+				idx := int(atomic.AddInt32(&callCount, 1)) - 1
+				if idx >= len(tt.responses) {
+					idx = len(tt.responses) - 1
+				}
+				resp := tt.responses[idx]
+
+				switch {
+				case strings.HasPrefix(r.URL.Path, "/api/jobs"):
+					if resp.notFound {
+						json.NewEncoder(w).Encode(map[string]interface{}{"jobs": []interface{}{}})
+						return
+					}
+					job := storage.ReviewJob{
+						ID:     42,
+						Status: storage.JobStatus(resp.status),
+						Error:  resp.errMsg,
+					}
+					json.NewEncoder(w).Encode(map[string]interface{}{"jobs": []storage.ReviewJob{job}})
+
+				case strings.HasPrefix(r.URL.Path, "/api/review"):
+					json.NewEncoder(w).Encode(storage.Review{
+						JobID:  42,
+						Output: resp.review,
+					})
+				}
+			}))
+			defer ts.Close()
+
+			ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
+			defer cancel()
+
+			review, err := waitForAnalysisJob(ctx, ts.URL, 42)
+
+			if tt.wantErr {
+				if err == nil {
+					t.Fatal("expected error, got nil")
+				}
+				if !strings.Contains(err.Error(), tt.wantErrMsg) {
+					t.Errorf("error %q should contain %q", err.Error(), tt.wantErrMsg)
+				}
+				return
+			}
+
+			if err != nil {
+				t.Fatalf("unexpected error: %v", err)
+			}
+			if review == nil {
+				t.Fatal("expected review, got nil")
+			}
+			if review.Output != tt.responses[len(tt.responses)-1].review {
+				t.Errorf("got review %q, want %q", review.Output, tt.responses[len(tt.responses)-1].review)
+			}
+		})
+	}
+}
+
+func TestRunAnalyzeAndFix_Integration(t *testing.T) {
+	// This tests the full workflow with mocked daemon and test agent
+	tmpDir := createTestRepo(t, map[string]string{
+		"main.go": "package main\n",
+	})
+
+	ts, state := newMockServer(t, MockServerOpts{
+		JobIDStart:     99,
+		ReviewOutput:   "## CODE SMELLS\n- Found duplicated code in main.go",
+		DoneAfterPolls: 2,
+	})
+
+	cmd, output := newTestCmd(t)
+
+	analysisType := analyze.GetType("refactor")
+	opts := analyzeOptions{
+		agentName: "test",
+		fix:       true,
+		fixAgent:  "test",
+		reasoning: "fast",
+	}
+
+	err := runAnalyzeAndFix(cmd, ts.URL, tmpDir, 99, analysisType, opts)
+	if err != nil {
+		t.Fatalf("runAnalyzeAndFix failed: %v", err)
+	}
+
+	// Verify the workflow was executed
+	if atomic.LoadInt32(&state.JobsCount) < 2 {
+		t.Error("should have polled for job status")
+	}
+	if atomic.LoadInt32(&state.ReviewCount) == 0 {
+		t.Error("should have fetched the review")
+	}
+	if atomic.LoadInt32(&state.AddressCount) == 0 {
+		t.Error("should have marked job as addressed")
+	}
+
+	// Verify output contains analysis result
+	outputStr := output.String()
+	if !strings.Contains(outputStr, "CODE SMELLS") {
+		t.Error("output should contain analysis result")
+	}
+	if !strings.Contains(outputStr, "marked as addressed") {
+		t.Error("output should confirm job was addressed")
+	}
+}