gora-cli 0.1.2__tar.gz → 0.1.4__tar.gz

{gora_cli-0.1.2 → gora_cli-0.1.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gora-cli
-Version: 0.1.2
+Version: 0.1.4
 Summary: Local CLI chat history index for Codex, Claude Code, and Pi.
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers
@@ -124,6 +124,8 @@ go -C gora/go_tui build -o ../../dist/gora-tui .
 GORA_TUI_BIN=dist/gora-tui gora
 ```
 
+Live search starts after two characters and updates as you type.
+
 Controls:
 
 ```text

{gora_cli-0.1.2 → gora_cli-0.1.4}/README.md

@@ -111,6 +111,8 @@ go -C gora/go_tui build -o ../../dist/gora-tui .
 GORA_TUI_BIN=dist/gora-tui gora
 ```
 
+Live search starts after two characters and updates as you type.
+
 Controls:
 
 ```text

{gora_cli-0.1.2 → gora_cli-0.1.4}/gora/__init__.py

@@ -2,4 +2,4 @@
 
 __all__ = ["__version__"]
 
-__version__ = "0.1.2"
+__version__ = "0.1.4"

{gora_cli-0.1.2 → gora_cli-0.1.4}/gora/go_tui/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"database/sql"
 	"errors"
 	"flag"
@@ -49,6 +50,33 @@ var (
 	imageTagPattern = regexp.MustCompile(`(?s)</?image\b[^>]*(>|$)`)
 )
 
+const (
+	tuiSearchDebounce = 180 * time.Millisecond
+	tuiSearchMinRunes = 2
+	tuiSearchLimit    = 500
+)
+
+type reloadTickMsg struct {
+	token int
+}
+
+type resultsLoadedMsg struct {
+	token     int
+	query     string
+	rows      []item
+	truncated bool
+	tooShort  bool
+	err       error
+}
+
+type previewLoadedMsg struct {
+	token      int
+	sessionKey string
+	allRoles   bool
+	messages   []transcriptMessage
+	err        error
+}
+
 type item struct {
 	SessionKey   string
 	Provider     string
@@ -334,44 +362,56 @@ func newFilterList(width int, height int) list.Model {
 }
 
 type model struct {
-	db              *sql.DB
-	dbPath          string
-	search          textinput.Model
-	transcriptView  viewport.Model
-	helpBubble      help.Model
-	resultsTable    table.Model
-	filterList      list.Model
-	keys            keyMap
-	providers       map[string]bool
-	repoFilters     map[string]bool
-	modelFilters    map[string]bool
-	providerOptions []filterOption
-	repoOptions     []filterOption
-	modelOptions    []filterOption
-	allRoles        bool
-	detail          bool
-	detailItem      item
-	filterOpen      bool
-	focus           focusArea
-	filterSection   filterSection
-	previewKey      string
-	previewWidth    int
-	previewAllRoles bool
-	previewLines    []string
-	previewErr      error
-	selected        int
-	width           int
-	height          int
-	searchTop       int
-	searchBottom    int
-	filterTop       int
-	filterBottom    int
-	rowsTop         int
-	browseButtons   []actionButton
-	detailButtons   []actionButton
-	results         []item
-	notice          string
-	err             error
+	db                *sql.DB
+	dbPath            string
+	search            textinput.Model
+	transcriptView    viewport.Model
+	helpBubble        help.Model
+	resultsTable      table.Model
+	filterList        list.Model
+	keys              keyMap
+	providers         map[string]bool
+	repoFilters       map[string]bool
+	modelFilters      map[string]bool
+	providerOptions   []filterOption
+	repoOptions       []filterOption
+	modelOptions      []filterOption
+	allRoles          bool
+	detail            bool
+	detailItem        item
+	filterOpen        bool
+	focus             focusArea
+	filterSection     filterSection
+	previewKey        string
+	previewAllRoles   bool
+	previewLoading    bool
+	previewMessages   []transcriptMessage
+	previewErr        error
+	previewToken      int
+	selected          int
+	width             int
+	height            int
+	searchTop         int
+	searchBottom      int
+	filterTop         int
+	filterBottom      int
+	rowsTop           int
+	browseButtons     []actionButton
+	detailButtons     []actionButton
+	results           []item
+	loading           bool
+	searchTooShort    bool
+	resultsTruncated  bool
+	reloadToken       int
+	cancelReload      context.CancelFunc
+	resultsVersion    int
+	tableRowsVersion  int
+	tableRowsWidth    int
+	tableRowsHeight   int
+	tableRowsSelected int
+	tableRows         []table.Row
+	notice            string
+	err               error
 }
 
 func main() {
@@ -391,7 +431,9 @@ func main() {
 		os.Exit(1)
 	}
 	defer db.Close()
-	db.SetMaxOpenConns(1)
+	db.SetMaxOpenConns(4)
+	db.SetMaxIdleConns(4)
+	_, _ = db.Exec("PRAGMA busy_timeout = 1000")
 
 	search := textinput.New()
 	search.Placeholder = "type to search local Codex, Claude Code, and Pi chats"
@@ -419,7 +461,6 @@ func main() {
 	m.providerOptions, _ = loadProviderOptions(db)
 	m.repoOptions, _ = loadRepoOptions(db)
 	m.modelOptions, _ = loadModelOptions(db)
-	m.reload()
 
 	program := tea.NewProgram(m, tea.WithAltScreen(), tea.WithMouseCellMotion())
 	if _, err := program.Run(); err != nil {
@@ -437,7 +478,7 @@ func configureTerminalColors() {
 }
 
 func (m *model) Init() tea.Cmd {
-	return textinput.Blink
+	return tea.Batch(textinput.Blink, m.requestReload(0))
 }
 
 func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
@@ -455,6 +496,15 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		return m, m.handleKey(msg)
 	case tea.MouseMsg:
 		return m, m.handleMouse(msg)
+	case reloadTickMsg:
+		if msg.token != m.reloadToken {
+			return m, nil
+		}
+		return m, m.loadResultsCmd(msg.token)
+	case resultsLoadedMsg:
+		return m, m.applyResults(msg)
+	case previewLoadedMsg:
+		m.applyPreview(msg)
 	}
 	return m, nil
 }
@@ -489,15 +539,13 @@ func (m *model) handleKey(msg tea.KeyMsg) tea.Cmd {
 		if m.search.Value() != "" {
 			m.search.SetValue("")
 			m.resetPosition()
-			m.reload()
-			return nil
+			return m.requestReload(0)
 		}
 		if m.hasActiveFilters() {
 			m.clearFilters()
 			m.notice = "filters cleared"
 			m.resetPosition()
-			m.reload()
-			return nil
+			return m.requestReload(0)
 		}
 		return tea.Quit
 	case "tab":
@@ -510,17 +558,17 @@ func (m *model) handleKey(msg tea.KeyMsg) tea.Cmd {
 	case "/":
 		m.setFocus(focusSearch)
 	case "up", "k":
-		m.move(-1)
 		m.setFocus(focusResults)
+		return m.move(-1)
 	case "down", "j":
-		m.move(1)
 		m.setFocus(focusResults)
+		return m.move(1)
 	case "pgup":
-		m.move(-10)
 		m.setFocus(focusResults)
+		return m.move(-10)
 	case "pgdown":
-		m.move(10)
 		m.setFocus(focusResults)
+		return m.move(10)
 	case "enter", "right":
 		if m.focus == focusFilters {
 			m.openFilters()
@@ -533,27 +581,36 @@ func (m *model) handleKey(msg tea.KeyMsg) tea.Cmd {
 	case "ctrl+r":
 		m.allRoles = !m.allRoles
 		m.resetPosition()
-		m.reload()
+		return m.requestReload(0)
 	case "ctrl+u":
 		m.search.SetValue("")
 		m.resetPosition()
-		m.reload()
+		return m.requestReload(0)
 	default:
 		if m.focus != focusSearch {
+			if key == "q" {
+				return tea.Quit
+			}
 			if key == "m" {
 				m.exportSelected("md")
+				return nil
 			}
 			if key == "t" {
 				m.exportSelected("txt")
+				return nil
+			}
+			if isPrintableSearchKey(msg) {
+				m.setFocus(focusSearch)
+			} else {
+				return nil
 			}
-			return nil
 		}
 		before := m.search.Value()
 		var cmd tea.Cmd
 		m.search, cmd = m.search.Update(msg)
 		if m.search.Value() != before {
 			m.resetPosition()
-			m.reload()
+			return tea.Batch(cmd, m.requestReload(tuiSearchDebounce))
 		}
 		return cmd
 	}
@@ -573,14 +630,12 @@ func (m *model) handleMouse(msg tea.MouseMsg) tea.Cmd {
 		return cmd
 	}
 	if msg.Button == tea.MouseButtonWheelUp {
-		m.move(-3)
 		m.setFocus(focusResults)
-		return nil
+		return m.move(-3)
 	}
 	if msg.Button == tea.MouseButtonWheelDown {
-		m.move(3)
 		m.setFocus(focusResults)
-		return nil
+		return m.move(3)
 	}
 	if msg.Button != tea.MouseButtonLeft || msg.Action != tea.MouseActionPress {
 		return nil
@@ -800,8 +855,21 @@ func (m *model) renderFilters(width int) string {
 }
 
 func (m *model) renderStatus(width int) string {
+	if m.loading {
+		query := strings.TrimSpace(m.search.Value())
+		if query != "" {
+			return m.renderStatusLine(fmt.Sprintf("searching for %q", query), width)
+		}
+		return m.renderStatusLine("loading recent chats", width)
+	}
+	if m.searchTooShort {
+		return m.renderStatusLine(fmt.Sprintf("type at least %d characters to search", tuiSearchMinRunes), width)
+	}
 	if m.search.Value() != "" {
 		status := fmt.Sprintf("%d matches for %q", len(m.results), m.search.Value())
+		if m.resultsTruncated {
+			status = fmt.Sprintf("showing first %d matches for %q", len(m.results), m.search.Value())
+		}
 		return m.renderStatusLine(status, width)
 	}
 	return m.renderStatusLine(fmt.Sprintf("%d recent chats", len(m.results)), width)
@@ -826,6 +894,12 @@ func (m *model) renderResultsTitle(width int) string {
 
 func (m *model) renderResultsTable(width int, height int) string {
 	if len(m.results) == 0 {
+		if m.loading {
+			return mutedStyle.Render("  loading...")
+		}
+		if m.searchTooShort {
+			return mutedStyle.Render(fmt.Sprintf("  type at least %d characters to search", tuiSearchMinRunes))
+		}
 		if m.hasActiveFilters() {
 			return mutedStyle.Render("  no chats match the current filters")
 		}
@@ -894,31 +968,20 @@ func clipStyledLines(lines []string, height int) []string {
 }
 
 func (m *model) transcriptPreviewLines(row item, width int) []string {
-	if m.db == nil {
+	if m.previewKey != row.SessionKey || m.previewAllRoles != m.allRoles || m.previewLoading {
+		return []string{mutedStyle.Render("loading preview...")}
+	}
+	if m.previewErr != nil {
+		return []string{lipgloss.NewStyle().Foreground(red).Render(fit(m.previewErr.Error(), width))}
+	}
+	if len(m.previewMessages) == 0 {
 		fallback := "session " + row.SessionKey
 		if row.Preview != "" {
 			fallback = "match " + row.Preview
 		}
 		return []string{mutedStyle.Render(fit(fallback, width))}
 	}
-	if m.previewKey == row.SessionKey && m.previewWidth == width && m.previewAllRoles == m.allRoles {
-		if m.previewErr != nil {
-			return []string{lipgloss.NewStyle().Foreground(red).Render(fit(m.previewErr.Error(), width))}
-		}
-		return m.previewLines
-	}
-
-	messages, err := loadTranscriptPreviewMessages(m.db, row.SessionKey, m.allRoles, 8)
-	m.previewKey = row.SessionKey
-	m.previewWidth = width
-	m.previewAllRoles = m.allRoles
-	m.previewErr = err
-	if err != nil {
-		m.previewLines = nil
-		return []string{lipgloss.NewStyle().Foreground(red).Render(fit(err.Error(), width))}
-	}
-	m.previewLines = formatTranscriptPreviewLines(messages, width)
-	return m.previewLines
+	return formatTranscriptPreviewLines(m.previewMessages, width)
 }
 
 func formatTranscriptPreviewLines(messages []transcriptMessage, width int) []string {
@@ -960,12 +1023,28 @@ func (m *model) configureResultsTable(width int, height int) {
 	if m.resultsTable.Width() == 0 && m.resultsTable.Height() == 0 {
 		m.resultsTable = newResultsTable()
 	}
-	m.resultsTable.SetColumns(resultTableColumns(width))
 	m.selected = clamp(m.selected, 0, max(0, len(m.results)-1))
-	m.resultsTable.SetRows(resultTableRows(m.results, m.selected))
+	height = max(4, height)
+	if m.tableRowsVersion != m.resultsVersion ||
+		m.tableRowsWidth != width ||
+		m.tableRowsHeight != height {
+		m.resultsTable.SetColumns(resultTableColumns(width))
+		m.tableRows = resultTableRows(m.results, m.selected)
+		m.resultsTable.SetRows(m.tableRows)
+		m.tableRowsVersion = m.resultsVersion
+		m.tableRowsWidth = width
+		m.tableRowsHeight = height
+		m.tableRowsSelected = m.selected
+	} else if m.tableRowsSelected != m.selected {
+		updateSelectedMarker(m.tableRows, m.tableRowsSelected, m.selected)
+		m.resultsTable.SetRows(m.tableRows)
+		m.tableRowsSelected = m.selected
+	}
 	m.resultsTable.SetWidth(width)
-	m.resultsTable.SetHeight(max(4, height))
-	m.resultsTable.SetCursor(m.selected)
+	m.resultsTable.SetHeight(height)
+	if m.resultsTable.Cursor() != m.selected {
+		m.resultsTable.SetCursor(m.selected)
+	}
 	if m.focus == focusResults {
 		m.resultsTable.Focus()
 	} else {
@@ -973,6 +1052,15 @@ func (m *model) configureResultsTable(width int, height int) {
 	}
 }
 
+func updateSelectedMarker(rows []table.Row, oldSelected int, newSelected int) {
+	if oldSelected >= 0 && oldSelected < len(rows) && len(rows[oldSelected]) > 0 {
+		rows[oldSelected][0] = ""
+	}
+	if newSelected >= 0 && newSelected < len(rows) && len(rows[newSelected]) > 0 {
+		rows[newSelected][0] = ">"
+	}
+}
+
 func resultTableColumns(width int) []table.Column {
 	inner := max(40, width-4)
 	markerWidth := 2
@@ -1366,17 +1454,23 @@ func (m *model) renderDetailStatus(width int) string {
 	return ""
 }
 
-func (m *model) move(delta int) {
+func (m *model) move(delta int) tea.Cmd {
 	if len(m.results) == 0 {
 		m.selected = 0
-		return
+		return nil
 	}
+	before := m.selected
 	if delta < 0 {
 		m.resultsTable.MoveUp(-delta)
 	} else {
 		m.resultsTable.MoveDown(delta)
 	}
 	m.selected = clamp(m.resultsTable.Cursor(), 0, len(m.results)-1)
+	m.configureResultsTable(max(72, m.tableRowsWidth), max(4, m.tableRowsHeight))
+	if m.selected == before {
+		return nil
+	}
+	return m.requestPreview()
 }
 
 func (m *model) openDetail() {
@@ -1459,11 +1553,11 @@ func (m *model) openFilters() {
 	m.configureFilterList(max(72, m.width), max(8, m.height-8))
 }
 
-func (m *model) closeFilters() {
+func (m *model) closeFilters() tea.Cmd {
 	m.filterOpen = false
 	m.setFocus(focusFilters)
 	m.resetPosition()
-	m.reload()
+	return m.requestReload(0)
 }
 
 func (m *model) handleFilterKey(msg tea.KeyMsg) tea.Cmd {
@@ -1472,7 +1566,7 @@ func (m *model) handleFilterKey(msg tea.KeyMsg) tea.Cmd {
 	case "ctrl+c":
 		return tea.Quit
 	case "esc", "left":
-		m.closeFilters()
+		return m.closeFilters()
 	case "tab", "right":
 		m.advanceFilterSection()
 	case "shift+tab":
@@ -1734,29 +1828,134 @@ func clearSet(set map[string]bool) {
 	}
 }
 
-func (m *model) reload() {
+func (m *model) requestReload(delay time.Duration) tea.Cmd {
+	if m.cancelReload != nil {
+		m.cancelReload()
+		m.cancelReload = nil
+	}
 	m.err = nil
-	var rows []item
-	var err error
+	m.loading = true
+	m.searchTooShort = false
+	m.resultsTruncated = false
+	m.reloadToken++
+	token := m.reloadToken
+
+	query := strings.TrimSpace(m.search.Value())
+	if query != "" && runeCount(query) < tuiSearchMinRunes {
+		return func() tea.Msg {
+			return resultsLoadedMsg{token: token, query: query, tooShort: true}
+		}
+	}
+	if delay > 0 {
+		return tea.Tick(delay, func(time.Time) tea.Msg {
+			return reloadTickMsg{token: token}
+		})
+	}
+	return m.loadResultsCmd(token)
+}
+
+func (m *model) requestPreview() tea.Cmd {
+	row, ok := m.currentSelection()
+	if !ok || m.db == nil {
+		m.previewKey = ""
+		m.previewMessages = nil
+		m.previewErr = nil
+		m.previewLoading = false
+		return nil
+	}
+	if m.previewKey == row.SessionKey && m.previewAllRoles == m.allRoles && !m.previewLoading && m.previewErr == nil && len(m.previewMessages) > 0 {
+		return nil
+	}
+
+	m.previewToken++
+	token := m.previewToken
+	sessionKey := row.SessionKey
+	allRoles := m.allRoles
+	db := m.db
+
+	m.previewKey = sessionKey
+	m.previewAllRoles = allRoles
+	m.previewMessages = nil
+	m.previewErr = nil
+	m.previewLoading = true
+
+	return func() tea.Msg {
+		messages, err := loadTranscriptPreviewMessages(db, sessionKey, allRoles, 8)
+		return previewLoadedMsg{
+			token:      token,
+			sessionKey: sessionKey,
+			allRoles:   allRoles,
+			messages:   messages,
+			err:        err,
+		}
+	}
+}
+
+func (m *model) applyPreview(msg previewLoadedMsg) {
+	if msg.token != m.previewToken || msg.sessionKey != m.previewKey || msg.allRoles != m.previewAllRoles {
+		return
+	}
+	m.previewLoading = false
+	m.previewMessages = msg.messages
+	m.previewErr = msg.err
+}
+
+func (m *model) loadResultsCmd(token int) tea.Cmd {
+	ctx, cancel := context.WithCancel(context.Background())
+	m.cancelReload = cancel
+
 	query := strings.TrimSpace(m.search.Value())
 	providers := selectedSetValues(m.providers)
 	models := selectedSetValues(m.modelFilters)
 	repos := selectedSetValues(m.repoFilters)
-	if query == "" {
-		rows, err = listSessions(m.db, providers, models, repos)
-	} else {
-		rows, err = searchMessages(m.db, query, providers, models, repos, m.allRoles)
+	allRoles := m.allRoles
+	db := m.db
+
+	return func() tea.Msg {
+		var rows []item
+		var truncated bool
+		var err error
+		if query == "" {
+			rows, err = listSessionsContext(ctx, db, providers, models, repos)
+		} else {
+			rows, truncated, err = searchMessagesTUIContext(ctx, db, query, providers, models, repos, allRoles, tuiSearchLimit)
+		}
+		return resultsLoadedMsg{
+			token:     token,
+			query:     query,
+			rows:      rows,
+			truncated: truncated,
+			err:       err,
+		}
 	}
-	if err != nil {
-		m.err = err
+}
+
+func (m *model) applyResults(msg resultsLoadedMsg) tea.Cmd {
+	if msg.token != m.reloadToken {
+		return nil
+	}
+	m.loading = false
+	m.searchTooShort = msg.tooShort
+	m.resultsTruncated = msg.truncated
+	m.cancelReload = nil
+	if msg.err != nil {
+		if errors.Is(msg.err, context.Canceled) {
+			return nil
+		}
+		m.err = msg.err
 		m.results = nil
-		return
+		m.resultsVersion++
+		return nil
 	}
-	m.results = rows
+	m.err = nil
+	m.results = msg.rows
 	if m.selected >= len(m.results) {
 		m.selected = max(0, len(m.results)-1)
 	}
+	m.resultsVersion++
+	m.previewKey = ""
 	m.configureResultsTable(max(72, m.width), max(4, m.height/2))
+	return m.requestPreview()
 }
 
 func (m *model) resetPosition() {
@@ -1765,6 +1964,17 @@ func (m *model) resetPosition() {
 	m.detail = false
 }
 
+func isPrintableSearchKey(msg tea.KeyMsg) bool {
+	if msg.Type != tea.KeyRunes {
+		return false
+	}
+	return len(msg.Runes) > 0
+}
+
+func runeCount(value string) int {
+	return len([]rune(strings.TrimSpace(value)))
+}
+
 func (m *model) detailHeight() int {
 	return max(1, m.height-5)
 }
@@ -1859,6 +2069,10 @@ func loadModelOptions(db *sql.DB) ([]filterOption, error) {
 }
 
 func listSessions(db *sql.DB, providers []string, models []string, repos []string) ([]item, error) {
+	return listSessionsContext(context.Background(), db, providers, models, repos)
+}
+
+func listSessionsContext(ctx context.Context, db *sql.DB, providers []string, models []string, repos []string) ([]item, error) {
 	filters, args := sessionFilters("s", providers, models, repos)
 	filters = append(filters, rootSessionFilter("s"))
 	filters = append(filters, displayableSessionFilter("s"))
@@ -1866,7 +2080,7 @@ func listSessions(db *sql.DB, providers []string, models []string, repos []strin
 	if len(filters) > 0 {
 		where = "WHERE " + strings.Join(filters, " AND ")
 	}
-	rows, err := db.Query(`
+	rows, err := db.QueryContext(ctx, `
 		SELECT s.session_key, s.provider, `+displayTitleExpr("s")+`,
 		       COALESCE(s.started_at, ''),
 		       COALESCE(s.updated_at, s.started_at, ''),
@@ -1899,14 +2113,28 @@ func listSessions(db *sql.DB, providers []string, models []string, repos []strin
 }
 
 func searchMessages(db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool) ([]item, error) {
-	rows, err := searchMessagesFTS(db, query, providers, models, repos, allRoles)
+	rows, _, err := searchMessagesContext(context.Background(), db, query, providers, models, repos, allRoles, 0)
+	return rows, err
+}
+
+func searchMessagesContext(ctx context.Context, db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool, limit int) ([]item, bool, error) {
+	rows, truncated, err := searchMessagesFTS(ctx, db, query, providers, models, repos, allRoles, limit)
+	if err == nil {
+		return rows, truncated, nil
+	}
+	return searchMessagesLike(ctx, db, query, providers, models, repos, allRoles, limit)
+}
+
+func searchMessagesTUIContext(ctx context.Context, db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool, limit int) ([]item, bool, error) {
+	rows, truncated, err := searchMessagesFTSFast(ctx, db, query, providers, models, repos, allRoles, limit)
 	if err == nil {
-		return rows, nil
+		return rows, truncated, nil
 	}
-	return searchMessagesLike(db, query, providers, models, repos, allRoles)
+	return searchMessagesLikeFast(ctx, db, query, providers, models, repos, allRoles, limit)
 }
 
-func searchMessagesFTS(db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool) ([]item, error) {
+func searchMessagesFTSFast(ctx context.Context, db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool, limit int) ([]item, bool, error) {
+	scanLimit := max(limit*6, limit)
 	args := []any{toFTSQuery(query)}
 	filters := messageFilters("m", providers, models, repos, allRoles, &args)
 	filters = append(filters, rootSessionFilter("s"))
@@ -1915,7 +2143,110 @@ func searchMessagesFTS(db *sql.DB, query string, providers []string, models []st
 	if len(filters) > 0 {
 		where += " AND " + strings.Join(filters, " AND ")
 	}
-	rows, err := db.Query(`
+	if scanLimit > 0 {
+		args = append(args, scanLimit)
+	}
+	limitSQL := ""
+	if scanLimit > 0 {
+		limitSQL = " LIMIT ?"
+	}
+	rows, err := db.QueryContext(ctx, `
+		SELECT m.session_key, m.provider, `+displayTitleExpr("s")+`,
+		       COALESCE(m.timestamp, s.updated_at, s.started_at, ''),
+		       COALESCE(s.started_at, ''),
+		       COALESCE(s.updated_at, s.started_at, ''),
+		       COALESCE(s.cwd, ''), COALESCE(s.message_count, 0),
+		       COALESCE((SELECT GROUP_CONCAT(model) FROM (
+		           SELECT DISTINCT sm.model FROM session_models sm
+		           WHERE sm.session_key = m.session_key
+		           ORDER BY sm.model
+		       )), ''),
+		       COALESCE(snippet(message_fts, 0, '[', ']', '...', 18), m.text),
+		       m.ordinal
+		FROM message_fts
+		JOIN messages m ON m.message_key = message_fts.message_key
+		JOIN sessions s ON s.session_key = m.session_key
+		WHERE `+where+limitSQL+`
+	`, args...)
+	if err != nil {
+		return nil, false, err
+	}
+	defer rows.Close()
+	items, err := scanItems(rows, true)
+	if err != nil {
+		return nil, false, err
+	}
+	return finalizeTUIItems(items, limit, scanLimit)
+}
+
+func searchMessagesLikeFast(ctx context.Context, db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool, limit int) ([]item, bool, error) {
+	scanLimit := max(limit*6, limit)
+	args := []any{"%" + query + "%"}
+	filters := []string{"m.text LIKE ?"}
+	filters = append(filters, messageFilters("m", providers, models, repos, allRoles, &args)...)
+	filters = append(filters, rootSessionFilter("s"))
+	filters = append(filters, displayableSessionFilter("s"))
+	if scanLimit > 0 {
+		args = append(args, scanLimit)
+	}
+	limitSQL := ""
+	if scanLimit > 0 {
+		limitSQL = " LIMIT ?"
+	}
+
+	rows, err := db.QueryContext(ctx, `
+		SELECT m.session_key, m.provider, `+displayTitleExpr("s")+`,
+		       COALESCE(m.timestamp, s.updated_at, s.started_at, ''),
+		       COALESCE(s.started_at, ''),
+		       COALESCE(s.updated_at, s.started_at, ''),
+		       COALESCE(s.cwd, ''), COALESCE(s.message_count, 0),
+		       COALESCE((SELECT GROUP_CONCAT(model) FROM (
+		           SELECT DISTINCT sm.model FROM session_models sm
+		           WHERE sm.session_key = m.session_key
+		           ORDER BY sm.model
+		       )), ''),
+		       m.text,
+		       m.ordinal
+		FROM messages m
+		JOIN sessions s ON s.session_key = m.session_key
+		WHERE `+strings.Join(filters, " AND ")+limitSQL+`
+	`, args...)
+	if err != nil {
+		return nil, false, err
+	}
+	defer rows.Close()
+	items, err := scanItems(rows, true)
+	if err != nil {
+		return nil, false, err
+	}
+	return finalizeTUIItems(items, limit, scanLimit)
+}
+
+func finalizeTUIItems(items []item, limit int, scanLimit int) ([]item, bool, error) {
+	deduped := dedupeItems(items)
+	sortItemsByRecency(deduped)
+	rows, truncated, err := limitItems(deduped, limit)
+	if err != nil {
+		return nil, false, err
+	}
+	return rows, truncated || (scanLimit > 0 && len(items) >= scanLimit), nil
+}
+
+func searchMessagesFTS(ctx context.Context, db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool, limit int) ([]item, bool, error) {
+	args := []any{toFTSQuery(query)}
+	filters := messageFilters("m", providers, models, repos, allRoles, &args)
+	filters = append(filters, rootSessionFilter("s"))
+	filters = append(filters, displayableSessionFilter("s"))
+	where := "message_fts MATCH ?"
+	if len(filters) > 0 {
+		where += " AND " + strings.Join(filters, " AND ")
+	}
+	limitSQL := ""
+	if limit > 0 {
+		limitSQL = " LIMIT ?"
+		args = append(args, limit*6)
+	}
+	rows, err := db.QueryContext(ctx, `
 		SELECT m.session_key, m.provider, `+displayTitleExpr("s")+`,
 		       COALESCE(m.timestamp, s.updated_at, s.started_at, ''),
 		       COALESCE(s.started_at, ''),
@@ -1933,26 +2264,33 @@ func searchMessagesFTS(db *sql.DB, query string, providers []string, models []st
 		JOIN sessions s ON s.session_key = m.session_key
 		WHERE `+where+`
 		ORDER BY bm25(message_fts), COALESCE(m.timestamp, s.updated_at) DESC
+		`+limitSQL+`
 	`, args...)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 	defer rows.Close()
 	items, err := scanItems(rows, true)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
-	return dedupeItems(items), nil
+	deduped := dedupeItems(items)
+	return limitItems(deduped, limit)
 }
 
-func searchMessagesLike(db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool) ([]item, error) {
+func searchMessagesLike(ctx context.Context, db *sql.DB, query string, providers []string, models []string, repos []string, allRoles bool, limit int) ([]item, bool, error) {
 	args := []any{"%" + query + "%"}
 	filters := []string{"m.text LIKE ?"}
 	filters = append(filters, messageFilters("m", providers, models, repos, allRoles, &args)...)
 	filters = append(filters, rootSessionFilter("s"))
 	filters = append(filters, displayableSessionFilter("s"))
+	limitSQL := ""
+	if limit > 0 {
+		limitSQL = " LIMIT ?"
+		args = append(args, limit*6)
+	}
 
-	rows, err := db.Query(`
+	rows, err := db.QueryContext(ctx, `
 		SELECT m.session_key, m.provider, `+displayTitleExpr("s")+`,
 		       COALESCE(m.timestamp, s.updated_at, s.started_at, ''),
 		       COALESCE(s.started_at, ''),
@@ -1969,16 +2307,18 @@ func searchMessagesLike(db *sql.DB, query string, providers []string, models []s
 		JOIN sessions s ON s.session_key = m.session_key
 		WHERE `+strings.Join(filters, " AND ")+`
 		ORDER BY COALESCE(m.timestamp, s.updated_at) DESC
+		`+limitSQL+`
 	`, args...)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
 	defer rows.Close()
 	items, err := scanItems(rows, true)
 	if err != nil {
-		return nil, err
+		return nil, false, err
 	}
-	return dedupeItems(items), nil
+	deduped := dedupeItems(items)
+	return limitItems(deduped, limit)
 }
 
 func scanItems(rows *sql.Rows, isMatch bool) ([]item, error) {
@@ -2012,6 +2352,27 @@ func dedupeItems(items []item) []item {
 	return deduped
 }
 
+func sortItemsByRecency(items []item) {
+	sort.SliceStable(items, func(i int, j int) bool {
+		left := items[i].UpdatedAt
+		if left == "" {
+			left = items[i].Timestamp
+		}
+		right := items[j].UpdatedAt
+		if right == "" {
+			right = items[j].Timestamp
+		}
+		return left > right
+	})
+}
+
+func limitItems(items []item, limit int) ([]item, bool, error) {
+	if limit <= 0 || len(items) <= limit {
+		return items, false, nil
+	}
+	return items[:limit], true, nil
+}
+
 func loadTranscript(db *sql.DB, sessionKey string, allRoles bool, width int) (string, error) {
 	messages, err := loadTranscriptMessages(db, sessionKey, allRoles)
 	if err != nil {

{gora_cli-0.1.2 → gora_cli-0.1.4}/gora/go_tui/main_test.go

@@ -559,6 +559,44 @@ func TestExportShortcutsDoNotStealSearchTyping(t *testing.T) {
 	}
 }
 
+func TestShortSearchDoesNotTouchDatabase(t *testing.T) {
+	search := textinput.New()
+	search.SetValue("l")
+	m := &model{search: search}
+
+	cmd := m.requestReload(0)
+	raw := cmd()
+	msg, ok := raw.(resultsLoadedMsg)
+	if !ok {
+		t.Fatalf("message = %T, want resultsLoadedMsg", raw)
+	}
+	if !msg.tooShort {
+		t.Fatalf("tooShort = false, want true: %#v", msg)
+	}
+
+	m.applyResults(msg)
+	if !m.searchTooShort {
+		t.Fatal("model did not mark short search")
+	}
+	if m.loading {
+		t.Fatal("model stayed loading after short search")
+	}
+}
+
+func TestPrintableTypingStartsSearchFromResultsFocus(t *testing.T) {
+	search := textinput.New()
+	m := &model{search: search, focus: focusResults}
+
+	_ = m.handleKey(tea.KeyMsg{Type: tea.KeyRunes, Runes: []rune{'l'}})
+
+	if m.focus != focusSearch {
+		t.Fatalf("focus = %v, want search", m.focus)
+	}
+	if m.search.Value() != "l" {
+		t.Fatalf("search value = %q, want l", m.search.Value())
+	}
+}
+
 func TestDedupeItemsDoesNotCapResults(t *testing.T) {
 	items := make([]item, 0, 300)
 	for index := range 300 {

{gora_cli-0.1.2 → gora_cli-0.1.4}/gora/tui.py

@@ -6,7 +6,7 @@ import shutil
 import subprocess
 import sys
 
-TUI_CACHE_VERSION = "bubbletea-v1"
+TUI_CACHE_VERSION = "bubbletea-v3"
 
 
 def run_tui(db_path: Path | None) -> int:
@@ -24,12 +24,13 @@ def run_tui(db_path: Path | None) -> int:
         command.extend(["--db", str(db_path)])
 
     try:
-        return subprocess.run(command, cwd=cwd).returncode
-    except KeyboardInterrupt:
-        return 130
+        if cwd is not None:
+            os.chdir(cwd)
+        os.execvpe(command[0], command, os.environ.copy())
     except OSError as exc:
         print(f"failed to launch Bubble Tea TUI: {exc}", file=sys.stderr)
         return 1
+    return 1
 
 
 def _tui_command() -> tuple[list[str] | None, Path | None]:
@@ -95,6 +96,8 @@ def _build_tui(source_dir: Path, target: Path) -> bool:
     target.parent.mkdir(parents=True, exist_ok=True)
     tmp = target.with_suffix(".tmp")
     try:
+        if sys.stderr.isatty():
+            print("Building Gora TUI helper...", file=sys.stderr)
         result = subprocess.run(
             ["go", "build", "-o", str(tmp), "."],
             cwd=source_dir,

{gora_cli-0.1.2 → gora_cli-0.1.4}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "gora-cli"
-version = "0.1.2"
+version = "0.1.4"
 description = "Local CLI chat history index for Codex, Claude Code, and Pi."
 readme = "README.md"
 requires-python = ">=3.13"

{gora_cli-0.1.2 → gora_cli-0.1.4}/uv.lock

@@ -4,5 +4,5 @@ requires-python = ">=3.13"
 
 [[package]]
 name = "gora-cli"
-version = "0.1.2"
+version = "0.1.4"
 source = { editable = "." }