osborn 0.5.2 → 0.5.5

package/dist/session-access.d.ts

@@ -259,6 +259,30 @@ export interface SessionTranscripts {
  * @param opts.claudeDir - Override the claude directory path
  */
 export declare function getSessionPaths(sessionId: string, projectDir: string, opts?: SessionAccessOptions): SessionPaths;
+export interface SubAgentInfo {
+    agentId: string;
+    description: string;
+    status: string;
+    agentFile: string;
+    agentFileExists: boolean;
+    totalTokens: number;
+    totalToolUseCount: number;
+    durationMs: number;
+}
+/**
+ * Find all sub-agents spawned by a session.
+ * Extracts agentId from toolUseResult fields in the main JSONL,
+ * then checks for corresponding agent-{id}.jsonl files at the project level.
+ *
+ * Sub-agent files live at: ~/.claude/projects/{slug}/agent-{id}.jsonl
+ * (NOT inside the session subdirectory — that's only for the Osborn agent SDK path)
+ */
+export declare function getSessionSubAgents(sessionId: string, projectDir: string, opts?: SessionAccessOptions): SubAgentInfo[];
+/**
+ * Get all searchable file paths for a session — main JSONL + all sub-agent JSOLs.
+ * This is what the pipeline fast brain should ripgrep across.
+ */
+export declare function getSessionSearchPaths(sessionId: string, projectDir: string, opts?: SessionAccessOptions): string[];
 /**
  * Read raw JSON objects from a JSONL file — no parsing into SessionMessage.
  * Returns the actual JSON as-is so you can inspect the full object shapes.
@@ -318,9 +342,12 @@ export declare function getSessionPlan(sessionId: string, projectDir: string, op
  * Get recent tool use/result pairs from a session.
  * Returns matched pairs of (tool_use → tool_result) in chronological order.
  *
- * @param lastN - Number of recent pairs to return (default: 10)
+ * @param lastN - Number of recent pairs to return (default: 10, 0 = all)
+ * @param opts.toolNameFilter - Optional: only return results from these tool names (e.g., ['Read', 'WebSearch'])
  */
-export declare function getRecentToolResults(sessionId: string, projectDir: string, lastN?: number, opts?: SessionAccessOptions): ToolResultEntry[];
+export declare function getRecentToolResults(sessionId: string, projectDir: string, lastN?: number, opts?: SessionAccessOptions & {
+    toolNameFilter?: string[];
+}): ToolResultEntry[];
 /**
  * Watch a session JSONL file for new entries.
  * Calls back with each new parsed entry as it's appended.
@@ -347,6 +374,37 @@ export declare function getConversationText(sessionId: string, projectDir: strin
     role: string;
     text: string;
 }[];
+/**
+ * Search the session JSONL for entries matching a keyword (case-insensitive).
+ * Searches across text, toolResultContent, toolName, and toolInput.
+ * Returns matching entries with 500-char excerpts around the match.
+ *
+ * @param keyword - The search keyword (case-insensitive)
+ * @param opts.maxResults - Maximum number of results to return (default: 20)
+ */
+export declare function searchSessionJsonl(sessionId: string, projectDir: string, keyword: string, opts?: SessionAccessOptions & {
+    maxResults?: number;
+}): {
+    type: string;
+    text: string;
+    timestamp?: string;
+}[];
+/**
+ * Get session stats: message counts, tool usage breakdown, data sizes.
+ * Helps the fast brain decide how much data to read and which tools to query.
+ */
+export declare function getSessionStats(sessionId: string, projectDir: string, opts?: SessionAccessOptions): {
+    totalMessages: number;
+    userMessages: number;
+    assistantMessages: number;
+    toolUseCount: number;
+    toolResultCount: number;
+    toolBreakdown: Record<string, number>;
+    subagentCount: number;
+    fileSizeBytes: number;
+    firstTimestamp?: string;
+    lastTimestamp?: string;
+} | null;
 /**
  * Get a quick summary of a session: slug, message count, timestamps, tools used.
  */

package/dist/session-access.js

@@ -228,6 +228,80 @@ export function getSessionPaths(sessionId, projectDir, opts) {
         exists: existsSync(conversationPath),
     };
 }
+/**
+ * Find all sub-agents spawned by a session.
+ * Extracts agentId from toolUseResult fields in the main JSONL,
+ * then checks for corresponding agent-{id}.jsonl files at the project level.
+ *
+ * Sub-agent files live at: ~/.claude/projects/{slug}/agent-{id}.jsonl
+ * (NOT inside the session subdirectory — that's only for the Osborn agent SDK path)
+ */
+export function getSessionSubAgents(sessionId, projectDir, opts) {
+    const claudeDir = resolveClaudeDir(opts);
+    const slug = projectPathToSlug(projectDir);
+    const projectsDir = join(claudeDir, 'projects', slug);
+    const conversationPath = join(projectsDir, `${sessionId}.jsonl`);
+    if (!existsSync(conversationPath))
+        return [];
+    const agents = [];
+    const seenIds = new Set();
+    try {
+        const content = readFileSync(conversationPath, 'utf-8');
+        for (const line of content.split('\n')) {
+            if (!line.trim())
+                continue;
+            try {
+                const obj = JSON.parse(line);
+                const tur = obj.toolUseResult;
+                if (tur && typeof tur === 'object' && tur.agentId) {
+                    const id = tur.agentId;
+                    if (seenIds.has(id))
+                        continue;
+                    seenIds.add(id);
+                    const agentFile = join(projectsDir, `agent-${id}.jsonl`);
+                    agents.push({
+                        agentId: id,
+                        description: (tur.prompt || '').substring(0, 200),
+                        status: tur.status || '',
+                        agentFile,
+                        agentFileExists: existsSync(agentFile),
+                        totalTokens: tur.totalTokens || 0,
+                        totalToolUseCount: tur.totalToolUseCount || 0,
+                        durationMs: tur.totalDurationMs || 0,
+                    });
+                }
+            }
+            catch { }
+        }
+    }
+    catch { }
+    return agents;
+}
+/**
+ * Get all searchable file paths for a session — main JSONL + all sub-agent JSOLs.
+ * This is what the pipeline fast brain should ripgrep across.
+ */
+export function getSessionSearchPaths(sessionId, projectDir, opts) {
+    const paths = getSessionPaths(sessionId, projectDir, opts);
+    const files = [];
+    // Main conversation
+    if (existsSync(paths.conversation)) {
+        files.push(paths.conversation);
+    }
+    // Sub-agents from session subdirectory (Osborn agent SDK path)
+    for (const f of paths.subagents) {
+        if (existsSync(f))
+            files.push(f);
+    }
+    // Sub-agents at project level (Claude Code CLI path)
+    const agents = getSessionSubAgents(sessionId, projectDir, opts);
+    for (const a of agents) {
+        if (a.agentFileExists && !files.includes(a.agentFile)) {
+            files.push(a.agentFile);
+        }
+    }
+    return files;
+}
 // ============================================================
 // JSONL PARSING
 // ============================================================
@@ -530,13 +604,15 @@ export function getSessionPlan(sessionId, projectDir, opts) {
  * Get recent tool use/result pairs from a session.
  * Returns matched pairs of (tool_use → tool_result) in chronological order.
  *
- * @param lastN - Number of recent pairs to return (default: 10)
+ * @param lastN - Number of recent pairs to return (default: 10, 0 = all)
+ * @param opts.toolNameFilter - Optional: only return results from these tool names (e.g., ['Read', 'WebSearch'])
  */
 export function getRecentToolResults(sessionId, projectDir, lastN = 10, opts) {
     const messages = readSessionHistory(sessionId, projectDir, { claudeDir: opts?.claudeDir });
     // Build a map of tool_use by tool ID
     const toolUseMap = new Map();
     const results = [];
+    const toolFilter = opts?.toolNameFilter?.map(t => t.toLowerCase());
     for (const msg of messages) {
         if (msg.type === 'tool_use' && msg.toolId) {
             toolUseMap.set(msg.toolId, msg);
@@ -544,6 +620,10 @@ export function getRecentToolResults(sessionId, projectDir, lastN = 10, opts) {
         if (msg.type === 'tool_result' && msg.toolUseId) {
             const toolUse = toolUseMap.get(msg.toolUseId);
             if (toolUse) {
+                // Apply tool name filter if provided
+                if (toolFilter && !toolFilter.includes(toolUse.toolName.toLowerCase())) {
+                    continue;
+                }
                 results.push({
                     toolName: toolUse.toolName,
                     toolId: toolUse.toolId,
@@ -555,7 +635,7 @@ export function getRecentToolResults(sessionId, projectDir, lastN = 10, opts) {
             }
         }
     }
-    return results.slice(-lastN);
+    return lastN > 0 ? results.slice(-lastN) : results;
 }
 /**
  * Watch a session JSONL file for new entries.
@@ -648,6 +728,96 @@ export function getConversationText(sessionId, projectDir, lastN = 30, maxCharsP
     }));
     return exchanges.slice(-lastN);
 }
+/**
+ * Search the session JSONL for entries matching a keyword (case-insensitive).
+ * Searches across text, toolResultContent, toolName, and toolInput.
+ * Returns matching entries with 500-char excerpts around the match.
+ *
+ * @param keyword - The search keyword (case-insensitive)
+ * @param opts.maxResults - Maximum number of results to return (default: 20)
+ */
+export function searchSessionJsonl(sessionId, projectDir, keyword, opts) {
+    const messages = readSessionHistory(sessionId, projectDir, { claudeDir: opts?.claudeDir });
+    const maxResults = opts?.maxResults || 20;
+    const results = [];
+    const lowerKeyword = keyword.toLowerCase();
+    for (const msg of messages) {
+        if (results.length >= maxResults)
+            break;
+        // Search in text content
+        if (msg.text && msg.text.toLowerCase().includes(lowerKeyword)) {
+            const idx = msg.text.toLowerCase().indexOf(lowerKeyword);
+            const start = Math.max(0, idx - 100);
+            const end = Math.min(msg.text.length, idx + keyword.length + 400);
+            const excerpt = (start > 0 ? '...' : '') + msg.text.substring(start, end) + (end < msg.text.length ? '...' : '');
+            results.push({ type: msg.type, text: excerpt, timestamp: msg.timestamp });
+            continue;
+        }
+        // Search in tool result content
+        if (msg.toolResultContent && msg.toolResultContent.toLowerCase().includes(lowerKeyword)) {
+            const idx = msg.toolResultContent.toLowerCase().indexOf(lowerKeyword);
+            const start = Math.max(0, idx - 100);
+            const end = Math.min(msg.toolResultContent.length, idx + keyword.length + 400);
+            const excerpt = `[tool_result] ` + (start > 0 ? '...' : '') + msg.toolResultContent.substring(start, end) + (end < msg.toolResultContent.length ? '...' : '');
+            results.push({ type: msg.type, text: excerpt, timestamp: msg.timestamp });
+            continue;
+        }
+        // Search in tool name
+        if (msg.toolName && msg.toolName.toLowerCase().includes(lowerKeyword)) {
+            const inputPreview = msg.toolInput ? JSON.stringify(msg.toolInput).substring(0, 200) : '';
+            results.push({ type: msg.type, text: `[${msg.toolName}: ${inputPreview}]`, timestamp: msg.timestamp });
+            continue;
+        }
+        // Search in tool input
+        if (msg.toolInput) {
+            const inputStr = JSON.stringify(msg.toolInput);
+            if (inputStr.toLowerCase().includes(lowerKeyword)) {
+                results.push({ type: msg.type, text: `[${msg.toolName || 'tool'}: ${inputStr.substring(0, 500)}]`, timestamp: msg.timestamp });
+            }
+        }
+    }
+    return results;
+}
+/**
+ * Get session stats: message counts, tool usage breakdown, data sizes.
+ * Helps the fast brain decide how much data to read and which tools to query.
+ */
+export function getSessionStats(sessionId, projectDir, opts) {
+    const paths = getSessionPaths(sessionId, projectDir, opts);
+    if (!paths.exists)
+        return null;
+    const messages = readJsonl(paths.conversation);
+    const toolBreakdown = {};
+    let userMessages = 0;
+    let assistantMessages = 0;
+    let toolUseCount = 0;
+    let toolResultCount = 0;
+    for (const msg of messages) {
+        if (msg.type === 'user')
+            userMessages++;
+        else if (msg.type === 'assistant')
+            assistantMessages++;
+        else if (msg.type === 'tool_use') {
+            toolUseCount++;
+            const name = msg.toolName || 'unknown';
+            toolBreakdown[name] = (toolBreakdown[name] || 0) + 1;
+        }
+        else if (msg.type === 'tool_result')
+            toolResultCount++;
+    }
+    return {
+        totalMessages: messages.length,
+        userMessages,
+        assistantMessages,
+        toolUseCount,
+        toolResultCount,
+        toolBreakdown,
+        subagentCount: paths.subagents.length,
+        fileSizeBytes: existsSync(paths.conversation) ? statSync(paths.conversation).size : 0,
+        firstTimestamp: messages.find(m => m.timestamp)?.timestamp,
+        lastTimestamp: [...messages].reverse().find(m => m.timestamp)?.timestamp,
+    };
+}
 /**
  * Get a quick summary of a session: slug, message count, timestamps, tools used.
  */

package/dist/summary-index.d.ts

@@ -0,0 +1,87 @@
+/**
+ * summary-index.ts — Builds a compact searchable summary of Claude JSONL sessions
+ *
+ * Instead of ripgrepping 80MB raw JSONL, we extract one-line summaries per message
+ * into a ~1MB plain text file. Ripgrep searches this in <5ms.
+ *
+ * Format: {lineNum}|{timestamp}|{source}|{msgType}|{summary}
+ *
+ * No LLM calls — pure heuristic extraction:
+ *   tool_use  → tool name + key params (file path, command, query)
+ *   tool_result → tool name + first 80 chars of output
+ *   user → raw text (already short from voice)
+ *   assistant → first 500 chars of text
+ *
+ * Per-session index stored at: .osborn/sessions/{sessionId}/.index/search-index.txt
+ */
+export interface IndexEntry {
+    lineNum: number;
+    byteOffset: number;
+    timestamp: string;
+    source: string;
+    msgType: string;
+    summary: string;
+}
+export interface SummaryIndexState {
+    indexPath: string;
+    metaPath: string;
+    main: {
+        jsonlPath: string;
+        byteOffset: number;
+        lineCount: number;
+        indexLineCount: number;
+    };
+    subAgents: Map<string, {
+        jsonlPath: string;
+        byteOffset: number;
+        lineCount: number;
+        indexLineCount: number;
+    }>;
+    toolUseIdMap: Map<string, string>;
+}
+export interface SummaryIndexMeta {
+    version: 1;
+    sessionId: string;
+    createdAt: string;
+    updatedAt: string;
+    main: {
+        jsonlPath: string;
+        byteOffset: number;
+        lineCount: number;
+        indexLineCount: number;
+    };
+    subAgents: Record<string, {
+        jsonlPath: string;
+        byteOffset: number;
+        lineCount: number;
+        indexLineCount: number;
+    }>;
+    toolUseIdMap: Record<string, string>;
+}
+export interface IndexWatcher {
+    stop(): void;
+    state: SummaryIndexState;
+}
+/**
+ * Build or resume a summary index for a session.
+ * Reads main JSONL + all sub-agent JSONLs, extracts summaries.
+ * If an existing index with metadata exists, resumes from last byte offset.
+ */
+export declare function buildSummaryIndex(sessionId: string, workingDir: string, sessionBaseDir: string, onProgress?: (msg: string) => void): SummaryIndexState;
+/**
+ * Poll-based incremental index updater (10s interval).
+ * Checks main JSONL + sub-agents for new content, indexes in one batch.
+ * No fs.watch — avoids race conditions with concurrent writers.
+ */
+export declare function startIndexWatcher(sessionId: string, workingDir: string, sessionBaseDir: string, state: SummaryIndexState): IndexWatcher;
+export declare function getIndexPath(sessionId: string, sessionBaseDir: string): string | null;
+/**
+ * Given index search results (with byte offsets + source tags),
+ * read FULL content from raw JSONL via targeted reads — 0.5ms per result.
+ * No readFileSync of the whole file. Strips JSON noise, returns clean text.
+ */
+export declare function readFullContent(results: {
+    lineNum: number;
+    byteOffset: number;
+    source: string;
+}[], sessionId: string, workingDir: string, sessionBaseDir: string, maxCharsPerResult?: number): string[];