feat: Add conversation history and resume functionality

[nachoal]

Summary

This PR adds comprehensive conversation history and resume functionality to Simple Agent Go, allowing users to continue conversations across sessions and maintain context when working in the same directory.

Key Features

1. Conversation Persistence

• All conversations are automatically saved to ~/.simple-agent/sessions/
• Sessions are stored as JSON files with full message history
• Each session includes metadata: ID, timestamps, path, provider, model

2. New CLI Flags

• -c/--continue: Continue the last conversation in the current directory
• -r/--resume: Show interactive session picker or resume specific session
  • simple-agent -r - Opens session picker UI
  • simple-agent -r <session-id> - Directly resume specific session

3. Session Management

• Sessions are indexed by directory path for easy retrieval
• Session IDs use format: YYYYMMDD_HHMMSS_<6-char-random>
• Meta index file tracks sessions per directory

4. Interactive Session Picker

• Clean Bubble Tea UI for selecting sessions
• Shows: date/time, title, message count, provider/model
• Keyboard navigation: arrows/j/k, Enter to select, Esc to cancel

Implementation Details

Architecture

• history/ package: Core types and manager for session persistence
• agent.HistoryAgent: Wrapper that auto-saves after each message
• tui.SessionPicker: Interactive UI component for session selection
• Extended Agent interface with SetMemory() for restoring conversations

Technical Improvements

• Used Cobra's NoOptDefVal for optional flag arguments
• Fixed type assertion issues (value vs pointer types)
• Proper session restoration with provider/model settings preserved
• Debug output for troubleshooting (enabled with -v)

Testing

The implementation has been tested with:

• Creating new sessions
• Continuing last conversation with -c
• Interactive session picker with -r
• Direct session resume with -r <id>
• Cross-directory session isolation
• Provider/model preservation across sessions

Example Usage

# Start a new conversation
./simple-agent

# Continue last conversation in current directory
./simple-agent -c

# Show session picker
./simple-agent -r

# Resume specific session
./simple-agent -r 20250731_101333_abc123

Future Enhancements

• Session search functionality
• Export conversations to Markdown/JSON
• Session cleanup/archival
• Token usage tracking

This implementation provides a solid foundation for conversation persistence while maintaining the simplicity and performance that makes Simple Agent Go successful.

🤖 Generated with Claude Code

[claude]

Claude finished @nachoal's task —— View job

---

PR Review: Conversation History Implementation

Reviewing the conversation history and resume functionality implementation...

Todo List

• Read and analyze core implementation files
• Review code quality and Go best practices
• Check for security concerns
• Analyze performance considerations
• Assess error handling
• Review existing automated feedback
• Provide comprehensive feedback

Code Review Feedback

Critical Issues (Must Fix)

1. SessionPicker UI Completely Non-Functional 🚨

File: tui/session_picker.go:41

The Update method uses a value receiver instead of a pointer receiver:

func (p SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

This is a critical bug that makes the session picker completely unusable:

• All field updates (p.selected, p.width, p.height, p.SelectedSessionID) are lost
• Keyboard navigation fails silently
• Session selection doesn't work

Fix: Change to pointer receiver:

func (p *SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

2. Potential Security Issue in Random ID Generation 🔐

File: history/manager.go:317

Ignoring crypto/rand errors can lead to weak session IDs:

if _, err := rand.Read(b); err != nil {
    // Fall back to time-based seed if crypto/rand fails
    // This should be extremely rare
    panic(fmt.Sprintf("crypto/rand failed: %v", err))
}

While the panic approach ensures no weak IDs are generated, it's overly aggressive. Better approach:

if _, err := rand.Read(b); err != nil {
    return "", fmt.Errorf("failed to generate secure random ID: %w", err)
}

Major Issues

3. Inconsistent Error Handling in Session Loading

File: history/manager.go:172-175

Silent failures in ListSessionsForPath could hide corruption:

for _, id := range sessionIDs {
    session, err := m.LoadSession(id)
    if err != nil {
        continue  // Silent failure
    }
    // ...
}

This could mask serious issues. Consider logging errors or returning partial results with error information.

4. Race Condition in History Agent

File: agent/history_agent.go:111-112

SaveSession in goroutine has no error handling:

// Save session
ha.historyManager.SaveSession(ha.currentSession)

If this fails, the conversation history is silently lost. Should at least log the error.

Design & Architecture Issues

5. Memory Leak in Stream Interception

File: agent/history_agent.go:85

Large buffer allocation without bounds checking:

intercepted := make(chan StreamEvent, 100)

For long conversations, this could accumulate significant memory. Consider smaller buffer or dynamic sizing.

6. File Permission Security

File: history/manager.go:104

Session files use world-readable permissions:

if err := os.WriteFile(filename, data, 0644); err != nil {

Conversation history may contain sensitive information. Consider using 0600 (user-only access).

Code Quality Issues

7. Magic Numbers and Hard-coded Values

• Buffer size: intercepted := make(chan StreamEvent, 100) - should be configurable
• File permissions: 0755, 0644 - should be constants
• Title truncation: 50 characters - should be configurable

8. Timestamp Loss in Message Conversion

File: history/manager.go:204

Converting from LLM messages loses original timestamps:

Timestamp:  time.Now(), // We don't have original timestamps

This makes conversation history less useful for debugging and analysis.

Performance Considerations

9. Inefficient Session Sorting

File: history/manager.go:188-191

Sessions are sorted on every request. For users with many sessions, this could be slow. Consider:

• Caching sorted results
• Maintaining sorted order in the index
• Pagination for large session lists

10. JSON Marshaling on Every Save

File: history/manager.go:98

Pretty-printing JSON on every save adds overhead:

data, err := json.MarshalIndent(session, "", "  ")

For frequent saves, consider using json.Marshal and only pretty-print for exports.

Positive Aspects

✅ Well-structured architecture - Clean separation between history management and agent logic
✅ Comprehensive type definitions - Good use of Go struct tags and clear interfaces
✅ Proper mutex usage - Thread-safe operations in the manager
✅ Good error wrapping - Consistent use of fmt.Errorf with %w verb
✅ Intuitive CLI design - Clear flag handling with Cobra

Test Coverage Assessment

Missing Test Areas:

• Session persistence and loading
• Concurrent access to history manager
• Error scenarios (corrupted files, permission issues)
• CLI flag combinations and edge cases
• TUI keyboard navigation and selection

Recommendations

1. Fix the critical SessionPicker bug immediately - this breaks the main feature
2. Improve error handling - especially in async operations and file I/O
3. Add configuration options - for buffer sizes, file permissions, and UI settings
4. Consider adding logging - structured logging for debugging session management
5. Add comprehensive tests - unit tests for manager operations and TUI interactions

Security Recommendations

• Use restrictive file permissions (0600) for session files
• Validate session file contents before loading
• Consider encrypting sensitive conversation data
• Add session cleanup/rotation for old conversations

This is a solid foundation for conversation history, but the critical SessionPicker bug needs immediate attention.

[claude]

Claude finished @nachoal's task —— View job

---

PR Review: Conversation History Implementation

Reviewing the conversation history and resume functionality implementation...

Todo List

• Read and analyze core implementation files
• Review code quality and Go best practices
• Check for security concerns
• Analyze performance considerations
• Assess error handling
• Review existing automated feedback
• Provide comprehensive feedback

Code Review Feedback

Critical Issues (Must Fix)

1. SessionPicker UI Completely Non-Functional 🚨

File: tui/session_picker.go:41

The Update method uses a value receiver instead of a pointer receiver:

func (p SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

This is a critical bug that makes the session picker completely unusable:

• All field updates (p.selected, p.width, p.height, p.SelectedSessionID) are lost
• Keyboard navigation fails silently
• Session selection doesn't work

Fix: Change to pointer receiver:

func (p *SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

2. Potential Security Issue in Random ID Generation 🔐

File: history/manager.go:317

Ignoring crypto/rand errors can lead to weak session IDs:

if _, err := rand.Read(b); err != nil {
    // Fall back to time-based seed if crypto/rand fails
    // This should be extremely rare
    panic(fmt.Sprintf("crypto/rand failed: %v", err))
}

While the panic approach ensures no weak IDs are generated, it's overly aggressive. Better approach:

if _, err := rand.Read(b); err != nil {
    return "", fmt.Errorf("failed to generate secure random ID: %w", err)
}

Major Issues

3. Inconsistent Error Handling in Session Loading

File: history/manager.go:172-175

Silent failures in ListSessionsForPath could hide corruption:

for _, id := range sessionIDs {
    session, err := m.LoadSession(id)
    if err != nil {
        continue  // Silent failure
    }
    // ...
}

This could mask serious issues. Consider logging errors or returning partial results with error information.

4. Race Condition in History Agent

File: agent/history_agent.go:111-112

SaveSession in goroutine has no error handling:

// Save session
ha.historyManager.SaveSession(ha.currentSession)

If this fails, the conversation history is silently lost. Should at least log the error.

Design & Architecture Issues

5. Memory Leak in Stream Interception

File: agent/history_agent.go:85

Large buffer allocation without bounds checking:

intercepted := make(chan StreamEvent, 100)

For long conversations, this could accumulate significant memory. Consider smaller buffer or dynamic sizing.

6. File Permission Security

File: history/manager.go:104

Session files use world-readable permissions:

if err := os.WriteFile(filename, data, 0644); err != nil {

Conversation history may contain sensitive information. Consider using 0600 (user-only access).

Code Quality Issues

7. Magic Numbers and Hard-coded Values

• Buffer size: intercepted := make(chan StreamEvent, 100) - should be configurable
• File permissions: 0755, 0644 - should be constants
• Title truncation: 50 characters - should be configurable

8. Timestamp Loss in Message Conversion

File: history/manager.go:204

Converting from LLM messages loses original timestamps:

Timestamp:  time.Now(), // We don't have original timestamps

This makes conversation history less useful for debugging and analysis.

Performance Considerations

9. Inefficient Session Sorting

File: history/manager.go:188-191

Sessions are sorted on every request. For users with many sessions, this could be slow. Consider:

• Caching sorted results
• Maintaining sorted order in the index
• Pagination for large session lists

10. JSON Marshaling on Every Save

File: history/manager.go:98

Pretty-printing JSON on every save adds overhead:

data, err := json.MarshalIndent(session, "", "  ")

For frequent saves, consider using json.Marshal and only pretty-print for exports.

Positive Aspects

✅ Well-structured architecture - Clean separation between history management and agent logic
✅ Comprehensive type definitions - Good use of Go struct tags and clear interfaces
✅ Proper mutex usage - Thread-safe operations in the manager
✅ Good error wrapping - Consistent use of fmt.Errorf with %w verb
✅ Intuitive CLI design - Clear flag handling with Cobra

Test Coverage Assessment

Missing Test Areas:

• Session persistence and loading
• Concurrent access to history manager
• Error scenarios (corrupted files, permission issues)
• CLI flag combinations and edge cases
• TUI keyboard navigation and selection

Recommendations

1. Fix the critical SessionPicker bug immediately - this breaks the main feature
2. Improve error handling - especially in async operations and file I/O
3. Add configuration options - for buffer sizes, file permissions, and UI settings
4. Consider adding logging - structured logging for debugging session management
5. Add comprehensive tests - unit tests for manager operations and TUI interactions

Security Recommendations

• Use restrictive file permissions (0600) for session files
• Validate session file contents before loading
• Consider encrypting sensitive conversation data
• Add session cleanup/rotation for old conversations

This is a solid foundation for conversation history, but the critical SessionPicker bug needs immediate attention.

[claude]

Claude finished @nachoal's task —— View job

---

PR Review: Conversation History Implementation

Reviewing the conversation history and resume functionality implementation...

Todo List

• Read and analyze core implementation files
• Review code quality and Go best practices
• Check for security concerns
• Analyze performance considerations
• Assess error handling
• Review existing automated feedback
• Provide comprehensive feedback

Code Review Feedback

Critical Issues (Must Fix)

1. SessionPicker UI Completely Non-Functional 🚨

File: tui/session_picker.go:41

The Update method uses a value receiver instead of a pointer receiver:

func (p SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

This is a critical bug that makes the session picker completely unusable:

• All field updates (p.selected, p.width, p.height, p.SelectedSessionID) are lost
• Keyboard navigation fails silently
• Session selection doesn't work

Fix: Change to pointer receiver:

func (p *SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

2. Potential Security Issue in Random ID Generation 🔐

File: history/manager.go:317

Ignoring crypto/rand errors can lead to weak session IDs:

if _, err := rand.Read(b); err != nil {
    // Fall back to time-based seed if crypto/rand fails
    // This should be extremely rare
    panic(fmt.Sprintf("crypto/rand failed: %v", err))
}

While the panic approach ensures no weak IDs are generated, it's overly aggressive. Better approach:

if _, err := rand.Read(b); err != nil {
    return "", fmt.Errorf("failed to generate secure random ID: %w", err)
}

Major Issues

3. Inconsistent Error Handling in Session Loading

File: history/manager.go:172-175

Silent failures in ListSessionsForPath could hide corruption:

for _, id := range sessionIDs {
    session, err := m.LoadSession(id)
    if err != nil {
        continue  // Silent failure
    }
    // ...
}

This could mask serious issues. Consider logging errors or returning partial results with error information.

4. Race Condition in History Agent

File: agent/history_agent.go:111-112

SaveSession in goroutine has no error handling:

// Save session
ha.historyManager.SaveSession(ha.currentSession)

If this fails, the conversation history is silently lost. Should at least log the error.

Design & Architecture Issues

5. Memory Leak in Stream Interception

File: agent/history_agent.go:85

Large buffer allocation without bounds checking:

intercepted := make(chan StreamEvent, 100)

For long conversations, this could accumulate significant memory. Consider smaller buffer or dynamic sizing.

6. File Permission Security

File: history/manager.go:104

Session files use world-readable permissions:

if err := os.WriteFile(filename, data, 0644); err != nil {

Conversation history may contain sensitive information. Consider using 0600 (user-only access).

Code Quality Issues

7. Magic Numbers and Hard-coded Values

• Buffer size: intercepted := make(chan StreamEvent, 100) - should be configurable
• File permissions: 0755, 0644 - should be constants
• Title truncation: 50 characters - should be configurable

8. Timestamp Loss in Message Conversion

File: history/manager.go:204

Converting from LLM messages loses original timestamps:

Timestamp:  time.Now(), // We don't have original timestamps

This makes conversation history less useful for debugging and analysis.

Performance Considerations

9. Inefficient Session Sorting

File: history/manager.go:188-191

Sessions are sorted on every request. For users with many sessions, this could be slow. Consider:

• Caching sorted results
• Maintaining sorted order in the index
• Pagination for large session lists

10. JSON Marshaling on Every Save

File: history/manager.go:98

Pretty-printing JSON on every save adds overhead:

data, err := json.MarshalIndent(session, "", "  ")

For frequent saves, consider using json.Marshal and only pretty-print for exports.

Positive Aspects

✅ Well-structured architecture - Clean separation between history management and agent logic
✅ Comprehensive type definitions - Good use of Go struct tags and clear interfaces
✅ Proper mutex usage - Thread-safe operations in the manager
✅ Good error wrapping - Consistent use of fmt.Errorf with %w verb
✅ Intuitive CLI design - Clear flag handling with Cobra

Test Coverage Assessment

Missing Test Areas:

• Session persistence and loading
• Concurrent access to history manager
• Error scenarios (corrupted files, permission issues)
• CLI flag combinations and edge cases
• TUI keyboard navigation and selection

Recommendations

1. Fix the critical SessionPicker bug immediately - this breaks the main feature
2. Improve error handling - especially in async operations and file I/O
3. Add configuration options - for buffer sizes, file permissions, and UI settings
4. Consider adding logging - structured logging for debugging session management
5. Add comprehensive tests - unit tests for manager operations and TUI interactions

Security Recommendations

• Use restrictive file permissions (0600) for session files
• Validate session file contents before loading
• Consider encrypting sensitive conversation data
• Add session cleanup/rotation for old conversations

This is a solid foundation for conversation history, but the critical SessionPicker bug needs immediate attention.

---

[claude]

Claude finished @nachoal's task —— View job

---

PR Review: Conversation History Implementation

Reviewing the conversation history and resume functionality implementation...

Todo List

• Read and analyze core implementation files
• Review code quality and Go best practices
• Check for security concerns
• Analyze performance considerations
• Assess error handling
• Review existing automated feedback
• Provide comprehensive feedback

Code Review Feedback

Critical Issues (Must Fix)

1. SessionPicker UI Completely Non-Functional 🚨

File: tui/session_picker.go:41

The Update method uses a value receiver instead of a pointer receiver:

func (p SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

This is a critical bug that makes the session picker completely unusable:

• All field updates (p.selected, p.width, p.height, p.SelectedSessionID) are lost
• Keyboard navigation fails silently
• Session selection doesn't work

Fix: Change to pointer receiver:

func (p *SessionPicker) Update(msg tea.Msg) (tea.Model, tea.Cmd) {

2. Potential Security Issue in Random ID Generation 🔐

File: history/manager.go:317

Ignoring crypto/rand errors can lead to weak session IDs:

if _, err := rand.Read(b); err != nil {
    // Fall back to time-based seed if crypto/rand fails
    // This should be extremely rare
    panic(fmt.Sprintf("crypto/rand failed: %v", err))
}

While the panic approach ensures no weak IDs are generated, it's overly aggressive. Better approach:

if _, err := rand.Read(b); err != nil {
    return "", fmt.Errorf("failed to generate secure random ID: %w", err)
}

Major Issues

3. Inconsistent Error Handling in Session Loading

File: history/manager.go:172-175

Silent failures in ListSessionsForPath could hide corruption:

for _, id := range sessionIDs {
    session, err := m.LoadSession(id)
    if err != nil {
        continue  // Silent failure
    }
    // ...
}

This could mask serious issues. Consider logging errors or returning partial results with error information.

4. Race Condition in History Agent

File: agent/history_agent.go:111-112

SaveSession in goroutine has no error handling:

// Save session
ha.historyManager.SaveSession(ha.currentSession)

If this fails, the conversation history is silently lost. Should at least log the error.

Design & Architecture Issues

5. Memory Leak in Stream Interception

File: agent/history_agent.go:85

Large buffer allocation without bounds checking:

intercepted := make(chan StreamEvent, 100)

For long conversations, this could accumulate significant memory. Consider smaller buffer or dynamic sizing.

6. File Permission Security

File: history/manager.go:104

Session files use world-readable permissions:

if err := os.WriteFile(filename, data, 0644); err != nil {

Conversation history may contain sensitive information. Consider using 0600 (user-only access).

Code Quality Issues

7. Magic Numbers and Hard-coded Values

• Buffer size: intercepted := make(chan StreamEvent, 100) - should be configurable
• File permissions: 0755, 0644 - should be constants
• Title truncation: 50 characters - should be configurable

8. Timestamp Loss in Message Conversion

File: history/manager.go:204

Converting from LLM messages loses original timestamps:

Timestamp:  time.Now(), // We don't have original timestamps

This makes conversation history less useful for debugging and analysis.

Performance Considerations

9. Inefficient Session Sorting

File: history/manager.go:188-191

Sessions are sorted on every request. For users with many sessions, this could be slow. Consider:

• Caching sorted results
• Maintaining sorted order in the index
• Pagination for large session lists

10. JSON Marshaling on Every Save

File: history/manager.go:98

Pretty-printing JSON on every save adds overhead:

data, err := json.MarshalIndent(session, "", "  ")

For frequent saves, consider using json.Marshal and only pretty-print for exports.

Positive Aspects

✅ Well-structured architecture - Clean separation between history management and agent logic
✅ Comprehensive type definitions - Good use of Go struct tags and clear interfaces
✅ Proper mutex usage - Thread-safe operations in the manager
✅ Good error wrapping - Consistent use of fmt.Errorf with %w verb
✅ Intuitive CLI design - Clear flag handling with Cobra

Test Coverage Assessment

Missing Test Areas:

• Session persistence and loading
• Concurrent access to history manager
• Error scenarios (corrupted files, permission issues)
• CLI flag combinations and edge cases
• TUI keyboard navigation and selection

Recommendations

1. Fix the critical SessionPicker bug immediately - this breaks the main feature
2. Improve error handling - especially in async operations and file I/O
3. Add configuration options - for buffer sizes, file permissions, and UI settings
4. Consider adding logging - structured logging for debugging session management
5. Add comprehensive tests - unit tests for manager operations and TUI interactions

Security Recommendations

• Use restrictive file permissions (0600) for session files
• Validate session file contents before loading
• Consider encrypting sensitive conversation data
• Add session cleanup/rotation for old conversations

This is a solid foundation for conversation history, but the critical SessionPicker bug needs immediate attention.