lattice-orchestrator 0.7.0

package/dist/services/sessions/claude-history-reader.js

@@ -0,0 +1,864 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { LatticeError } from '../../types/index.js';
+import { createLogger } from '../infrastructure/logger.js';
+import { SessionInfoService } from '../sessions/session-info-service.js';
+import { ConversationCache } from '../sessions/conversation-cache.js';
+import { ToolMetricsService } from '../ToolMetricsService.js';
+import { MessageFilter } from '../message-filter.js';
+/**
+ * Reads conversation history from Claude's local storage
+ */
+export class ClaudeHistoryReader {
+    claudeHomePath;
+    logger;
+    sessionInfoService;
+    conversationCache;
+    toolMetricsService;
+    messageFilter;
+    constructor(sessionInfoService) {
+        this.claudeHomePath = path.join(os.homedir(), '.claude');
+        this.logger = createLogger('ClaudeHistoryReader');
+        this.sessionInfoService = sessionInfoService || SessionInfoService.getInstance();
+        this.conversationCache = new ConversationCache();
+        this.toolMetricsService = new ToolMetricsService();
+        this.messageFilter = new MessageFilter();
+    }
+    get homePath() {
+        return this.claudeHomePath;
+    }
+    /**
+     * Clear the conversation cache to force a refresh on next read
+     */
+    clearCache() {
+        this.conversationCache.clear();
+    }
+    /**
+     * List all conversations with optional filtering
+     */
+    async listConversations(filter) {
+        const timings = {};
+        const startTime = Date.now();
+        try {
+            // FAST PATH: For archived=true queries, use DB-only path (avoids parsing JSONL files)
+            // This is critical for performance - archived sessions can number in the thousands
+            if (filter?.archived === true && filter?.pinned === undefined) {
+                return this.listArchivedConversationsFast(filter, timings, startTime);
+            }
+            // SLOW PATH: Parse JSONL files for non-archived or mixed queries
+            // Fetch ALL session info first - needed to filter before expensive parsing
+            const sessionInfoStart = Date.now();
+            const allSessionInfo = await this.sessionInfoService.getAllSessionInfo();
+            timings.getAllSessionInfo = Date.now() - sessionInfoStart;
+            // Fetch ALL insights - needed for cached tool metrics (Phase 1 optimization)
+            const insightsStart = Date.now();
+            const allInsights = await this.sessionInfoService.getAllInsights();
+            timings.getAllInsights = Date.now() - insightsStart;
+            // Pre-filter session IDs based on archived/pinned filters to avoid parsing unwanted files
+            let allowedSessionIds = null;
+            if (filter?.archived !== undefined || filter?.pinned !== undefined) {
+                allowedSessionIds = new Set();
+                for (const [sessionId, info] of Object.entries(allSessionInfo)) {
+                    // Apply archive filter
+                    if (filter.archived !== undefined && info.archived !== filter.archived) {
+                        continue;
+                    }
+                    // Apply pinned filter
+                    if (filter.pinned !== undefined && info.pinned !== filter.pinned) {
+                        continue;
+                    }
+                    allowedSessionIds.add(sessionId);
+                }
+            }
+            // Parse conversations (optionally filtered by sessionId)
+            const parseStart = Date.now();
+            const conversationChains = await this.parseAllConversations(allowedSessionIds);
+            timings.parseAllConversations = Date.now() - parseStart;
+            // Track sessions that need metrics backfilled (fire-and-forget after response)
+            const metricsToBackfill = [];
+            // Convert to ConversationSummary format and enhance with custom names
+            const allConversations = conversationChains.map((chain) => {
+                // Use bulk-fetched session info (O(1) lookup instead of async query)
+                // Default to archived: true to match syncMissingSessions behavior -
+                // sessions discovered outside Claudia start archived
+                const sessionInfo = allSessionInfo[chain.sessionId] || {
+                    custom_name: '',
+                    created_at: new Date().toISOString(),
+                    updated_at: new Date().toISOString(),
+                    version: 4,
+                    pinned: false,
+                    archived: true,
+                    continuation_session_id: '',
+                    initial_commit_head: '',
+                    permission_mode: 'default'
+                };
+                // Use cached tool metrics if available (Phase 1 optimization)
+                const cachedInsights = allInsights.get(chain.sessionId);
+                let toolMetrics;
+                if (cachedInsights?.metrics_updated_at) {
+                    // Use cached metrics - fast path
+                    toolMetrics = {
+                        linesAdded: cachedInsights.lines_added || 0,
+                        linesRemoved: cachedInsights.lines_removed || 0,
+                        editCount: cachedInsights.edit_count || 0,
+                        writeCount: cachedInsights.write_count || 0
+                    };
+                }
+                else {
+                    // Calculate metrics and queue for backfill - slow path (only on first access)
+                    toolMetrics = this.toolMetricsService.calculateMetricsFromMessages(chain.messages);
+                    metricsToBackfill.push({ sessionId: chain.sessionId, metrics: toolMetrics, messageCount: chain.messages.length });
+                }
+                return {
+                    sessionId: chain.sessionId,
+                    projectPath: chain.projectPath,
+                    summary: chain.summary,
+                    sessionInfo: sessionInfo,
+                    createdAt: chain.createdAt,
+                    updatedAt: chain.updatedAt,
+                    messageCount: chain.messages.length,
+                    totalDuration: chain.totalDuration,
+                    model: chain.model,
+                    status: 'completed', // Default status, will be updated by server
+                    toolMetrics: toolMetrics
+                };
+            });
+            // Backfill metrics in background (don't block response)
+            if (metricsToBackfill.length > 0) {
+                this.logger.info('Backfilling tool metrics for sessions without cache', {
+                    count: metricsToBackfill.length
+                });
+                // Fire and forget - update DB in background
+                Promise.all(metricsToBackfill.map(({ sessionId, metrics, messageCount }) => this.sessionInfoService.updateToolMetrics(sessionId, metrics, messageCount).catch(() => { }))).catch(() => { });
+            }
+            // Apply filters and pagination
+            const filterStart = Date.now();
+            const filtered = this.applyFilters(allConversations, filter);
+            const paginated = this.applyPagination(filtered, filter);
+            timings.filterAndPaginate = Date.now() - filterStart;
+            timings.total = Date.now() - startTime;
+            this.logger.debug('listConversations breakdown', {
+                timingsMs: timings,
+                sessionInfoCount: Object.keys(allSessionInfo).length,
+                insightsCount: allInsights.size,
+                conversationChainsCount: conversationChains.length,
+                filteredCount: filtered.length,
+                paginatedCount: paginated.length,
+                allowedSessionIds: allowedSessionIds?.size ?? 'all',
+            });
+            return {
+                conversations: paginated,
+                total: filtered.length
+            };
+        }
+        catch (error) {
+            throw new LatticeError('HISTORY_READ_FAILED', `Failed to read conversation history: ${error}`, 500);
+        }
+    }
+    /**
+     * Fast path for listing archived sessions - queries DB directly without parsing JSONL files.
+     * This is ~100x faster than the file-parsing path for large archives.
+     */
+    async listArchivedConversationsFast(filter, timings, startTime) {
+        const dbStart = Date.now();
+        // Get total count for pagination
+        const total = this.sessionInfoService.getArchivedSessionCount();
+        // Get paginated archived sessions with insights from DB
+        const limit = filter.limit || 20;
+        const offset = filter.offset || 0;
+        const dbResults = this.sessionInfoService.getArchivedSessionsWithInsights(limit, offset);
+        timings.dbQuery = Date.now() - dbStart;
+        // Convert to ConversationSummary format
+        const conversations = dbResults.map(({ sessionId, sessionInfo, insights }) => {
+            // Build tool metrics from insights if available
+            const toolMetrics = insights?.metrics_updated_at ? {
+                linesAdded: insights.lines_added || 0,
+                linesRemoved: insights.lines_removed || 0,
+                editCount: insights.edit_count || 0,
+                writeCount: insights.write_count || 0
+            } : {
+                linesAdded: 0,
+                linesRemoved: 0,
+                editCount: 0,
+                writeCount: 0
+            };
+            return {
+                sessionId,
+                projectPath: '', // Not available without parsing JSONL - acceptable for archive view
+                summary: insights?.purpose || sessionInfo.custom_name || 'Archived session',
+                sessionInfo,
+                createdAt: sessionInfo.created_at,
+                updatedAt: sessionInfo.updated_at,
+                messageCount: insights?.message_count || 0,
+                totalDuration: 0, // Not available without parsing JSONL
+                model: 'Unknown', // Not available without parsing JSONL
+                status: 'completed',
+                toolMetrics
+            };
+        });
+        timings.total = Date.now() - startTime;
+        this.logger.debug('listArchivedConversationsFast', {
+            timingsMs: timings,
+            total,
+            returnedCount: conversations.length,
+            limit,
+            offset
+        });
+        return { conversations, total };
+    }
+    /**
+     * Get the file path for a session's JSONL file.
+     * Public wrapper around findSessionFile.
+     */
+    async getSessionFilePath(sessionId) {
+        return this.findSessionFile(sessionId);
+    }
+    /**
+     * Find the JSONL file for a session by checking each project folder
+     * Returns the file path if found, null otherwise
+     */
+    async findSessionFile(sessionId) {
+        const projectsPath = path.join(this.claudeHomePath, 'projects');
+        try {
+            const projects = await this.readDirectory(projectsPath);
+            for (const project of projects) {
+                const projectPath = path.join(projectsPath, project);
+                const stats = await fs.stat(projectPath);
+                if (!stats.isDirectory())
+                    continue;
+                const sessionFile = path.join(projectPath, `${sessionId}.jsonl`);
+                try {
+                    await fs.access(sessionFile);
+                    return sessionFile;
+                }
+                catch {
+                    // File doesn't exist in this project, continue searching
+                }
+            }
+            return null;
+        }
+        catch (error) {
+            this.logger.error('Error searching for session file', error, { sessionId });
+            return null;
+        }
+    }
+    /**
+     * Get file modification times for multiple sessions
+     * Used for lightweight activity detection without reading file contents
+     */
+    async getSessionFileMtimes(sessionIds) {
+        const results = new Map();
+        await Promise.all(sessionIds.map(async (sessionId) => {
+            const filePath = await this.findSessionFile(sessionId);
+            if (filePath) {
+                try {
+                    const stats = await fs.stat(filePath);
+                    results.set(sessionId, stats.mtimeMs);
+                }
+                catch {
+                    // File not accessible, skip
+                }
+            }
+        }));
+        return results;
+    }
+    /**
+     * Get sessions that are "recently active" based on file modification time.
+     * A session is considered active if its JSONL file was modified within the threshold.
+     * This is more reliable than fuser since Claude writes frequently during activity.
+     *
+     * @param sessionIds - Session IDs to check
+     * @param thresholdMs - How recent the mtime must be (default: 60 seconds)
+     * @returns Set of session IDs that are recently active
+     */
+    async getRecentlyActiveSessionsByMtime(sessionIds, thresholdMs = 60000) {
+        const activeSet = new Set();
+        const now = Date.now();
+        const projectsPath = path.join(this.claudeHomePath, 'projects');
+        // Build a Set for O(1) lookup
+        const sessionIdSet = new Set(sessionIds);
+        try {
+            // Get all project directories
+            const projects = await this.readDirectory(projectsPath);
+            // Check all JSONL files in parallel across all projects
+            await Promise.all(projects.map(async (project) => {
+                const projectDir = path.join(projectsPath, project);
+                try {
+                    const stats = await fs.stat(projectDir);
+                    if (!stats.isDirectory())
+                        return;
+                    const files = await this.readDirectory(projectDir);
+                    await Promise.all(files
+                        .filter(f => f.endsWith('.jsonl'))
+                        .map(async (file) => {
+                        const sessionId = file.replace('.jsonl', '');
+                        if (!sessionIdSet.has(sessionId))
+                            return;
+                        try {
+                            const filePath = path.join(projectDir, file);
+                            const fileStats = await fs.stat(filePath);
+                            const ageMs = now - fileStats.mtimeMs;
+                            if (ageMs < thresholdMs) {
+                                activeSet.add(sessionId);
+                                this.logger.debug('Session detected as active by mtime', {
+                                    sessionId: sessionId.slice(0, 8),
+                                    ageSeconds: Math.round(ageMs / 1000)
+                                });
+                            }
+                        }
+                        catch {
+                            // File not accessible, skip
+                        }
+                    }));
+                }
+                catch {
+                    // Project dir not accessible, skip
+                }
+            }));
+            return activeSet;
+        }
+        catch (error) {
+            this.logger.error('Error checking session mtimes', error);
+            return activeSet;
+        }
+    }
+    /**
+     * Fetch conversation with metadata in a single fast operation
+     * Uses direct file lookup instead of parsing all conversations
+     */
+    async fetchConversationDirect(sessionId) {
+        const startTime = Date.now();
+        try {
+            // Find the session file directly
+            const filePath = await this.findSessionFile(sessionId);
+            if (!filePath) {
+                throw new LatticeError('CONVERSATION_NOT_FOUND', `Conversation ${sessionId} not found`, 404);
+            }
+            // Parse just this one file
+            const entries = await this.parseJsonlFile(filePath);
+            // Extract project path from file path
+            const projectsPath = path.join(this.claudeHomePath, 'projects');
+            const relativePath = filePath.replace(projectsPath + path.sep, '');
+            const projectName = relativePath.split(path.sep)[0];
+            const projectPath = this.decodeProjectName(projectName);
+            // Get summary from global summaries.json
+            const summary = await this.getSummaryForSession(sessionId);
+            // Build conversation chain from entries
+            const summaryMap = new Map();
+            if (summary)
+                summaryMap.set(sessionId, summary);
+            const chain = this.buildConversationChain(sessionId, entries.map(e => ({ ...e, sourceProject: projectPath })), summaryMap);
+            if (!chain) {
+                throw new LatticeError('CONVERSATION_NOT_FOUND', `Failed to build conversation ${sessionId}`, 404);
+            }
+            const elapsed = Date.now() - startTime;
+            this.logger.debug('Direct conversation fetch completed', {
+                sessionId,
+                elapsedMs: elapsed,
+                messageCount: chain.messages.length
+            });
+            return {
+                messages: this.messageFilter.filterMessages(chain.messages),
+                metadata: {
+                    summary: chain.summary,
+                    projectPath: chain.projectPath,
+                    model: chain.model,
+                    totalDuration: chain.totalDuration
+                }
+            };
+        }
+        catch (error) {
+            if (error instanceof LatticeError)
+                throw error;
+            throw new LatticeError('CONVERSATION_READ_FAILED', `Failed to read conversation: ${error}`, 500);
+        }
+    }
+    /**
+     * Get summary for a session from summaries.json
+     */
+    async getSummaryForSession(sessionId) {
+        try {
+            const summariesPath = path.join(this.claudeHomePath, 'summaries.json');
+            const content = await fs.readFile(summariesPath, 'utf-8');
+            const summaries = JSON.parse(content);
+            return summaries[sessionId] || null;
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Decode project folder name to actual path
+     */
+    decodeProjectName(projectName) {
+        // Project folders use dashes instead of slashes
+        // e.g., "-home-jason-cui-custom" -> "/home/jason/cui-custom"
+        return projectName.replace(/^-/, '/').replace(/-/g, '/');
+    }
+    /**
+     * Get the working directory for a specific conversation session
+     * Reads the cwd from the session's JSONL file to get the accurate path
+     * (folder name decoding is lossy for paths containing hyphens)
+     */
+    async getConversationWorkingDirectory(sessionId) {
+        const startTime = Date.now();
+        try {
+            const filePath = await this.findSessionFile(sessionId);
+            if (!filePath) {
+                this.logger.warn('Session file not found', { sessionId });
+                return null;
+            }
+            // Read the first entry from the JSONL file to get the actual cwd
+            // This is more reliable than decoding the folder name, which is lossy
+            // (e.g., "slingshot-ai" folder becomes "slingshot/ai" when decoded)
+            const entries = await this.parseJsonlFile(filePath);
+            // Find the first entry with a cwd field
+            const entryWithCwd = entries.find(e => e.cwd);
+            if (entryWithCwd?.cwd) {
+                this.logger.debug('Found working directory from JSONL cwd field', {
+                    sessionId,
+                    workingDirectory: entryWithCwd.cwd,
+                    elapsedMs: Date.now() - startTime
+                });
+                return entryWithCwd.cwd;
+            }
+            // Fallback to folder name decoding if no cwd field found
+            // (older sessions may not have cwd in the JSONL)
+            const projectsPath = path.join(this.claudeHomePath, 'projects');
+            const relativePath = filePath.replace(projectsPath + path.sep, '');
+            const projectName = relativePath.split(path.sep)[0];
+            const projectPath = this.decodeProjectName(projectName);
+            this.logger.debug('Found working directory from folder name (fallback)', {
+                sessionId,
+                workingDirectory: projectPath,
+                elapsedMs: Date.now() - startTime
+            });
+            return projectPath;
+        }
+        catch (error) {
+            this.logger.error('Error getting working directory for conversation', error, { sessionId });
+            return null;
+        }
+    }
+    /**
+     * Get file modification times for JSONL files
+     * @param allowedSessionIds Optional filter - if provided, only stat files for these sessions
+     */
+    async getFileModificationTimes(allowedSessionIds) {
+        const modTimes = new Map();
+        const projectsPath = path.join(this.claudeHomePath, 'projects');
+        this.logger.debug('Getting file modification times', {
+            projectsPath,
+            filtered: !!allowedSessionIds,
+            allowedCount: allowedSessionIds?.size
+        });
+        try {
+            const projects = await this.readDirectory(projectsPath);
+            this.logger.debug('Found projects', { projectCount: projects.length });
+            for (const project of projects) {
+                const projectPath = path.join(projectsPath, project);
+                const stats = await fs.stat(projectPath);
+                if (!stats.isDirectory())
+                    continue;
+                const files = await this.readDirectory(projectPath);
+                const jsonlFiles = files.filter(f => f.endsWith('.jsonl'));
+                for (const file of jsonlFiles) {
+                    // Skip files not in allowed list (optimization: avoid stat calls)
+                    if (allowedSessionIds) {
+                        const sessionId = file.replace('.jsonl', '');
+                        if (!allowedSessionIds.has(sessionId))
+                            continue;
+                    }
+                    const filePath = path.join(projectPath, file);
+                    try {
+                        const fileStats = await fs.stat(filePath);
+                        modTimes.set(filePath, fileStats.mtimeMs);
+                    }
+                    catch (error) {
+                        this.logger.warn('Failed to stat file', { filePath, error });
+                    }
+                }
+            }
+            this.logger.debug('File modification times collection complete', {
+                totalFiles: modTimes.size,
+                projects: projects.length
+            });
+        }
+        catch (error) {
+            this.logger.error('Error getting file modification times', error);
+        }
+        return modTimes;
+    }
+    /**
+     * Extract source project name from file path
+     */
+    extractSourceProject(filePath) {
+        const projectsPath = path.join(this.claudeHomePath, 'projects');
+        const relativePath = path.relative(projectsPath, filePath);
+        const segments = relativePath.split(path.sep);
+        return segments[0]; // First segment is the project directory name
+    }
+    /**
+     * Process all entries into conversation chains (the cheap in-memory operations)
+     */
+    processAllEntries(allEntries) {
+        const startTime = Date.now();
+        this.logger.debug('Processing all entries into conversations', {
+            totalEntries: allEntries.length
+        });
+        // Group entries by sessionId
+        const sessionGroups = this.groupEntriesBySession(allEntries);
+        this.logger.debug('Entries grouped by session', {
+            sessionCount: sessionGroups.size,
+            totalEntries: allEntries.length
+        });
+        // Process summaries
+        const summaries = this.processSummaries(allEntries);
+        this.logger.debug('Summaries processed', {
+            summaryCount: summaries.size
+        });
+        // Build conversation chains
+        const conversationChains = [];
+        for (const [sessionId, entries] of sessionGroups) {
+            const chain = this.buildConversationChain(sessionId, entries, summaries);
+            if (chain) {
+                conversationChains.push(chain);
+            }
+        }
+        const totalElapsed = Date.now() - startTime;
+        this.logger.debug('Entry processing complete', {
+            conversationCount: conversationChains.length,
+            totalElapsedMs: totalElapsed,
+            avgTimePerConversation: conversationChains.length > 0 ? totalElapsed / conversationChains.length : 0
+        });
+        return conversationChains;
+    }
+    /**
+     * Parse all conversations from all JSONL files with file-level caching and concurrency protection
+     * @param allowedSessionIds Optional set of session IDs to parse. If provided, only these sessions will be parsed.
+     */
+    async parseAllConversations(allowedSessionIds) {
+        const startTime = Date.now();
+        const timings = {};
+        this.logger.debug('Starting parseAllConversations with file-level caching', {
+            filtered: allowedSessionIds !== null && allowedSessionIds !== undefined,
+            allowedCount: allowedSessionIds?.size
+        });
+        // Get current file modification times (filtered if allowedSessionIds provided)
+        const modTimeStart = Date.now();
+        const filteredModTimes = await this.getFileModificationTimes(allowedSessionIds);
+        timings.getFileModificationTimes = Date.now() - modTimeStart;
+        // Use the new file-level cache interface
+        const cacheStart = Date.now();
+        const conversations = await this.conversationCache.getOrParseConversations(filteredModTimes, (filePath) => this.parseJsonlFile(filePath), // Parse single file
+        (filePath) => this.extractSourceProject(filePath), // Get source project
+        (allEntries) => this.processAllEntries(allEntries) // Process entries
+        );
+        timings.getOrParseConversations = Date.now() - cacheStart;
+        timings.total = Date.now() - startTime;
+        this.logger.debug('parseAllConversations breakdown', {
+            timingsMs: timings,
+            filteredModTimesCount: filteredModTimes.size,
+            conversationCount: conversations.length,
+        });
+        return conversations;
+    }
+    /**
+     * Parse a single JSONL file and return all valid entries
+     */
+    async parseJsonlFile(filePath) {
+        try {
+            const content = await fs.readFile(filePath, 'utf-8');
+            const lines = content.split('\n').filter(line => line.trim());
+            const entries = [];
+            for (const line of lines) {
+                try {
+                    const entry = JSON.parse(line);
+                    entries.push(entry);
+                }
+                catch (parseError) {
+                    this.logger.warn('Failed to parse line from JSONL file', {
+                        error: parseError,
+                        filePath,
+                        line: line.substring(0, 100)
+                    });
+                }
+            }
+            return entries;
+        }
+        catch (error) {
+            this.logger.error('Failed to read JSONL file', error, { filePath });
+            return [];
+        }
+    }
+    /**
+     * Group entries by sessionId
+     */
+    groupEntriesBySession(entries) {
+        const sessionGroups = new Map();
+        for (const entry of entries) {
+            // Only group user and assistant messages
+            if ((entry.type === 'user' || entry.type === 'assistant') && entry.sessionId) {
+                if (!sessionGroups.has(entry.sessionId)) {
+                    sessionGroups.set(entry.sessionId, []);
+                }
+                sessionGroups.get(entry.sessionId).push(entry);
+            }
+        }
+        return sessionGroups;
+    }
+    /**
+     * Process summary entries and create leafUuid mapping
+     */
+    processSummaries(entries) {
+        const summaries = new Map();
+        for (const entry of entries) {
+            if (entry.type === 'summary' && entry.leafUuid && entry.summary) {
+                summaries.set(entry.leafUuid, entry.summary);
+            }
+        }
+        return summaries;
+    }
+    async readDirectory(dirPath) {
+        try {
+            return await fs.readdir(dirPath);
+        }
+        catch (error) {
+            if (error.code === 'ENOENT') {
+                return [];
+            }
+            throw error;
+        }
+    }
+    /**
+     * Build a conversation chain from session entries
+     */
+    buildConversationChain(sessionId, entries, summaries) {
+        try {
+            // Convert entries to ConversationMessage format
+            const messages = entries.map(entry => this.parseMessage(entry));
+            // Build message chain using parentUuid/uuid relationships
+            const orderedMessages = this.buildMessageChain(messages);
+            if (orderedMessages.length === 0) {
+                return null;
+            }
+            // Apply message filter
+            const filteredMessages = this.messageFilter.filterMessages(orderedMessages);
+            // Check if we have any messages left after filtering
+            if (filteredMessages.length === 0) {
+                return null;
+            }
+            // Filter out warmup/sidechain-only sessions
+            // These are subagent sessions that exist only to prime the context cache
+            const firstUserMessage = filteredMessages.find(msg => msg.type === 'user');
+            let isWarmupSession = false;
+            if (firstUserMessage?.message) {
+                const msgContent = 'content' in firstUserMessage.message
+                    ? firstUserMessage.message.content
+                    : null;
+                if (msgContent) {
+                    isWarmupSession = typeof msgContent === 'string'
+                        ? msgContent.trim() === 'Warmup'
+                        : Array.isArray(msgContent) &&
+                            msgContent.length === 1 &&
+                            msgContent[0].type === 'text' &&
+                            'text' in msgContent[0] &&
+                            msgContent[0].text?.trim() === 'Warmup';
+                }
+            }
+            // Skip sessions that are pure warmup sessions (sidechain with just "Warmup" prompt)
+            if (isWarmupSession && orderedMessages[0]?.isSidechain) {
+                return null;
+            }
+            // Determine project path - use original first message for cwd before filtering
+            const firstMessage = orderedMessages[0];
+            let projectPath = '';
+            if (firstMessage.cwd) {
+                projectPath = firstMessage.cwd;
+            }
+            else {
+                // Fallback to decoding directory name from source project
+                const sourceProject = entries[0].sourceProject;
+                projectPath = this.decodeProjectPath(sourceProject);
+            }
+            // Determine conversation summary
+            const summary = this.determineConversationSummary(filteredMessages, summaries);
+            // Calculate metadata from filtered messages
+            const totalDuration = filteredMessages.reduce((sum, msg) => sum + (msg.durationMs || 0), 0);
+            const model = this.extractModel(filteredMessages);
+            // Get timestamps from filtered messages
+            const timestamps = filteredMessages
+                .map(msg => msg.timestamp)
+                .filter(ts => ts)
+                .sort();
+            const createdAt = timestamps[0] || new Date().toISOString();
+            const updatedAt = timestamps[timestamps.length - 1] || createdAt;
+            return {
+                sessionId,
+                messages: filteredMessages,
+                projectPath,
+                summary,
+                createdAt,
+                updatedAt,
+                totalDuration,
+                model
+            };
+        }
+        catch (error) {
+            this.logger.error('Error building conversation chain', error, { sessionId });
+            return null;
+        }
+    }
+    /**
+     * Build ordered message chain using parentUuid relationships
+     */
+    buildMessageChain(messages) {
+        // Create uuid to message mapping
+        const messageMap = new Map();
+        messages.forEach(msg => messageMap.set(msg.uuid, msg));
+        // Find head message (parentUuid is null)
+        // Prefer non-sidechain roots - sidechain entries (subagent tasks) have their own
+        // separate chains but share the same sessionId
+        const rootMessages = messages.filter(msg => !msg.parentUuid);
+        const mainRoot = rootMessages.find(msg => !msg.isSidechain);
+        const headMessage = mainRoot || rootMessages[0];
+        if (!headMessage) {
+            // If no head found, return messages sorted by timestamp
+            return messages.sort((a, b) => new Date(a.timestamp || '').getTime() - new Date(b.timestamp || '').getTime());
+        }
+        // Build chain from head
+        const orderedMessages = [];
+        const visited = new Set();
+        const traverse = (currentMessage) => {
+            if (visited.has(currentMessage.uuid)) {
+                return; // Avoid cycles
+            }
+            visited.add(currentMessage.uuid);
+            orderedMessages.push(currentMessage);
+            // Find children (messages with this message as parent)
+            const children = messages.filter(msg => msg.parentUuid === currentMessage.uuid);
+            // Sort children by timestamp to maintain order
+            children.sort((a, b) => new Date(a.timestamp || '').getTime() - new Date(b.timestamp || '').getTime());
+            children.forEach(child => traverse(child));
+        };
+        traverse(headMessage);
+        // Add any orphaned messages at the end
+        const orphanedMessages = messages.filter(msg => !visited.has(msg.uuid));
+        orderedMessages.push(...orphanedMessages.sort((a, b) => new Date(a.timestamp || '').getTime() - new Date(b.timestamp || '').getTime()));
+        return orderedMessages;
+    }
+    /**
+     * Determine conversation summary from messages and summary map
+     */
+    determineConversationSummary(messages, summaries) {
+        // Walk through messages from latest to earliest to find last available summary
+        for (let i = messages.length - 1; i >= 0; i--) {
+            const message = messages[i];
+            if (summaries.has(message.uuid)) {
+                return summaries.get(message.uuid);
+            }
+        }
+        // Fallback to first user message content
+        const firstUserMessage = messages.find(msg => msg.type === 'user');
+        if (firstUserMessage && firstUserMessage.message) {
+            const content = this.extractMessageContent(firstUserMessage.message);
+            return content.length > 100 ? content.substring(0, 100) + '...' : content;
+        }
+        return 'No summary available';
+    }
+    /**
+     * Extract text content from message object
+     */
+    extractMessageContent(message) {
+        if (typeof message === 'string') {
+            return message;
+        }
+        if (message.content) {
+            if (typeof message.content === 'string') {
+                return message.content;
+            }
+            if (Array.isArray(message.content)) {
+                // Find first text content block
+                const textBlock = message.content.find((block) => block.type === 'text');
+                return textBlock && 'text' in textBlock ? textBlock.text : '';
+            }
+        }
+        return 'No content available';
+    }
+    /**
+     * Extract model information from messages
+     */
+    extractModel(messages) {
+        for (const message of messages) {
+            if (message.message && typeof message.message === 'object') {
+                const messageObj = message.message;
+                if (messageObj.model) {
+                    return messageObj.model;
+                }
+            }
+        }
+        return 'Unknown';
+    }
+    parseMessage(entry) {
+        return {
+            uuid: entry.uuid || '',
+            type: entry.type,
+            message: entry.message, // Non-null assertion since ConversationMessage requires it
+            timestamp: entry.timestamp || '',
+            sessionId: entry.sessionId || '',
+            parentUuid: entry.parentUuid,
+            isSidechain: entry.isSidechain,
+            userType: entry.userType,
+            cwd: entry.cwd,
+            version: entry.version,
+            durationMs: entry.durationMs
+        };
+    }
+    applyFilters(conversations, filter) {
+        if (!filter)
+            return conversations;
+        let filtered = [...conversations];
+        // Filter by project path
+        if (filter.projectPath) {
+            filtered = filtered.filter(c => c.projectPath === filter.projectPath);
+        }
+        // Filter by continuation session
+        if (filter.hasContinuation !== undefined) {
+            filtered = filtered.filter(c => {
+                const hasContinuation = c.sessionInfo.continuation_session_id !== '';
+                return filter.hasContinuation ? hasContinuation : !hasContinuation;
+            });
+        }
+        // Filter by archived status
+        if (filter.archived !== undefined) {
+            filtered = filtered.filter(c => c.sessionInfo.archived === filter.archived);
+        }
+        // Filter by pinned status
+        if (filter.pinned !== undefined) {
+            filtered = filtered.filter(c => c.sessionInfo.pinned === filter.pinned);
+        }
+        // Sort
+        if (filter.sortBy) {
+            filtered.sort((a, b) => {
+                const field = filter.sortBy === 'created' ? 'createdAt' : 'updatedAt';
+                const aVal = new Date(a[field]).getTime();
+                const bVal = new Date(b[field]).getTime();
+                return filter.order === 'desc' ? bVal - aVal : aVal - bVal;
+            });
+        }
+        return filtered;
+    }
+    applyPagination(conversations, filter) {
+        if (!filter)
+            return conversations;
+        const limit = filter.limit || 20;
+        const offset = filter.offset || 0;
+        return conversations.slice(offset, offset + limit);
+    }
+    decodeProjectPath(encoded) {
+        // Claude encodes directory paths by replacing '/' with '-'
+        return encoded.replace(/-/g, '/');
+    }
+}
+//# sourceMappingURL=claude-history-reader.js.map