Resume Claude Code Sessions Interactively

A Go-based TUI (Terminal User Interface) application that allows users to browse and resume recent Claude Code sessions. It provides a sophisticated split-screen interface where users can browse projects, view sessions, and preview conversation messages in real-time before resuming.

Architecture Overview

The application follows the Go standard project layout with clean separation of concerns:

Data Flow

1. DuckDB queries read from `~/.claude/projects/**/*.jsonl` files containing session history

2. Projects are fetched first with aggregated statistics (session count, last activity)

3. Sessions are lazily loaded only when a project is selected

4. Messages are lazily loaded when navigating sessions (first 10 + last 10 messages)

5. When a session is selected, the app changes to the project directory and executes `claude --resume <session-id>`

Implementation Instructions

Step 1: Set Up Project Structure

Create the following directory structure:

```

claude-resume/

├── cmd/claude-resume/

│ └── main.go

├── internal/

│ ├── db/

│ │ └── duckdb.go

│ ├── sessions/

│ │ └── sessions.go

│ └── tui/

│ └── tui.go

├── pkg/models/

│ └── models.go

├── go.mod

├── go.sum

├── Makefile

└── CLAUDE.md

```

Step 2: Initialize Go Module

Initialize the project with required dependencies:

```bash

go mod init github.com/username/claude-resume

go get github.com/marcboeker/go-duckdb

go get github.com/charmbracelet/bubbletea

go get github.com/charmbracelet/lipgloss

go get github.com/spf13/cobra

```

Step 3: Implement Database Connection (internal/db/duckdb.go)

Create a singleton DuckDB connection that:

Step 4: Define Data Models (pkg/models/models.go)

Define the following structs:

```go

type Project struct {

Path string

SessionCount int

LastSessionAt time.Time

}

type Session struct {

SessionID string

ProjectPath string

MessageCount int

FirstMessage string

LastActivity time.Time

Messages []Message

}

type Message struct {

Role string

Content string

}

```

Step 5: Implement Session Queries (internal/sessions/sessions.go)

Create three main query functions:

#### FetchProjects()

#### FetchSessions(projectPath string)

#### FetchMessages(projectPath, sessionID string)

Step 6: Build TUI Interface (internal/tui/tui.go)

Implement a Bubble Tea model with the following features:

#### State Management

#### Project View

#### Session View (Split-Screen)

#### Message Display Features

#### Terminal Handling

Step 7: Create CLI Commands (cmd/claude-resume/main.go)

Use Cobra to implement two commands:

#### `claude-resume show`

#### `claude-resume debug-session <session-id>`

Step 8: Add Build Configuration (Makefile)

Create targets for:

Step 9: Handle Session Resumption

When user presses Enter on a selected session:

1. Extract project path from session

2. Use `os.Chdir()` to change to the project directory

3. Execute `claude --resume <session-id>` using `exec.Command()`

4. Exit the TUI cleanly to hand control to Claude Code

Important Implementation Details

SQL Query Patterns

Performance Optimizations

Error Handling

Testing Strategy

Test the following scenarios:

Git Commit Policy

**NEVER execute git commit commands unless explicitly requested by the user.**

Git commits should only be created when the user explicitly asks using phrases like:

This ensures users maintain full control over their git history and can review all changes before committing.

Development Commands

```bash

Build the application

make build

Build and run immediately

make run

Install to Go's bin directory

make install

Run tests

make test

Clean build artifacts

make clean

Update dependencies

go mod tidy

```

Usage Examples

After installation:

```bash

Launch interactive TUI to browse and resume sessions

claude-resume show

Debug a specific session (get raw data)

claude-resume debug-session <session-id>

```

Constraints