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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: gora-cli
-Version: 0.1.3
+Version: 0.1.4
 Summary: Local CLI chat history index for Codex, Claude Code, and Pi.
 Classifier: Environment :: Console
 Classifier: Intended Audience :: Developers

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

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

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

@@ -69,6 +69,14 @@ type resultsLoadedMsg struct {
 	err       error
 }
 
+type previewLoadedMsg struct {
+	token      int
+	sessionKey string
+	allRoles   bool
+	messages   []transcriptMessage
+	err        error
+}
+
 type item struct {
 	SessionKey   string
 	Provider     string
@@ -375,10 +383,11 @@ type model struct {
 	focus             focusArea
 	filterSection     filterSection
 	previewKey        string
-	previewWidth      int
 	previewAllRoles   bool
-	previewLines      []string
+	previewLoading    bool
+	previewMessages   []transcriptMessage
 	previewErr        error
+	previewToken      int
 	selected          int
 	width             int
 	height            int
@@ -400,6 +409,7 @@ type model struct {
 	tableRowsWidth    int
 	tableRowsHeight   int
 	tableRowsSelected int
+	tableRows         []table.Row
 	notice            string
 	err               error
 }
@@ -421,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"
@@ -490,7 +502,9 @@ func (m *model) Update(msg tea.Msg) (tea.Model, tea.Cmd) {
 		}
 		return m, m.loadResultsCmd(msg.token)
 	case resultsLoadedMsg:
-		m.applyResults(msg)
+		return m, m.applyResults(msg)
+	case previewLoadedMsg:
+		m.applyPreview(msg)
 	}
 	return m, nil
 }
@@ -544,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()
@@ -574,6 +588,9 @@ func (m *model) handleKey(msg tea.KeyMsg) tea.Cmd {
 		return m.requestReload(0)
 	default:
 		if m.focus != focusSearch {
+			if key == "q" {
+				return tea.Quit
+			}
 			if key == "m" {
 				m.exportSelected("md")
 				return nil
@@ -613,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
@@ -953,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 {
@@ -1023,14 +1027,18 @@ func (m *model) configureResultsTable(width int, height int) {
 	height = max(4, height)
 	if m.tableRowsVersion != m.resultsVersion ||
 		m.tableRowsWidth != width ||
-		m.tableRowsHeight != height ||
-		m.tableRowsSelected != m.selected {
+		m.tableRowsHeight != height {
 		m.resultsTable.SetColumns(resultTableColumns(width))
-		m.resultsTable.SetRows(resultTableRows(m.results, m.selected))
+		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(height)
@@ -1044,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
@@ -1437,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() {
@@ -1831,6 +1854,52 @@ func (m *model) requestReload(delay time.Duration) tea.Cmd {
 	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
@@ -1849,7 +1918,7 @@ func (m *model) loadResultsCmd(token int) tea.Cmd {
 		if query == "" {
 			rows, err = listSessionsContext(ctx, db, providers, models, repos)
 		} else {
-			rows, truncated, err = searchMessagesContext(ctx, db, query, providers, models, repos, allRoles, tuiSearchLimit)
+			rows, truncated, err = searchMessagesTUIContext(ctx, db, query, providers, models, repos, allRoles, tuiSearchLimit)
 		}
 		return resultsLoadedMsg{
 			token:     token,
@@ -1861,9 +1930,9 @@ func (m *model) loadResultsCmd(token int) tea.Cmd {
 	}
 }
 
-func (m *model) applyResults(msg resultsLoadedMsg) {
+func (m *model) applyResults(msg resultsLoadedMsg) tea.Cmd {
 	if msg.token != m.reloadToken {
-		return
+		return nil
 	}
 	m.loading = false
 	m.searchTooShort = msg.tooShort
@@ -1871,12 +1940,12 @@ func (m *model) applyResults(msg resultsLoadedMsg) {
 	m.cancelReload = nil
 	if msg.err != nil {
 		if errors.Is(msg.err, context.Canceled) {
-			return
+			return nil
 		}
 		m.err = msg.err
 		m.results = nil
 		m.resultsVersion++
-		return
+		return nil
 	}
 	m.err = nil
 	m.results = msg.rows
@@ -1886,6 +1955,7 @@ func (m *model) applyResults(msg resultsLoadedMsg) {
 	m.resultsVersion++
 	m.previewKey = ""
 	m.configureResultsTable(max(72, m.width), max(4, m.height/2))
+	return m.requestPreview()
 }
 
 func (m *model) resetPosition() {
@@ -2055,6 +2125,113 @@ func searchMessagesContext(ctx context.Context, db *sql.DB, query string, provid
 	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, truncated, nil
+	}
+	return searchMessagesLikeFast(ctx, db, query, providers, models, repos, allRoles, limit)
+}
+
+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"))
+	filters = append(filters, displayableSessionFilter("s"))
+	where := "message_fts MATCH ?"
+	if len(filters) > 0 {
+		where += " AND " + strings.Join(filters, " AND ")
+	}
+	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)
@@ -2175,6 +2352,20 @@ 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

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

@@ -6,7 +6,7 @@ import shutil
 import subprocess
 import sys
 
-TUI_CACHE_VERSION = "bubbletea-v2"
+TUI_CACHE_VERSION = "bubbletea-v3"
 
 
 def run_tui(db_path: Path | None) -> int:

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

@@ -1,6 +1,6 @@
 [project]
 name = "gora-cli"
-version = "0.1.3"
+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.3 → gora_cli-0.1.4}/uv.lock

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