opencode-sesh 0.1.5 → 0.1.6

package/AGENTS.md

@@ -108,6 +108,11 @@ Resume happens in place (`exec` after `cd` to the session's cwd).
   `api.route.navigate("session", …)`. `ctrl+o` and the command palette open it;
   Ctrl-X deletes via the opencode CLI and removes the row only after the server
   confirms the deletion.
+- **Picker search:** pages the global session list (`SESSION_PAGE_LIMIT`, capped
+  at `SESSION_MAX` and reported when truncated) instead of a fixed 500-row
+  window, then indexes transcript text for **every** session in batches
+  (`TRANSCRIPT_BATCH`) with bounded remote concurrency (`REMOTE_CONCURRENCY`).
+  The header shows indexing progress/coverage. `tests/tui.mjs` locks this.
 
 ### Hard-won rules — do not regress
 

package/CHANGELOG.md

@@ -7,6 +7,23 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.1.6] - 2026-09-13
+
+### Changed
+
+- The TUI picker pages through the entire global session list instead of a
+  fixed 500-session window, indexes transcript text for every session (not just
+  the newest 150) in batches, bounds remote transcript fetching, and shows
+  indexing progress/coverage in the search header.
+- Transcript extraction reads parts in batches and assembles all records in a
+  single `jq` pass. A 250-session cold index dropped from about 28 s to about
+  7 s locally (warm ~0.3 s).
+
+### Added
+
+- TUI data-layer contract tests (pagination, full index coverage, bounded
+  concurrency, progress, and the truncated cap), run on Node 24 in CI.
+
 ## [0.1.5] - 2026-09-13
 
 ### Fixed
@@ -102,7 +119,8 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 - Fixture-database regression suite, TypeScript typechecking, and ShellCheck in
   CI.
 
-[Unreleased]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.5...HEAD
+[Unreleased]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.6...HEAD
+[0.1.6]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.5...v0.1.6
 [0.1.5]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.4...v0.1.5
 [0.1.4]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.3...v0.1.4
 [0.1.3]: https://github.com/ozandogrultan/opencode-sesh/compare/v0.1.2...v0.1.3

package/README.md

@@ -137,6 +137,11 @@ read -r id cwd < <(sesh --print --query "auth")
 Click the sidebar's `search…` box to filter recent sessions in place; click
 elsewhere or press Esc to leave search.
 
+The full picker pages through your whole global session list (no fixed window)
+and indexes transcript text for every session in the background, showing
+indexing progress under the search box. It only stops at a safety cap of 5,000
+sessions, and says so when it does.
+
 ## Configuration
 
 All variables are optional.

package/bin/sesh-list.sh

@@ -260,53 +260,71 @@ refresh() {
   "$JQ_BIN" -c '.stale[]?' "$cache_state" > "$needs_extract"
   while IFS= read -r cache; do [ -n "$cache" ] && rm -f "$cache"; done < <("$JQ_BIN" -r '.prune[]?' "$cache_state")
 
-  local sid dir title created updated partCount partMax raw_file text_file record cache
-  local extract_failed=0
+  local stale_ids=() sid chunk j i
   while IFS= read -r row; do
     [ -n "$row" ] || continue
     sid=$(printf '%s' "$row" | "$JQ_BIN" -r '.id')
     valid_session_id "$sid" || continue
-    dir=$(printf '%s' "$row" | "$JQ_BIN" -r '.directory // ""')
-    title=$(printf '%s' "$row" | "$JQ_BIN" -r '.title // ""')
-    created=$(printf '%s' "$row" | "$JQ_BIN" -r '.time_created // 0')
-    updated=$(printf '%s' "$row" | "$JQ_BIN" -r '.time_updated // 0')
-    partCount=$(printf '%s' "$row" | "$JQ_BIN" -r '.partCount // 0')
-    partMax=$(printf '%s' "$row" | "$JQ_BIN" -r '.partMax // 0')
-    cache="$EXTRACTIONS/$sid.json"
-    raw_file="$scratch/$sid.parts.json"
-    text_file="$scratch/$sid.text"
-    # Text parts only: reasoning blobs and tool payloads would bloat the search
-    # index. The transcript travels through files, never argv, so a large
-    # conversation cannot hit ARG_MAX; a failure leaves the session uncached so
-    # the next refresh retries instead of certifying it fresh.
-    if db_json "SELECT data FROM part WHERE session_id = '$sid' AND json_extract(data, '\$.type') = 'text' ORDER BY time_created;" > "$raw_file" 2>/dev/null \
-      && "$JQ_BIN" -r '[.[]? | (.data? // empty) | (try fromjson catch empty) | select(type == "object" and .type == "text") | .text // empty] | join(" ")' "$raw_file" > "$text_file" 2>/dev/null; then
-      :
-    else
+    stale_ids+=("$sid")
+  done < "$needs_extract"
+
+  # Batch the transcript read: one SQL query per chunk of sessions and a single
+  # jq pass to assemble every record, instead of a query plus three jq processes
+  # per session. Text still travels through files, never argv. Any failure leaves
+  # every stale session uncached, so the next refresh retries them.
+  local extract_failed=0 parts_raw="$scratch/parts.jsonl" records="$scratch/records.jsonl"
+  : > "$parts_raw"
+  j=0
+  while [ "$j" -lt "${#stale_ids[@]}" ]; do
+    chunk=''
+    for ((i = j; i < j + 200 && i < ${#stale_ids[@]}; i++)); do
+      chunk="${chunk:+$chunk,}'${stale_ids[$i]}'"
+    done
+    if ! db_json "SELECT session_id, data FROM part WHERE session_id IN ($chunk) AND json_extract(data, '\$.type') = 'text' ORDER BY session_id, time_created;" 2>/dev/null \
+      | "$JQ_BIN" -c '.[]?' >> "$parts_raw"; then
       extract_failed=1
-      continue
-    fi
-    if [ -z "$title" ]; then
-      title=$("$JQ_BIN" -Rrs 'gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end | select(length > 0) // "(untitled)"' "$text_file" 2>/dev/null) || title='(untitled)'
-      [ -n "$title" ] || title='(untitled)'
+      break
     fi
-    record=$("$JQ_BIN" -cn --arg sid "$sid" --arg cwd "$dir" --arg title "$title" \
-      --argjson created "$created" --argjson updated "$updated" --argjson parts "$partCount" --argjson maxpart "$partMax" \
-      --rawfile text "$text_file" '
-      {cacheSchema: 2, cacheSession: $sid, cacheUpdated: $updated, cacheParts: $parts, cacheMax: $maxpart,
-       sessionId: $sid, transcriptPath: "", source: "opencode",
-       cwd: $cwd, title: ($title | gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end),
-       updatedEpoch: (($updated / 1000 | floor) | if . > 0 then . else ($created / 1000 | floor) end),
-       fulltextLower: (($title + " " + $text) | sub("\n$"; "") | ascii_downcase)}') || record=''
-    if [ -n "$record" ]; then
+    j=$((j + 200))
+  done
+
+  if [ "$extract_failed" = 0 ]; then
+    "$JQ_BIN" -cnr --arg extractions "$EXTRACTIONS" --slurpfile stale "$needs_extract" --slurpfile parts "$parts_raw" '
+      ($parts
+       | map({sid: .session_id,
+              text: ((.data | try fromjson catch null)
+                     | if type == "object" and .type == "text" and (.text | type) == "string" then .text else empty end)})
+       | group_by(.sid)
+       | map({key: .[0].sid, value: ([.[].text] | join(" "))})
+       | from_entries) as $bySid
+      | $stale[]
+      | select((.id | type) == "string" and (.id | test("^ses_[A-Za-z0-9]+$")))
+      | . as $s
+      | ($bySid[$s.id] // "") as $text
+      | (if ($s.title // "") == ""
+         then (($text | gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end) | select(length > 0) // "(untitled)")
+         else $s.title end) as $title
+      | {sessionId: $s.id,
+         cachePath: ($extractions + "/" + $s.id + ".json"),
+         record: {cacheSchema: 2, cacheSession: $s.id,
+                  cacheUpdated: ($s.time_updated // 0), cacheParts: ($s.partCount // 0), cacheMax: ($s.partMax // 0),
+                  sessionId: $s.id, transcriptPath: "", source: "opencode",
+                  cwd: ($s.directory // ""),
+                  title: ($title | gsub("[\r\n]+"; " ") | if length > 70 then .[0:67] + "..." else . end),
+                  updatedEpoch: ((($s.time_updated // 0) / 1000 | floor) | if . > 0 then . else ((($s.time_created // 0) / 1000) | floor) end),
+                  fulltextLower: (($title + " " + $text) | ascii_downcase)}}
+      | "\(.sessionId)\n\(.cachePath)\n\(.record | tojson)"' > "$records" || extract_failed=1
+  fi
+
+  if [ "$extract_failed" = 0 ]; then
+    while IFS= read -r sid && IFS= read -r cache_path && IFS= read -r record; do
+      [ -n "$sid" ] || continue
       cache_tmp=$(mktemp "$EXTRACTIONS/$sid.json.XXXXXX")
       printf '%s\n' "$record" > "$cache_tmp"
-      mv "$cache_tmp" "$cache"
+      mv "$cache_tmp" "$cache_path"
       printf '%s\n' "$record" >> "$historical"
-    else
-      extract_failed=1
-    fi
-  done < "$needs_extract"
+    done < "$records"
+  fi
 
   if ! "$JQ_BIN" -c --slurpfile hist "$historical" --arg scope "$SCOPE_CWD" --argjson limit "$LIMIT" --argjson archived "$INCLUDE_ARCHIVED" '
     .meta as $meta

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-sesh",
-  "version": "0.1.5",
+  "version": "0.1.6",
   "type": "module",
   "description": "Browse, search, preview and resume opencode sessions from the terminal and the TUI.",
   "license": "MIT",

package/tui/sesh-panel.tsx

@@ -159,20 +159,47 @@ function ensureRootMouse(renderer: TuiPluginApi["renderer"]) {
 }
 
 type Entry = { id: string; title: string; dir: string; group: string; updated: number }
+type EntryResult = { entries: Entry[]; truncated: boolean }
 
-async function fetchEntries(api: TuiPluginApi): Promise<Entry[]> {
+const SESSION_PAGE_LIMIT = 200
+const SESSION_MAX = 5000
+
+async function fetchEntries(api: TuiPluginApi): Promise<EntryResult> {
   const home = process.env.HOME ?? ""
-  const [sessionResult, projectResult] = await Promise.all([
-    api.client.experimental.session.list({ limit: 500, roots: true, directory: "" }),
-    api.client.project.list({}),
-  ])
-  const sessions = ((sessionResult?.data ?? sessionResult) as Session[]) ?? []
+  const projectResult = await api.client.project.list({})
   const projects = ((projectResult?.data ?? projectResult) as Project[]) ?? []
-  if (!Array.isArray(sessions)) return []
   const projectName = new Map<string, string>(
     projects.map((p) => [p.id, p.name?.trim() || shortDir(p.worktree ?? "", home)]),
   )
-  return sessions
+  const sessions: Session[] = []
+  let cursor: number | undefined
+  let truncated = false
+  // Page through the global list instead of one fixed window, so sessions in
+  // older directories stay searchable. `cursor` is the previous page's oldest
+  // `time.updated`; a repeated or missing cursor stops the walk.
+  for (;;) {
+    const result = await api.client.experimental.session.list({
+      limit: SESSION_PAGE_LIMIT,
+      roots: true,
+      directory: "",
+      ...(cursor === undefined ? {} : { cursor }),
+    })
+    const page = ((result?.data ?? result) as Session[]) ?? []
+    if (!Array.isArray(page) || page.length === 0) break
+    sessions.push(...page)
+    if (page.length < SESSION_PAGE_LIMIT) break
+    if (sessions.length >= SESSION_MAX) {
+      truncated = true
+      break
+    }
+    const next = page[page.length - 1]?.time?.updated
+    if (typeof next !== "number" || next === cursor) {
+      truncated = true
+      break
+    }
+    cursor = next
+  }
+  const entries = sessions
     .filter((s) => !s.time?.archived && !s.parentID)
     .sort((a, b) => b.time.updated - a.time.updated)
     .map((s) => {
@@ -187,76 +214,118 @@ async function fetchEntries(api: TuiPluginApi): Promise<Entry[]> {
         updated: s.time.updated,
       }
     })
+  return { entries, truncated }
 }
 
-const TRANSCRIPT_INDEX_LIMIT = 150
 const SESSION_ID_PATTERN = /^ses_[A-Za-z0-9]+$/
+const TRANSCRIPT_BATCH = 64
+const REMOTE_CONCURRENCY = 8
 
-async function buildSearchIndex(api: TuiPluginApi, entries: Entry[]): Promise<Map<string, string>> {
-  const index = new Map<string, string>()
-  const targets = entries.slice(0, TRANSCRIPT_INDEX_LIMIT)
-  for (const entry of targets) {
-    index.set(entry.id, `${entry.title.toLowerCase()} ${entry.dir.toLowerCase()}`)
-  }
-  const ids = targets.map((entry) => entry.id).filter((id) => SESSION_ID_PATTERN.test(id))
-  if (ids.length === 0) return index
+type IndexProgress = { indexed: number; total: number; complete: boolean }
+
+const nextTick = () => new Promise<void>((resolve) => setTimeout(resolve, 0))
+
+async function openTranscriptDb(): Promise<any | undefined> {
   try {
     const home = process.env.HOME ?? ""
     const dataHome = process.env.XDG_DATA_HOME ?? `${home}/.local/share`
     // @ts-ignore - bun:sqlite ships with the Bun runtime (verified); no type package installed
     const sqlite: any = await import("bun:sqlite")
-    if (typeof sqlite?.Database !== "function") throw new Error("bun:sqlite unavailable")
-    const db = new sqlite.Database(`${dataHome}/opencode/opencode.db`, { readonly: true })
+    if (typeof sqlite?.Database !== "function") return undefined
+    return new sqlite.Database(`${dataHome}/opencode/opencode.db`, { readonly: true })
+  } catch {
+    return undefined
+  }
+}
+
+function addTranscript(index: Map<string, string>, sid: string, data: string): void {
+  try {
+    const part = JSON.parse(data) as { type?: unknown; text?: unknown }
+    if (part?.type !== "text" || typeof part.text !== "string") return
+    const base = index.get(sid) ?? ""
+    index.set(sid, `${base} ${part.text.toLowerCase()}`.trim())
+  } catch {
+    // ignore malformed parts
+  }
+}
+
+// Index titles/directories immediately, then add transcript text progressively
+// in batches so the render thread can breathe. Covers every entry, not a fixed
+// newest window; `onProgress` lets the picker show coverage.
+async function buildSearchIndex(
+  api: TuiPluginApi,
+  entries: Entry[],
+  onProgress?: (progress: IndexProgress) => void,
+): Promise<Map<string, string>> {
+  const index = new Map<string, string>()
+  for (const entry of entries) {
+    index.set(entry.id, `${entry.title.toLowerCase()} ${entry.dir.toLowerCase()}`)
+  }
+  const ids = entries.map((entry) => entry.id).filter((id) => SESSION_ID_PATTERN.test(id))
+  const remaining = new Set(ids)
+  const total = ids.length
+  let indexed = 0
+  const report = (complete: boolean) => onProgress?.({ indexed, total, complete })
+  report(false)
+
+  const db = await openTranscriptDb()
+  if (db) {
     try {
-      const placeholders = ids.map(() => "?").join(",")
-      const rows = (db
-        .query(
-          `SELECT session_id AS sid, data FROM part WHERE session_id IN (${placeholders}) AND json_extract(data, '$.type') = 'text' ORDER BY time_created`,
-        )
-        .all(...ids) ?? []) as { sid: string; data: string }[]
-      const byId = new Map<string, string[]>()
-      for (const row of rows) {
-        try {
-          const part = JSON.parse(row.data) as { type?: unknown; text?: unknown }
-          if (part?.type === "text" && typeof part.text === "string") {
-            const list = byId.get(row.sid) ?? []
-            list.push(part.text)
-            byId.set(row.sid, list)
-          }
-        } catch {}
-      }
-      for (const entry of targets) {
-        const text = (byId.get(entry.id) ?? []).join(" ").toLowerCase()
-        if (text) index.set(entry.id, `${index.get(entry.id)} ${text}`)
+      for (let i = 0; i < ids.length; i += TRANSCRIPT_BATCH) {
+        const batch = ids.slice(i, i + TRANSCRIPT_BATCH)
+        const placeholders = batch.map(() => "?").join(",")
+        const rows = (db
+          .query(
+            `SELECT session_id AS sid, data FROM part WHERE session_id IN (${placeholders}) AND json_extract(data, '$.type') = 'text' ORDER BY time_created`,
+          )
+          .all(...batch) ?? []) as { sid: string; data: string }[]
+        for (const row of rows) addTranscript(index, row.sid, row.data)
+        for (const id of batch) remaining.delete(id)
+        indexed += batch.length
+        report(false)
+        await nextTick()
       }
+    } catch {
+      // local store unavailable mid-walk; fall back to the remote path below
     } finally {
       db.close()
     }
-  } catch {
-    await buildSearchIndexRemote(api, targets, index)
   }
+
+  if (remaining.size > 0) {
+    await buildSearchIndexRemote(api, [...remaining], index, () => {
+      indexed += 1
+      report(false)
+    })
+  }
+  report(true)
   return index
 }
 
 async function buildSearchIndexRemote(
   api: TuiPluginApi,
-  targets: Entry[],
+  ids: string[],
   index: Map<string, string>,
+  onEach: () => void,
 ): Promise<void> {
   const home = process.env.HOME ?? ""
   const cacheDir = process.env.SESH_CACHE_DIR ?? `${home}/.cache/sesh`
-  await Promise.all(
-    targets.map(async (entry) => {
-      const base = index.get(entry.id) ?? ""
-      if (!SESSION_ID_PATTERN.test(entry.id)) return
+  let cursor = 0
+  // Bounded concurrency: a fixed worker pool instead of one request per session.
+  const worker = async () => {
+    for (;;) {
+      const i = cursor++
+      if (i >= ids.length) return
+      const id = ids[i]
+      const base = index.get(id) ?? ""
       try {
-        const raw = await readFile(`${cacheDir}/extractions/${entry.id}.json`, "utf8")
+        const raw = await readFile(`${cacheDir}/extractions/${id}.json`, "utf8")
         const record = JSON.parse(raw) as { fulltextLower?: unknown }
         const fulltext = typeof record?.fulltextLower === "string" ? record.fulltextLower : ""
-        index.set(entry.id, `${base} ${fulltext}`)
+        index.set(id, `${base} ${fulltext}`.trim())
       } catch {
         try {
-          const result = await api.client.session.messages({ sessionID: entry.id })
+          const result = await api.client.session.messages({ sessionID: id })
           const messages = result.data ?? []
           const text = messages
             .flatMap((message) =>
@@ -266,11 +335,13 @@ async function buildSearchIndexRemote(
             )
             .join(" ")
             .toLowerCase()
-          index.set(entry.id, `${base} ${text}`)
+          index.set(id, `${base} ${text}`.trim())
         } catch {}
       }
-    }),
-  )
+      onEach()
+    }
+  }
+  await Promise.all(Array.from({ length: Math.min(REMOTE_CONCURRENCY, ids.length) }, worker))
 }
 
 const TRANSCRIPT_PREVIEW_TURNS = 8
@@ -397,7 +468,7 @@ function SidebarSessions(props: { api: TuiPluginApi }) {
     let alive = true
     const load = async () => {
       try {
-        const all = await fetchEntries(props.api)
+        const { entries: all } = await fetchEntries(props.api)
         if (alive) setEntries(all)
       } catch {
         // leave the previous list in place rather than flashing to blank
@@ -469,7 +540,7 @@ function SidebarSessions(props: { api: TuiPluginApi }) {
         directory: entry.dir || undefined,
       })
       if (result && "error" in result && result.error) throw result.error
-      const remaining = await fetchEntries(props.api)
+      const { entries: remaining } = await fetchEntries(props.api)
       if (remaining.some((item) => item.id === entry.id)) {
         setEntries(remaining)
         props.api.ui.toast({ message: "Session was not deleted", variant: "error" })
@@ -723,7 +794,7 @@ function HomeSessions(props: { api: TuiPluginApi }) {
     let alive = true
     const load = async () => {
       try {
-        const all = await fetchEntries(props.api)
+        const { entries: all } = await fetchEntries(props.api)
         if (alive) setEntries(all)
       } catch {}
     }
@@ -827,13 +898,14 @@ const tui: TuiPlugin = async (api) => {
     if (api.mode.current() !== BASE_MODE) return
     if (api.renderer.currentFocusedEditor === null) return
 
-    let entries: Entry[]
+    let entriesResult: EntryResult
     try {
-      entries = await fetchEntries(api)
+      entriesResult = await fetchEntries(api)
     } catch {
       api.ui.toast({ message: "Could not load sessions", variant: "error" })
       return
     }
+    const entries = entriesResult.entries
     if (entries.length === 0) {
       api.ui.toast({ message: "No sessions found", variant: "warning" })
       return
@@ -844,7 +916,12 @@ const tui: TuiPlugin = async (api) => {
     const [query, setQuery] = createSignal("")
     const [cursor, setCursor] = createSignal(0)
     const [searchIndex, setSearchIndex] = createSignal<Map<string, string>>(new Map())
-    void buildSearchIndex(api, entries).then(setSearchIndex)
+    const [indexProgress, setIndexProgress] = createSignal<IndexProgress>({
+      indexed: 0,
+      total: 0,
+      complete: false,
+    })
+    void buildSearchIndex(api, entries, setIndexProgress).then(setSearchIndex)
     let pickerInput: { value: string; isDestroyed?: boolean } | undefined
 
     type DialogRow = { kind: "group"; label: string; count: number } | { kind: "item"; entry: Entry }
@@ -868,6 +945,22 @@ const tui: TuiPlugin = async (api) => {
 
     const selectableEntries = createMemo(() => matchedGroups().flatMap((g) => g.list))
 
+    // Visible bounding: say how much transcript text search actually covers and
+    // when the metadata walk hit its cap, instead of silently under-reporting.
+    const coverageLabel = createMemo(() => {
+      const progress = indexProgress()
+      const bits: string[] = []
+      if (progress.total > 0) {
+        bits.push(
+          progress.complete
+            ? `transcripts ${progress.total}`
+            : `indexing transcripts ${progress.indexed}/${progress.total}`,
+        )
+      }
+      if (entriesResult.truncated) bits.push(`showing newest ${entries.length}`)
+      return bits.join(" · ")
+    })
+
     createEffect(() => {
       const count = selectableEntries().length
       if (cursor() >= count) setCursor(Math.max(0, count - 1))
@@ -1041,6 +1134,11 @@ const tui: TuiPlugin = async (api) => {
                 }}
               />
             </box>
+            <Show when={coverageLabel()}>
+              <box paddingTop={1}>
+                <text style={{ fg: api.theme.current.textMuted }}>{coverageLabel()}</text>
+              </box>
+            </Show>
           </box>
           <box
             flexDirection="column"