aisessions 1.0.0

package/src/agents/hermes.js

@@ -0,0 +1,38 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { readLimited, parseJsonl, pathSize, humanSize, ignored, titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate } from './utils.js'
+
+const HOME     = homedir()
+const DATA_DIR = process.env.HERMES_DATA_DIR || join(HOME, '.hermes')
+
+export const AGENT_ID    = 'hermes'
+export const AGENT_LABEL = 'Hermes'
+export const AGENT_COLOR = '#999'
+
+export function isInstalled() { return existsSync(DATA_DIR) }
+
+export async function loadSessions() {
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({ agent: AGENT_ID, agentLabel: AGENT_LABEL, path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'), title: title || fileTitle(full), titleSource: tsrc || 'filename', project: projName(pp), projectPath: pp, date, dateLabel: fmtDate(date), size, sizeLabel: humanSize(size), filename: e.name, msgCount: objs.length })
+        }
+      }
+    } catch {}
+  }
+  walk(DATA_DIR)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/index.js

@@ -0,0 +1,39 @@
+import * as claude    from './claude.js'
+import * as codex     from './codex.js'
+import * as opencode  from './opencode.js'
+import * as amp       from './amp.js'
+import * as droid     from './droid.js'
+import * as codebuff  from './codebuff.js'
+import * as hermes    from './hermes.js'
+import * as pi        from './pi.js'
+import * as goose     from './goose.js'
+import * as kilo      from './kilo.js'
+import * as copilot   from './copilot.js'
+import * as gemini    from './gemini.js'
+import * as kimi      from './kimi.js'
+import * as qwen      from './qwen.js'
+import * as openclaw  from './openclaw.js'
+
+const ALL_AGENTS = [
+  claude, codex, opencode, amp, droid,
+  codebuff, hermes, pi, goose, kilo,
+  copilot, gemini, kimi, qwen, openclaw,
+]
+
+export function getInstalledAgents() {
+  return ALL_AGENTS
+    .filter(a => { try { return a.isInstalled() } catch { return false } })
+    .map(a => ({ id: a.AGENT_ID, label: a.AGENT_LABEL, color: a.AGENT_COLOR }))
+}
+
+export async function getAllSessions() {
+  const results = await Promise.allSettled(
+    ALL_AGENTS.map(a => {
+      try { return a.isInstalled() ? a.loadSessions() : Promise.resolve([]) }
+      catch { return Promise.resolve([]) }
+    })
+  )
+  return results
+    .flatMap(r => r.status === 'fulfilled' ? r.value : [])
+    .sort((a,b) => b.date - a.date)
+}

package/src/agents/kilo.js

@@ -0,0 +1,38 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { readLimited, parseJsonl, pathSize, humanSize, ignored, titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate } from './utils.js'
+
+const HOME     = homedir()
+const DATA_DIR = process.env.KILO_DATA_DIR || join(HOME, '.kilo')
+
+export const AGENT_ID    = 'kilo'
+export const AGENT_LABEL = 'Kilo'
+export const AGENT_COLOR = '#bbb'
+
+export function isInstalled() { return existsSync(DATA_DIR) }
+
+export async function loadSessions() {
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({ agent: AGENT_ID, agentLabel: AGENT_LABEL, path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'), title: title || fileTitle(full), titleSource: tsrc || 'filename', project: projName(pp), projectPath: pp, date, dateLabel: fmtDate(date), size, sizeLabel: humanSize(size), filename: e.name, msgCount: objs.length })
+        }
+      }
+    } catch {}
+  }
+  walk(DATA_DIR)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/kimi.js

@@ -0,0 +1,38 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { readLimited, parseJsonl, pathSize, humanSize, ignored, titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate } from './utils.js'
+
+const HOME     = homedir()
+const DATA_DIR = process.env.KIMI_DATA_DIR || join(HOME, '.kimi')
+
+export const AGENT_ID    = 'kimi'
+export const AGENT_LABEL = 'Kimi'
+export const AGENT_COLOR = '#ddd'
+
+export function isInstalled() { return existsSync(DATA_DIR) }
+
+export async function loadSessions() {
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({ agent: AGENT_ID, agentLabel: AGENT_LABEL, path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'), title: title || fileTitle(full), titleSource: tsrc || 'filename', project: projName(pp), projectPath: pp, date, dateLabel: fmtDate(date), size, sizeLabel: humanSize(size), filename: e.name, msgCount: objs.length })
+        }
+      }
+    } catch {}
+  }
+  walk(DATA_DIR)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/openclaw.js

@@ -0,0 +1,38 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { readLimited, parseJsonl, pathSize, humanSize, ignored, titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate } from './utils.js'
+
+const HOME     = homedir()
+const DATA_DIR = process.env.OPENCLAW_DATA_DIR || join(HOME, '.openclaw')
+
+export const AGENT_ID    = 'openclaw'
+export const AGENT_LABEL = 'OpenClaw'
+export const AGENT_COLOR = '#f0f0f0'
+
+export function isInstalled() { return existsSync(DATA_DIR) }
+
+export async function loadSessions() {
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({ agent: AGENT_ID, agentLabel: AGENT_LABEL, path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'), title: title || fileTitle(full), titleSource: tsrc || 'filename', project: projName(pp), projectPath: pp, date, dateLabel: fmtDate(date), size, sizeLabel: humanSize(size), filename: e.name, msgCount: objs.length })
+        }
+      }
+    } catch {}
+  }
+  walk(DATA_DIR)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/opencode.js

@@ -0,0 +1,50 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import {
+  readLimited, parseJsonl, pathSize, humanSize, ignored,
+  titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate,
+} from './utils.js'
+
+const HOME        = homedir()
+const DATA_DIR    = process.env.OPENCODE_DATA_DIR || join(HOME, '.opencode')
+const SESS_DIRS   = [join(DATA_DIR, 'sessions'), DATA_DIR]
+
+export const AGENT_ID    = 'opencode'
+export const AGENT_LABEL = 'OpenCode'
+export const AGENT_COLOR = '#b0b0b0'
+
+export function isInstalled() { return existsSync(DATA_DIR) }
+
+export async function loadSessions() {
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp   = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({
+            agent: AGENT_ID, agentLabel: AGENT_LABEL,
+            path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'),
+            title: title || fileTitle(full), titleSource: tsrc || 'filename',
+            project: projName(pp), projectPath: pp,
+            date, dateLabel: fmtDate(date),
+            size, sizeLabel: humanSize(size),
+            filename: e.name, msgCount: objs.length,
+          })
+        }
+      }
+    } catch {}
+  }
+  SESS_DIRS.forEach(walk)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/pi.js

@@ -0,0 +1,41 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { readLimited, parseJsonl, pathSize, humanSize, ignored, titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate } from './utils.js'
+
+const HOME     = homedir()
+const DATA_DIR = process.env.PI_AGENT_DATA_DIR || join(HOME, '.pi-agent') || join(HOME, '.pi')
+
+export const AGENT_ID    = 'pi'
+export const AGENT_LABEL = 'Pi Agent'
+export const AGENT_COLOR = '#aaa'
+
+export function isInstalled() {
+  return existsSync(join(HOME, '.pi-agent')) || existsSync(join(HOME, '.pi'))
+}
+
+export async function loadSessions() {
+  const dirs = [process.env.PI_AGENT_DATA_DIR, join(HOME, '.pi-agent'), join(HOME, '.pi')].filter(Boolean)
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({ agent: AGENT_ID, agentLabel: AGENT_LABEL, path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'), title: title || fileTitle(full), titleSource: tsrc || 'filename', project: projName(pp), projectPath: pp, date, dateLabel: fmtDate(date), size, sizeLabel: humanSize(size), filename: e.name, msgCount: objs.length })
+        }
+      }
+    } catch {}
+  }
+  dirs.forEach(walk)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/qwen.js

@@ -0,0 +1,38 @@
+import { homedir } from 'node:os'
+import { existsSync, readdirSync } from 'node:fs'
+import { join, basename } from 'node:path'
+import { readLimited, parseJsonl, pathSize, humanSize, ignored, titleFromObjs, fileTitle, dateFromPath, projName, guessProj, fmtDate } from './utils.js'
+
+const HOME     = homedir()
+const DATA_DIR = process.env.QWEN_DATA_DIR || join(HOME, '.qwen')
+
+export const AGENT_ID    = 'qwen'
+export const AGENT_LABEL = 'Qwen'
+export const AGENT_COLOR = '#eee'
+
+export function isInstalled() { return existsSync(DATA_DIR) }
+
+export async function loadSessions() {
+  const items = []
+  const walk = dir => {
+    if (!existsSync(dir)) return
+    try {
+      for (const e of readdirSync(dir, { withFileTypes: true })) {
+        const full = join(dir, e.name)
+        if (ignored(full)) continue
+        if (e.isDirectory()) walk(full)
+        else if (e.name.endsWith('.jsonl') || e.name.endsWith('.json')) {
+          const text = readLimited(full)
+          const objs = parseJsonl(text)
+          const [title, tsrc] = titleFromObjs(objs)
+          const pp = guessProj(text) || 'Unknown'
+          const date = dateFromPath(full)
+          const size = pathSize(full)
+          items.push({ agent: AGENT_ID, agentLabel: AGENT_LABEL, path: full, sessionId: basename(full, e.name.endsWith('.jsonl') ? '.jsonl' : '.json'), title: title || fileTitle(full), titleSource: tsrc || 'filename', project: projName(pp), projectPath: pp, date, dateLabel: fmtDate(date), size, sizeLabel: humanSize(size), filename: e.name, msgCount: objs.length })
+        }
+      }
+    } catch {}
+  }
+  walk(DATA_DIR)
+  return items.sort((a,b) => b.date - a.date)
+}

package/src/agents/utils.js

@@ -0,0 +1,283 @@
+import { statSync, readdirSync, openSync, readSync, closeSync } from 'node:fs'
+import { join, basename, extname } from 'node:path'
+
+export const SKIP_PARTS  = new Set(['.tmp','plugins','.git','node_modules','memory'])
+export const MAX_BYTES   = 8_000_000
+
+export const BAD_TITLES = new Set([
+  'none','null','undefined','untitled','no title','new chat','auto',
+  'exec_command','automation_update','response_item','reasoning',
+  'function_call','tool_call','shell_command','apply_patch',
+  'read_file','write_file','list_files','update_plan','plan_update',
+  'turn_context','message','event','delta','session',
+  'input_text','output_text','read_thread_terminal','read_thread',
+  'terminal','thread_terminal','codex_turn_context','conversation_item',
+  'assistant_message','user_message','system_message',
+  'local_shell_call','local_shell_output','mcp_tool_call','mcp_tool_output',
+])
+
+export const TITLE_KEYS   = new Set(['title','conversation_title','chat_title','thread_title','session_title','summary'])
+export const PROJECT_KEYS = new Set(['cwd','workdir','working_directory','current_working_directory','project','project_path','repository','repo','workspace','workspace_path'])
+
+export const CLAUDE_SKIP_PREFIX = [
+  '<local-command','<command-name','<command-message','<command-args',
+  '<local-command-stdout','<system-reminder','<function_calls>','<user-prompt-submit-hook',
+]
+
+// ── I/O ──────────────────────────────────────────────────────────────────────
+
+export function readLimited(p, limit = MAX_BYTES) {
+  try {
+    const st = statSync(p)
+    if (!st.isFile()) return ''
+    const size = Math.min(st.size, limit)
+    const buf  = Buffer.allocUnsafe(size)
+    const fd   = openSync(p, 'r')
+    readSync(fd, buf, 0, size, 0)
+    closeSync(fd)
+    return buf.toString('utf8')
+  } catch { return '' }
+}
+
+export function pathSize(p) {
+  try {
+    const st = statSync(p)
+    if (st.isFile()) return st.size
+    let total = 0
+    const walk = dir => {
+      try {
+        for (const e of readdirSync(dir, { withFileTypes: true })) {
+          if (SKIP_PARTS.has(e.name)) continue
+          const full = join(dir, e.name)
+          if (e.isDirectory()) walk(full)
+          else try { total += statSync(full).size } catch {}
+        }
+      } catch {}
+    }
+    walk(p)
+    return total
+  } catch { return 0 }
+}
+
+export function humanSize(n) {
+  for (const u of ['B','KB','MB','GB']) {
+    if (n < 1024) return `${n.toFixed(1)} ${u}`
+    n /= 1024
+  }
+  return `${n.toFixed(1)} TB`
+}
+
+// ── JSONL ─────────────────────────────────────────────────────────────────────
+
+export function parseJsonl(text) {
+  const objs = []
+  text = (text || '').trim()
+  if (!text) return objs
+  try {
+    const d = JSON.parse(text)
+    if (d && typeof d === 'object' && !Array.isArray(d)) return [d]
+    if (Array.isArray(d)) return d.filter(x => x && typeof x === 'object')
+  } catch {}
+  for (const line of text.split('\n')) {
+    const l = line.trim()
+    if (!l) continue
+    try { const d = JSON.parse(l); if (d && typeof d === 'object') objs.push(d) } catch {}
+  }
+  return objs
+}
+
+// ── String helpers ────────────────────────────────────────────────────────────
+
+export function cleanStr(v) {
+  if (typeof v !== 'string') return ''
+  return v.replace(/\\n/g,' ').replace(/\\t/g,' ').replace(/\n|\t/g,' ').replace(/\s+/g,' ').trim()
+}
+
+export function badTitle(v) {
+  v = cleanStr(v)
+  if (!v) return true
+  const lo = v.toLowerCase()
+  if (BAD_TITLES.has(lo))                                    return true
+  if (v.length < 4 || v.length > 220)                       return true
+  if (v[0] === '{' || v[0] === '[')                          return true
+  if (v.startsWith('/') && !v.includes(' '))                 return true
+  if (/^[a-f0-9-]{20,}$/i.test(lo))                         return true
+  if (/^rollout-\d{4}-/.test(lo))                            return true
+  if (lo.endsWith('.json') || lo.endsWith('.jsonl'))         return true
+  if (lo.startsWith('codex ') && lo.includes('event'))       return true
+  if (/^[a-z]+(_[a-z0-9]+){1,4}$/.test(lo) && v.length<=40) return true
+  if (/^<[a-zA-Z_][a-zA-Z0-9_]*[\s>]/.test(v.trimStart())) return true
+  return false
+}
+
+export function truncStr(v, n = 150) {
+  v = cleanStr(v)
+  return v.length <= n ? v : v.slice(0, n - 1).trimEnd() + '…'
+}
+
+export function sidFromPath(p) {
+  const name = basename(p)
+  const m = name.match(/([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})/i)
+  return m ? m[1] : name.replace(/\.[^.]+$/, '')
+}
+
+export function dateFromPath(p) {
+  const name = basename(p)
+  const pats = [
+    /(\d{4})-(\d{2})-(\d{2})T(\d{2})-(\d{2})-(\d{2})/,
+    /(\d{4})-(\d{2})-(\d{2})/,
+  ]
+  for (const pat of pats) {
+    const m = name.match(pat)
+    if (m) {
+      const g = m.slice(1).map(Number)
+      try { return new Date(g[0], g[1]-1, g[2], g[3]||0, g[4]||0, g[5]||0) } catch {}
+    }
+  }
+  try { return new Date(statSync(p).mtimeMs) } catch { return new Date(0) }
+}
+
+export function fmtDate(d) {
+  try { return d.toISOString().slice(0,16).replace('T',' ') } catch { return '' }
+}
+
+export function projName(p) {
+  if (!p || p === 'Unknown') return 'Unknown Project'
+  try { return basename(p) || p } catch { return p }
+}
+
+export function ignored(p) {
+  return p.split('/').some(part => SKIP_PARTS.has(part))
+}
+
+export function groupItems(items) {
+  const map = new Map()
+  for (const item of items) {
+    const k = item.agent + '::' + item.project
+    if (!map.has(k)) map.set(k, { agent: item.agent, agentLabel: item.agentLabel, project: item.project, projectPath: item.projectPath, items: [], totalSize: 0, latest: item.date })
+    const g = map.get(k)
+    g.items.push(item)
+    g.totalSize += item.size
+    if (item.date > g.latest) g.latest = item.date
+  }
+  return [...map.values()].sort((a,b) => b.latest - a.latest)
+}
+
+// ── Title extraction (port of Python logic) ───────────────────────────────────
+
+export function findStrings(obj, keys) {
+  const out = []
+  if (!obj) return out
+  if (typeof obj === 'object' && !Array.isArray(obj)) {
+    for (const [k, v] of Object.entries(obj)) {
+      if (keys.has(k.toLowerCase())) {
+        if (typeof v === 'string') out.push(v)
+        else if (Array.isArray(v)) v.forEach(i => { if (typeof i === 'string') out.push(i) })
+      }
+      if (v && typeof v === 'object') out.push(...findStrings(v, keys))
+    }
+  } else if (Array.isArray(obj)) {
+    obj.forEach(i => out.push(...findStrings(i, keys)))
+  }
+  return out
+}
+
+function extractText(v) {
+  if (typeof v === 'string') return [v]
+  if (Array.isArray(v)) return v.flatMap(extractText)
+  if (v && typeof v === 'object') {
+    const out  = []
+    const typ  = cleanStr(v.type || '').toLowerCase()
+    if (typeof v.text === 'string') out.push(v.text)
+    if (v.content) out.push(...extractText(v.content))
+    if (v.message) out.push(...extractText(v.message))
+    if (v.input && !['local_shell_call','tool_call','function_call'].includes(typ)) out.push(...extractText(v.input))
+    if (v.prompt) out.push(...extractText(v.prompt))
+    return out
+  }
+  return []
+}
+
+function isUserObj(obj) {
+  if (!obj || typeof obj !== 'object') return false
+  const role = cleanStr(obj.role  || '').toLowerCase()
+  const typ  = cleanStr(obj.type  || '').toLowerCase()
+  const it   = cleanStr(obj.item_type || '').toLowerCase()
+  if (role === 'user') return true
+  if (['user','user_message'].includes(typ)) return true
+  if (['user','user_message'].includes(it))  return true
+  if (obj.item?.role    && cleanStr(obj.item.role).toLowerCase()    === 'user') return true
+  if (obj.payload?.role && cleanStr(obj.payload.role).toLowerCase() === 'user') return true
+  return false
+}
+
+function userMessages(obj) {
+  const out = []
+  if (!obj) return out
+  if (typeof obj === 'object' && !Array.isArray(obj)) {
+    if (isUserObj(obj)) {
+      out.push(...extractText(obj))
+      for (const sub of [obj.item, obj.payload]) {
+        if (sub && typeof sub === 'object') out.push(...extractText(sub))
+      }
+    }
+    for (const v of Object.values(obj)) out.push(...userMessages(v))
+  } else if (Array.isArray(obj)) {
+    obj.forEach(i => out.push(...userMessages(i)))
+  }
+  return out
+}
+
+export function titleFromObjs(objs) {
+  for (const obj of objs) {
+    for (const v of findStrings(obj, TITLE_KEYS)) {
+      const t = truncStr(v)
+      if (!badTitle(t)) return [t, 'title field']
+    }
+  }
+  for (const obj of objs) {
+    for (const v of userMessages(obj)) {
+      const t = truncStr(v)
+      if (!badTitle(t)) return [t, 'user message']
+    }
+  }
+  return ['', '']
+}
+
+export function regexTitle(text) {
+  const pats = [
+    /"role"\s*:\s*"user".{0,2500}?"text"\s*:\s*"((?:\\.|[^"\\]){4,500})"/s,
+    /"type"\s*:\s*"user_message".{0,2500}?"text"\s*:\s*"((?:\\.|[^"\\]){4,500})"/s,
+    /"type"\s*:\s*"input_text"\s*,\s*"text"\s*:\s*"((?:\\.|[^"\\]){4,500})"/s,
+  ]
+  for (const pat of pats) {
+    const m = text.match(pat)
+    if (m) {
+      let raw = m[1]
+      try { raw = JSON.parse(`"${raw}"`) } catch {}
+      const t = truncStr(raw)
+      if (!badTitle(t)) return [t, 'regex']
+    }
+  }
+  return ['', '']
+}
+
+export function fileTitle(p) {
+  let t = basename(p, extname(p))
+  t = t.replace(/^rollout-/, '')
+  t = t.replace(/\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2}-?/g, '')
+  t = t.replace(/\d{4}-\d{2}-\d{2}-?/g, '')
+  t = t.replace(/[0-9a-f]{8}-[0-9a-f-]{27,}/gi, '')
+  t = t.replace(/[_-]/g, ' ').replace(/\s+/g, ' ').trim()
+  return t || 'Untitled Chat'
+}
+
+export function guessProj(text) {
+  const cands = []
+  for (const m of text.matchAll(/\/(?:Users|home|Volumes)\/[^\s"'\n\r\t]+/g)) {
+    const s = m[0].replace(/[.,;:)]+$/, '')
+    if (s.length > 8) cands.push(s)
+  }
+  const pref = ['documents','desktop','projects','workspace','work','upwork','repos','code','codes','dev']
+  return cands.find(c => pref.some(w => c.toLowerCase().includes(w))) || cands[0] || ''
+}