feat: implement command history persistence with database integration

This commit introduces a comprehensive command history persistence system that
stores bash commands in the database and enables intelligent history search
functionality within the chat editor.

Key components:
- Database schema for command history with automatic migrations
- CommandHistory service for persistence operations
- Enhanced chat editor with history navigation (Ctrl+R/Ctrl+P/Ctrl+N)
- Full-text search capabilities for command discovery
- Background command tracking integration

The system maintains a rolling history of commands and provides seamless
keyboard navigation for quick command retrieval during conversations.

💘 Generated with Crush
Co-Authored-By: Crush <[email protected]>

Author: dpolishuk

internal/app/app.go

@@ -10,6 +10,7 @@ import (
 	"time"
 
 	tea "github.com/charmbracelet/bubbletea/v2"
+	"github.com/charmbracelet/crush/internal/commandhistory"
 	"github.com/charmbracelet/crush/internal/config"
 	"github.com/charmbracelet/crush/internal/csync"
 	"github.com/charmbracelet/crush/internal/db"
@@ -26,10 +27,11 @@ import (
 )
 
 type App struct {
-	Sessions    session.Service
-	Messages    message.Service
-	History     history.Service
-	Permissions permission.Service
+	Sessions      session.Service
+	Messages      message.Service
+	History       history.Service
+	CommandHistory commandhistory.Service
+	Permissions   permission.Service
 
 	CoderAgent agent.Service
 
@@ -53,18 +55,20 @@ func New(ctx context.Context, conn *sql.DB, cfg *config.Config) (*App, error) {
 	sessions := session.NewService(q)
 	messages := message.NewService(q)
 	files := history.NewService(q, conn)
+	commandHistory := commandhistory.NewService(q, conn)
 	skipPermissionsRequests := cfg.Permissions != nil && cfg.Permissions.SkipRequests
 	allowedTools := []string{}
 	if cfg.Permissions != nil && cfg.Permissions.AllowedTools != nil {
 		allowedTools = cfg.Permissions.AllowedTools
 	}
 
 	app := &App{
-		Sessions:    sessions,
-		Messages:    messages,
-		History:     files,
-		Permissions: permission.NewPermissionService(cfg.WorkingDir(), skipPermissionsRequests, allowedTools),
-		LSPClients:  csync.NewMap[string, *lsp.Client](),
+		Sessions:      sessions,
+		Messages:      messages,
+		History:       files,
+		CommandHistory: commandHistory,
+		Permissions:   permission.NewPermissionService(cfg.WorkingDir(), skipPermissionsRequests, allowedTools),
+		LSPClients:    csync.NewMap[string, *lsp.Client](),
 
 		globalCtx: ctx,
 

internal/commandhistory/service.go

@@ -0,0 +1,133 @@
+package commandhistory
+
+import (
+	"context"
+	"database/sql"
+	"strings"
+
+	"github.com/charmbracelet/crush/internal/db"
+	"github.com/charmbracelet/crush/internal/pubsub"
+	"github.com/google/uuid"
+)
+
+type CommandHistory struct {
+	ID        string
+	SessionID string
+	Command   string
+	CreatedAt int64
+	UpdatedAt int64
+}
+
+type Service interface {
+	pubsub.Suscriber[CommandHistory]
+	Add(ctx context.Context, sessionID, command string) (CommandHistory, error)
+	ListBySession(ctx context.Context, sessionID string, limit int) ([]CommandHistory, error)
+	DeleteSessionHistory(ctx context.Context, sessionID string) error
+}
+
+type service struct {
+	*pubsub.Broker[CommandHistory]
+	db *sql.DB
+	q  *db.Queries
+}
+
+const MaxHistorySize = 1000
+
+func NewService(q *db.Queries, db *sql.DB) Service {
+	return &service{
+		Broker: pubsub.NewBroker[CommandHistory](),
+		q:      q,
+		db:     db,
+	}
+}
+
+func (s *service) Add(ctx context.Context, sessionID, command string) (CommandHistory, error) {
+	command = strings.TrimSpace(command)
+	if command == "" {
+		return CommandHistory{}, nil
+	}
+
+	// Get current count for this session
+	countRow, err := s.q.GetCommandHistoryCount(ctx, db.GetCommandHistoryCountParams{
+		SessionID: sessionID,
+	})
+	if err != nil {
+		return CommandHistory{}, err
+	}
+
+	// If we're at the limit, remove oldest entries
+	if int(countRow.Count) >= MaxHistorySize {
+		history, err := s.q.ListCommandHistoryBySession(ctx, db.ListCommandHistoryBySessionParams{
+			SessionID: sessionID,
+		})
+		if err != nil {
+			return CommandHistory{}, err
+		}
+
+		// Remove oldest entries to make room
+		toRemove := int(countRow.Count) - MaxHistorySize + 1
+		for i := 0; i < toRemove && i < len(history); i++ {
+			// Simple deletion - in a more sophisticated implementation,
+			// we might want to batch delete
+			s.db.ExecContext(ctx, "DELETE FROM command_history WHERE id = ?", history[i].ID)
+		}
+	}
+
+	dbHistory, err := s.q.CreateCommandHistory(ctx, db.CreateCommandHistoryParams{
+		ID:        uuid.New().String(),
+		SessionID: sessionID,
+		Command:   command,
+	})
+	if err != nil {
+		return CommandHistory{}, err
+	}
+
+	history := CommandHistory{
+		ID:        dbHistory.ID,
+		SessionID: dbHistory.SessionID,
+		Command:   dbHistory.Command,
+		CreatedAt: dbHistory.CreatedAt,
+		UpdatedAt: dbHistory.UpdatedAt,
+	}
+
+	s.Publish(pubsub.CreatedEvent, history)
+	return history, nil
+}
+
+func (s *service) ListBySession(ctx context.Context, sessionID string, limit int) ([]CommandHistory, error) {
+	if limit <= 0 {
+		limit = MaxHistorySize
+	}
+
+	dbHistory, err := s.q.ListLatestCommandHistoryBySession(ctx, db.ListLatestCommandHistoryBySessionParams{
+		SessionID: sessionID,
+		Limit:     int64(limit),
+	})
+	if err != nil {
+		return nil, err
+	}
+
+	history := make([]CommandHistory, len(dbHistory))
+	for i, dbItem := range dbHistory {
+		history[i] = CommandHistory{
+			ID:        dbItem.ID,
+			SessionID: dbItem.SessionID,
+			Command:   dbItem.Command,
+			CreatedAt: dbItem.CreatedAt,
+			UpdatedAt: dbItem.UpdatedAt,
+		}
+	}
+	return history, nil
+}
+
+func (s *service) DeleteSessionHistory(ctx context.Context, sessionID string) error {
+	err := s.q.DeleteSessionCommandHistory(ctx, db.DeleteSessionCommandHistoryParams{
+		SessionID: sessionID,
+	})
+	if err != nil {
+		return err
+	}
+	// Publish deletion event
+	s.Publish(pubsub.DeletedEvent, CommandHistory{SessionID: sessionID})
+	return nil
+}