@swarmify/agents-cli 1.10.3 → 1.11.0

package/dist/lib/session/discover.js

@@ -5,6 +5,7 @@ import * as crypto from 'crypto';
 import * as readline from 'readline';
 import { execSync } from 'child_process';
 import { SESSION_AGENTS } from './types.js';
+import { extractSessionTopic } from './prompt.js';
 const HOME = os.homedir();
 const AGENTS_DIR = path.join(HOME, '.agents');
 const SESSIONS_DIR = path.join(AGENTS_DIR, 'sessions');
@@ -30,18 +31,31 @@ export async function discoverSessions(options) {
     // Merge with persistent index (preserves sessions whose files were removed)
     const index = loadIndex();
     const liveIds = new Set(sessions.map(s => s.id));
+    const agentFilter = new Set(agents);
+    // Add matching index entries to display results
     index.forEach((entry, id) => {
-        if (!liveIds.has(id)) {
+        if (!liveIds.has(id) && agentFilter.has(entry.agent)) {
             sessions.push(entry);
         }
     });
-    // Persist updated index
-    saveIndex(sessions);
+    // Persist: merge live sessions into full index (don't drop unqueried agents)
+    const toSave = new Map(index);
+    for (const s of sessions) {
+        toSave.set(s.id, s);
+    }
+    saveIndex([...toSave.values()]);
+    const projectQuery = options?.project?.trim();
     // Filter by project (case-insensitive substring match)
-    if (options?.project) {
-        const query = options.project.toLowerCase();
+    if (projectQuery) {
+        const query = projectQuery.toLowerCase();
         sessions = sessions.filter(s => s.project?.toLowerCase().includes(query));
     }
+    // An explicit project search should scan across directories instead of
+    // intersecting with the default cwd-only scope.
+    if (!options?.all && !projectQuery) {
+        const currentDir = normalizeCwd(options?.cwd || process.cwd());
+        sessions = sessions.filter(s => normalizeCwd(s.cwd) === currentDir);
+    }
     // Sort by timestamp descending
     sessions.sort((a, b) => {
         const ta = new Date(a.timestamp).getTime() || 0;
@@ -50,17 +64,23 @@ export async function discoverSessions(options) {
     });
     return sessions.slice(0, limit);
 }
+function normalizeCwd(cwd) {
+    if (!cwd)
+        return '';
+    const resolved = path.resolve(cwd);
+    return safeRealpathSync(resolved) || resolved;
+}
 /**
  * Resolve a session by full or short ID from the full index.
  */
 export function resolveSessionById(sessions, idQuery) {
     const query = idQuery.toLowerCase();
-    // Exact match first
-    const exact = sessions.filter(s => s.id.toLowerCase() === query);
+    // Exact match first (full id or shortId)
+    const exact = sessions.filter(s => s.id.toLowerCase() === query || s.shortId.toLowerCase() === query);
     if (exact.length > 0)
         return exact;
-    // Prefix match
-    return sessions.filter(s => s.id.toLowerCase().startsWith(query));
+    // Prefix match (against both id and shortId)
+    return sessions.filter(s => s.id.toLowerCase().startsWith(query) || s.shortId.toLowerCase().startsWith(query));
 }
 // ---------------------------------------------------------------------------
 // Persistent session index
@@ -79,10 +99,12 @@ function loadIndex() {
                 if (entry.id)
                     map.set(entry.id, entry);
             }
-            catch { }
+            catch { /* malformed index entry, skip */ }
         }
     }
-    catch { }
+    catch (err) {
+        console.error(`Warning: Could not load session cache (${err.message}). Rebuilding...`);
+    }
     return map;
 }
 function saveIndex(sessions) {
@@ -95,22 +117,13 @@ function saveIndex(sessions) {
             if (seen.has(s.id))
                 continue;
             seen.add(s.id);
-            lines.push(JSON.stringify({
-                id: s.id,
-                shortId: s.shortId,
-                agent: s.agent,
-                timestamp: s.timestamp,
-                project: s.project,
-                cwd: s.cwd,
-                filePath: s.filePath,
-                gitBranch: s.gitBranch,
-                version: s.version,
-                account: s.account,
-            }));
+            lines.push(JSON.stringify(s));
         }
         fs.writeFileSync(INDEX_PATH, lines.join('\n') + '\n', 'utf-8');
     }
-    catch { }
+    catch (err) {
+        console.error(`Warning: Could not save session cache: ${err.message}`);
+    }
 }
 // ---------------------------------------------------------------------------
 // Multi-version directory scanning
@@ -124,7 +137,7 @@ function saveIndex(sessions) {
  * @param subdir - Subdirectory within the agent's config dir where sessions live
  *                 (e.g., 'projects' for Claude, 'sessions' for Codex, 'tmp' for Gemini)
  */
-function getAgentSessionDirs(agent, subdir) {
+export function getAgentSessionDirs(agent, subdir) {
     const resolved = new Set();
     const dirs = [];
     function addDir(dir) {
@@ -147,7 +160,7 @@ function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(versionsBase, version, 'home', `.${agent}`, subdir));
             }
         }
-        catch { }
+        catch { /* dir unreadable or missing */ }
     }
     // 3. Backups (from before version management was enabled)
     const backupsBase = path.join(AGENTS_DIR, 'backups', agent);
@@ -157,7 +170,7 @@ function getAgentSessionDirs(agent, subdir) {
                 addDir(path.join(backupsBase, ts, subdir));
             }
         }
-        catch { }
+        catch { /* dir unreadable or missing */ }
     }
     return dirs;
 }
@@ -180,7 +193,7 @@ function getClaudeAccount() {
                 candidates.push(path.join(versionsBase, version, 'home', '.claude.json'));
             }
         }
-        catch { }
+        catch { /* versions dir unreadable */ }
     }
     for (const candidate of candidates) {
         try {
@@ -193,7 +206,7 @@ function getClaudeAccount() {
                 return name;
             }
         }
-        catch { }
+        catch { /* auth file unreadable or malformed */ }
     }
     cachedClaudeAccount = '';
     return undefined;
@@ -205,6 +218,7 @@ async function discoverClaudeSessions() {
     const sessions = [];
     const seen = new Set();
     const account = getClaudeAccount();
+    let skipped = 0;
     for (const projectsDir of getAgentSessionDirs('claude', 'projects')) {
         let projectDirs;
         try {
@@ -236,48 +250,36 @@ async function discoverClaudeSessions() {
                     if (meta)
                         sessions.push(meta);
                 }
-                catch { }
+                catch {
+                    skipped++;
+                }
             }
         }
     }
+    if (skipped > 0 && process.env.AGENTS_DEBUG) {
+        console.error(`[debug] Skipped ${skipped} unreadable Claude session(s)`);
+    }
     return sessions;
 }
 async function readClaudeMeta(filePath, sessionId, account) {
-    const lines = await readFirstLines(filePath, 10);
-    let topic;
-    for (const line of lines) {
-        let parsed;
-        try {
-            parsed = JSON.parse(line);
-        }
-        catch {
-            continue;
-        }
-        // Extract topic from first user message
-        if (!topic && parsed.type === 'user' && parsed.message?.content) {
-            const text = Array.isArray(parsed.message.content)
-                ? parsed.message.content.find((b) => b.type === 'text')?.text
-                : typeof parsed.message.content === 'string' ? parsed.message.content : undefined;
-            if (text)
-                topic = extractTopic(text);
-        }
-        // Look for first user or assistant line with timestamp/cwd
-        if ((parsed.type === 'user' || parsed.type === 'assistant') && parsed.timestamp) {
-            const cwd = parsed.cwd || '';
-            return {
-                id: sessionId,
-                shortId: sessionId.slice(0, 8),
-                agent: 'claude',
-                timestamp: parsed.timestamp,
-                project: cwd ? path.basename(cwd) : undefined,
-                cwd,
-                filePath,
-                gitBranch: parsed.gitBranch || undefined,
-                version: parsed.version || undefined,
-                account,
-                topic,
-            };
-        }
+    const scan = await scanClaudeSession(filePath);
+    if (scan.timestamp) {
+        const cwd = scan.cwd || '';
+        return {
+            id: sessionId,
+            shortId: sessionId.slice(0, 8),
+            agent: 'claude',
+            timestamp: scan.timestamp,
+            project: cwd ? path.basename(cwd) : undefined,
+            cwd,
+            filePath,
+            gitBranch: scan.gitBranch,
+            version: scan.version,
+            account,
+            topic: scan.topic,
+            messageCount: scan.messageCount,
+            tokenCount: scan.tokenCount,
+        };
     }
     // Fallback: use file mtime
     const stat = safeStatSync(filePath);
@@ -288,6 +290,9 @@ async function readClaudeMeta(filePath, sessionId, account) {
         timestamp: stat ? stat.mtime.toISOString() : new Date().toISOString(),
         filePath,
         account,
+        messageCount: scan.messageCount,
+        tokenCount: scan.tokenCount,
+        topic: scan.topic,
     };
 }
 // ---------------------------------------------------------------------------
@@ -308,7 +313,7 @@ function getCodexAccount() {
                 candidates.push(path.join(versionsBase, version, 'home', '.codex', 'auth.json'));
             }
         }
-        catch { }
+        catch { /* versions dir unreadable */ }
     }
     for (const candidate of candidates) {
         try {
@@ -328,7 +333,7 @@ function getCodexAccount() {
                 }
             }
         }
-        catch { }
+        catch { /* auth file or JWT malformed */ }
     }
     cachedCodexAccount = '';
     return undefined;
@@ -340,6 +345,7 @@ async function discoverCodexSessions() {
     const sessions = [];
     const seen = new Set();
     const account = getCodexAccount();
+    let skipped = 0;
     for (const sessionsDir of getAgentSessionDirs('codex', 'sessions')) {
         const jsonlFiles = walkForFiles(sessionsDir, '.jsonl', 200);
         for (const filePath of jsonlFiles) {
@@ -350,56 +356,35 @@ async function discoverCodexSessions() {
                     sessions.push(meta);
                 }
             }
-            catch { }
+            catch {
+                skipped++;
+            }
         }
     }
+    if (skipped > 0 && process.env.AGENTS_DEBUG) {
+        console.error(`[debug] Skipped ${skipped} unreadable Codex session(s)`);
+    }
     return sessions;
 }
 async function readCodexMeta(filePath, account) {
-    const lines = await readFirstLines(filePath, 5);
-    if (lines.length === 0)
-        return null;
-    let parsed;
-    try {
-        parsed = JSON.parse(lines[0]);
-    }
-    catch {
-        return null;
-    }
-    if (parsed.type !== 'session_meta')
-        return null;
-    const payload = parsed.payload || {};
-    const sessionId = payload.id || '';
+    const scan = await scanCodexSession(filePath);
+    const sessionId = scan.sessionId || '';
     if (!sessionId)
         return null;
-    // Extract topic from first user message in subsequent lines
-    let topic;
-    for (let i = 1; i < lines.length; i++) {
-        try {
-            const ev = JSON.parse(lines[i]);
-            if (ev.type === 'message' && ev.role === 'user' && ev.content) {
-                const text = typeof ev.content === 'string' ? ev.content
-                    : Array.isArray(ev.content) ? ev.content.find((b) => b.type === 'input_text')?.text : undefined;
-                if (text) {
-                    topic = extractTopic(text);
-                    break;
-                }
-            }
-        }
-        catch { }
-    }
-    const cwd = payload.cwd || '';
+    const cwd = scan.cwd || '';
     return {
         id: sessionId,
         shortId: sessionId.slice(0, 8),
         agent: 'codex',
-        timestamp: payload.timestamp || parsed.timestamp || new Date().toISOString(),
+        timestamp: scan.timestamp || new Date().toISOString(),
         project: cwd ? path.basename(cwd) : undefined,
         cwd,
         filePath,
-        gitBranch: payload.git?.branch || undefined,
-        version: payload.version || undefined,
-        topic,
+        gitBranch: scan.gitBranch,
+        version: scan.version,
+        topic: scan.topic,
+        messageCount: scan.messageCount,
+        tokenCount: scan.tokenCount,
         account,
     };
 }
@@ -410,6 +395,7 @@ async function discoverGeminiSessions() {
     const projectMap = buildGeminiProjectMap();
     const sessions = [];
     const seen = new Set();
+    let skipped = 0;
     for (const tmpDir of getAgentSessionDirs('gemini', 'tmp')) {
         let hashDirs;
         try {
@@ -438,23 +424,28 @@ async function discoverGeminiSessions() {
                         sessions.push(meta);
                     }
                 }
-                catch { }
+                catch {
+                    skipped++;
+                }
             }
         }
     }
+    if (skipped > 0 && process.env.AGENTS_DEBUG) {
+        console.error(`[debug] Skipped ${skipped} unreadable Gemini session(s)`);
+    }
     return sessions;
 }
 function readGeminiMeta(filePath, hashDir, projectMap) {
-    // Read the first ~2KB to get top-level fields without parsing entire messages array
-    const fd = fs.openSync(filePath, 'r');
-    const buf = Buffer.alloc(2048);
-    const bytesRead = fs.readSync(fd, buf, 0, 2048, 0);
-    fs.closeSync(fd);
-    const header = buf.toString('utf-8', 0, bytesRead);
-    // Extract fields via regex (avoids parsing potentially huge messages array)
-    const sessionId = extractJsonField(header, 'sessionId');
-    const startTime = extractJsonField(header, 'startTime');
-    const projectHash = extractJsonField(header, 'projectHash');
+    let session;
+    try {
+        session = JSON.parse(fs.readFileSync(filePath, 'utf-8'));
+    }
+    catch {
+        return null;
+    }
+    const sessionId = typeof session.sessionId === 'string' ? session.sessionId : '';
+    const startTime = typeof session.startTime === 'string' ? session.startTime : '';
+    const projectHash = typeof session.projectHash === 'string' ? session.projectHash : '';
     if (!sessionId)
         return null;
     // Resolve project name from hash
@@ -462,11 +453,31 @@ function readGeminiMeta(filePath, hashDir, projectMap) {
     const project = projectInfo?.name || hashDir.slice(0, 12);
     const cwd = projectInfo?.path;
     const stat = safeStatSync(filePath);
-    // Try to extract first user message from the header bytes
+    const messages = Array.isArray(session.messages) ? session.messages : [];
     let topic;
-    const userMsgMatch = header.match(/"role"\s*:\s*"user"[\s\S]*?"text"\s*:\s*"([^"]{1,200})"/);
-    if (userMsgMatch)
-        topic = extractTopic(userMsgMatch[1]);
+    let messageCount = 0;
+    let tokenCount = 0;
+    let sawTokenCount = false;
+    for (const message of messages) {
+        if (message.type === 'user') {
+            const text = extractGeminiMessageText(message.content);
+            if (text) {
+                messageCount++;
+                if (!topic)
+                    topic = extractSessionTopic(text);
+            }
+        }
+        else if (message.type === 'gemini') {
+            if (extractGeminiMessageText(message.content)) {
+                messageCount++;
+            }
+        }
+        const total = getGeminiTokenCount(message.tokens);
+        if (total !== null) {
+            tokenCount += total;
+            sawTokenCount = true;
+        }
+    }
     return {
         id: sessionId,
         shortId: sessionId.slice(0, 8),
@@ -476,6 +487,8 @@ function readGeminiMeta(filePath, hashDir, projectMap) {
         cwd,
         filePath,
         topic,
+        messageCount,
+        tokenCount: sawTokenCount ? tokenCount : undefined,
     };
 }
 function buildGeminiProjectMap() {
@@ -507,9 +520,7 @@ function buildGeminiProjectMap() {
             }
         }
     }
-    catch {
-        // Ignore parse errors
-    }
+    catch { /* projects.json missing or malformed */ }
     // Also check ~/.gemini/history/*/.project_root for additional mappings
     const historyDir = path.join(HOME, '.gemini', 'history');
     if (fs.existsSync(historyDir)) {
@@ -524,15 +535,11 @@ function buildGeminiProjectMap() {
                             map.set(hash, { name, path: projectPath });
                         }
                     }
-                    catch {
-                        // Skip
-                    }
+                    catch { /* history entry unreadable */ }
                 }
             }
         }
-        catch {
-            // Skip
-        }
+        catch { /* history entry unreadable */ }
     }
     return map;
 }
@@ -554,7 +561,7 @@ function getOpenCodeAccount() {
             }
         }
     }
-    catch { }
+    catch { /* sqlite3 unavailable or DB locked */ }
     cachedOpenCodeAccount = '';
     return undefined;
 }
@@ -563,8 +570,8 @@ async function discoverOpenCodeSessions() {
         return [];
     const account = getOpenCodeAccount();
     try {
-        // Query sessions joined with first user message for topic.
-        // time_created is millisecond epoch. Limit to 200 most recent.
+        // Query sessions. time_created is millisecond epoch. Limit to 200 most recent.
+        // Use session.title as topic (OpenCode auto-generates good titles).
         const query = `
       SELECT
         s.id,
@@ -572,41 +579,43 @@ async function discoverOpenCodeSessions() {
         s.directory,
         s.version,
         s.time_created,
-        s.parent_id,
-        (SELECT substr(p.data, 1, 300)
-         FROM message m
-         JOIN part p ON p.message_id = m.id AND p.session_id = m.session_id
-         WHERE m.session_id = s.id
-           AND json_extract(m.data, '$.role') = 'user'
-           AND json_extract(p.data, '$.type') = 'text'
-         ORDER BY m.time_created ASC
-         LIMIT 1) AS first_user_text
+        COALESCE(stats.message_count, 0),
+        stats.token_count,
+        COALESCE(stats.has_token_data, 0)
       FROM session s
+      LEFT JOIN (
+        SELECT
+          session_id,
+          COUNT(*) AS message_count,
+          SUM(
+            COALESCE(json_extract(data, '$.tokens.input'), 0) +
+            COALESCE(json_extract(data, '$.tokens.output'), 0) +
+            COALESCE(json_extract(data, '$.tokens.reasoning'), 0) +
+            COALESCE(json_extract(data, '$.tokens.cache.read'), 0) +
+            COALESCE(json_extract(data, '$.tokens.cache.write'), 0)
+          ) AS token_count,
+          MAX(CASE WHEN json_type(data, '$.tokens') IS NOT NULL THEN 1 ELSE 0 END) AS has_token_data
+        FROM message
+        GROUP BY session_id
+      ) stats ON stats.session_id = s.id
       WHERE s.parent_id IS NULL
-      ORDER BY s.time_created DESC
+      ORDER BY time_created DESC
       LIMIT 200;
     `.replace(/\n/g, ' ');
-        const out = execSync(`sqlite3 -separator '|||' "${OPENCODE_DB}" "${query}"`, { encoding: 'utf-8', stdio: ['ignore', 'pipe', 'ignore'], timeout: 5000 });
+        const out = execSync(`sqlite3 -separator '|||' "${OPENCODE_DB}"`, { encoding: 'utf-8', input: query, stdio: ['pipe', 'pipe', 'ignore'], timeout: 5000 });
         const sessions = [];
         for (const line of out.split('\n')) {
             if (!line.trim())
                 continue;
-            const [id, title, directory, version, timeCreatedStr, _parentId, firstUserText] = line.split('|||');
+            const [id, title, directory, version, timeCreatedStr, messageCountStr, tokenCountStr, hasTokenDataStr] = line.split('|||');
             if (!id)
                 continue;
             const timeCreated = parseInt(timeCreatedStr, 10);
+            const messageCount = parseInt(messageCountStr, 10);
+            const tokenCount = parseInt(tokenCountStr, 10);
+            const hasTokenData = hasTokenDataStr === '1';
             const timestamp = isNaN(timeCreated) ? new Date().toISOString() : new Date(timeCreated).toISOString();
-            // Extract topic from the part data JSON or fall back to session title
-            let topic = title || undefined;
-            if (firstUserText) {
-                try {
-                    const partData = JSON.parse(firstUserText);
-                    if (partData.text) {
-                        topic = extractTopic(partData.text);
-                    }
-                }
-                catch { }
-            }
+            const topic = title || undefined;
             sessions.push({
                 id,
                 shortId: id.replace(/^ses_/, '').slice(0, 8),
@@ -618,11 +627,16 @@ async function discoverOpenCodeSessions() {
                 version: version || undefined,
                 account,
                 topic,
+                messageCount: Number.isNaN(messageCount) ? undefined : messageCount,
+                tokenCount: hasTokenData && !Number.isNaN(tokenCount) ? tokenCount : undefined,
             });
         }
         return sessions;
     }
-    catch {
+    catch (err) {
+        if (process.stderr.isTTY) {
+            console.error(`Warning: Could not query OpenCode sessions: ${err.message}`);
+        }
         return [];
     }
 }
@@ -711,10 +725,146 @@ async function discoverOpenClawSessions() {
     }
     return sessions;
 }
+async function scanClaudeSession(filePath) {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let timestamp;
+    let cwd;
+    let gitBranch;
+    let version;
+    let topic;
+    let messageCount = 0;
+    let tokenCount = 0;
+    let sawTokenCount = false;
+    const seenAssistantIds = new Set();
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (!timestamp && (parsed.type === 'user' || parsed.type === 'assistant') && parsed.timestamp) {
+                timestamp = parsed.timestamp;
+                cwd = parsed.cwd || '';
+                gitBranch = parsed.gitBranch || undefined;
+                version = parsed.version || undefined;
+            }
+            if (parsed.type === 'user') {
+                const text = extractClaudeUserText(parsed);
+                if (text) {
+                    messageCount++;
+                    if (!topic)
+                        topic = extractSessionTopic(text);
+                }
+                continue;
+            }
+            if (parsed.type !== 'assistant')
+                continue;
+            const assistantId = typeof parsed.message?.id === 'string'
+                ? parsed.message.id
+                : typeof parsed.uuid === 'string'
+                    ? parsed.uuid
+                    : undefined;
+            const logicalId = assistantId || `${parsed.timestamp || ''}:${seenAssistantIds.size}`;
+            if (seenAssistantIds.has(logicalId))
+                continue;
+            seenAssistantIds.add(logicalId);
+            messageCount++;
+            const usage = getClaudeUsageTotal(parsed.message?.usage || parsed.usage);
+            if (usage !== null) {
+                tokenCount += usage;
+                sawTokenCount = true;
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return {
+        timestamp,
+        cwd,
+        gitBranch,
+        version,
+        topic,
+        messageCount,
+        tokenCount: sawTokenCount ? tokenCount : undefined,
+    };
+}
+async function scanCodexSession(filePath) {
+    const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
+    const rl = readline.createInterface({ input: stream, crlfDelay: Infinity });
+    let sessionId;
+    let timestamp;
+    let cwd;
+    let gitBranch;
+    let version;
+    let topic;
+    let messageCount = 0;
+    let tokenCount;
+    try {
+        for await (const line of rl) {
+            if (!line.trim())
+                continue;
+            let parsed;
+            try {
+                parsed = JSON.parse(line);
+            }
+            catch {
+                continue;
+            }
+            if (parsed.type === 'session_meta') {
+                const payload = parsed.payload || {};
+                sessionId = payload.id || sessionId;
+                timestamp = payload.timestamp || parsed.timestamp || timestamp;
+                cwd = payload.cwd || cwd;
+                gitBranch = payload.git?.branch || gitBranch;
+                version = payload.version || version;
+                continue;
+            }
+            if (parsed.type === 'response_item' && parsed.payload?.type === 'message') {
+                const role = parsed.payload.role === 'user' || parsed.payload.role === 'developer'
+                    ? 'user'
+                    : 'assistant';
+                const text = extractCodexMessageText(parsed.payload.content, role);
+                if (!text)
+                    continue;
+                messageCount++;
+                if (role === 'user' && !topic)
+                    topic = extractSessionTopic(text);
+                continue;
+            }
+            if (parsed.type === 'event_msg' && parsed.payload?.type === 'token_count') {
+                const total = getCodexTokenCount(parsed.payload.info?.total_token_usage);
+                if (total !== null)
+                    tokenCount = total;
+            }
+        }
+    }
+    finally {
+        rl.close();
+        stream.destroy();
+    }
+    return {
+        sessionId,
+        timestamp,
+        cwd,
+        gitBranch,
+        version,
+        topic,
+        messageCount,
+        tokenCount,
+    };
+}
 // ---------------------------------------------------------------------------
 // Utilities
 // ---------------------------------------------------------------------------
-function readFirstLines(filePath, maxLines) {
+export function readFirstLines(filePath, maxLines) {
     return new Promise((resolve) => {
         const lines = [];
         const stream = fs.createReadStream(filePath, { encoding: 'utf-8' });
@@ -736,7 +886,7 @@ function readFirstLines(filePath, maxLines) {
  * Walk a directory recursively for files with a given extension.
  * Returns at most `limit` files, sorted by mtime descending.
  */
-function walkForFiles(dir, ext, limit) {
+export function walkForFiles(dir, ext, limit) {
     const results = [];
     function walk(d, depth) {
         if (depth > 5)
@@ -766,11 +916,6 @@ function walkForFiles(dir, ext, limit) {
     results.sort((a, b) => b.mtime - a.mtime);
     return results.slice(0, limit).map(r => r.path);
 }
-function extractJsonField(text, field) {
-    const re = new RegExp(`"${field}"\\s*:\\s*"([^"]*)"`, 'i');
-    const match = text.match(re);
-    return match ? match[1] : '';
-}
 function sha256(input) {
     return crypto.createHash('sha256').update(input).digest('hex');
 }
@@ -790,11 +935,104 @@ function safeRealpathSync(p) {
         return null;
     }
 }
-function extractTopic(text) {
-    // Strip leading whitespace, slash commands, and system tags
-    let clean = text.replace(/^[\s\n]+/, '').replace(/<[^>]+>/g, '').trim();
-    // Take first line only
-    const firstLine = clean.split('\n')[0].trim();
-    return firstLine;
+function extractClaudeUserText(parsed) {
+    if (parsed.isMeta === true)
+        return undefined;
+    const content = parsed.message?.content;
+    if (typeof content === 'string') {
+        const text = content.trim();
+        return isLocalCommandMessage(text) ? undefined : text || undefined;
+    }
+    if (!Array.isArray(content))
+        return undefined;
+    const text = content
+        .filter((block) => block.type === 'text')
+        .map((block) => String(block.text || '').trim())
+        .find((value) => value && !value.startsWith('[Request interrupted'));
+    if (!text || isLocalCommandMessage(text))
+        return undefined;
+    return text;
+}
+function isLocalCommandMessage(text) {
+    return /<local-command-caveat>|<bash-(input|stdout|stderr)>/i.test(text);
+}
+function getClaudeUsageTotal(usage) {
+    if (!usage || typeof usage !== 'object')
+        return null;
+    return sumKnownNumbers([
+        usage.input_tokens,
+        usage.output_tokens,
+        usage.cache_creation_input_tokens,
+        usage.cache_read_input_tokens,
+    ]);
+}
+function extractCodexMessageText(contentBlocks, role) {
+    if (!Array.isArray(contentBlocks))
+        return undefined;
+    const matches = role === 'user'
+        ? contentBlocks.filter((block) => block.type === 'input_text')
+        : contentBlocks.filter((block) => block.type === 'output_text');
+    const text = matches
+        .map((block) => String(block.text || '').trim())
+        .find((value) => {
+        if (!value)
+            return false;
+        if (role === 'user' && (value.length >= 2000 || value.includes('<permissions instructions>') || value.startsWith('# AGENTS.md instructions'))) {
+            return false;
+        }
+        return true;
+    });
+    return text || undefined;
+}
+function getCodexTokenCount(totalTokenUsage) {
+    if (!totalTokenUsage || typeof totalTokenUsage !== 'object')
+        return null;
+    return sumKnownNumbers([
+        totalTokenUsage.input_tokens,
+        totalTokenUsage.cached_input_tokens,
+        totalTokenUsage.output_tokens,
+        totalTokenUsage.reasoning_output_tokens,
+    ]);
+}
+function extractGeminiMessageText(content) {
+    if (typeof content === 'string')
+        return content.trim();
+    if (Array.isArray(content)) {
+        return content
+            .map((part) => {
+            if (typeof part === 'string')
+                return part;
+            if (typeof part?.text === 'string')
+                return part.text;
+            return '';
+        })
+            .join('\n')
+            .trim();
+    }
+    return '';
+}
+function getGeminiTokenCount(tokens) {
+    if (!tokens || typeof tokens !== 'object')
+        return null;
+    if (typeof tokens.total === 'number')
+        return tokens.total;
+    return sumKnownNumbers([
+        tokens.input,
+        tokens.output,
+        tokens.cached,
+        tokens.thoughts,
+        tokens.tool,
+    ]);
+}
+function sumKnownNumbers(values) {
+    let total = 0;
+    let found = false;
+    for (const value of values) {
+        if (typeof value !== 'number' || Number.isNaN(value))
+            continue;
+        total += value;
+        found = true;
+    }
+    return found ? total : null;
 }
 //# sourceMappingURL=discover.js.map