@ebowwa/claudecodehistory 1.5.1 → 1.6.0

package/typescript/dist/history-service.js

@@ -0,0 +1,739 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import { createReadStream } from 'fs';
+import { createInterface } from 'readline';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { parseDir, CLAUDE_CODE_FIELDS } from '@ebowwa/jsonl-hft';
+const execAsync = promisify(exec);
+const USE_FAST_PARSER = process.env.CLAUDE_HISTORY_FAST_PARSER !== 'false';
+export class ClaudeCodeHistoryService {
+    claudeDir;
+    constructor(claudeDir) {
+        this.claudeDir = claudeDir || path.join(os.homedir(), '.claude');
+    }
+    /**
+     * Normalize date string to ISO format for proper comparison with timezone support
+     */
+    normalizeDate(dateString, isEndDate = false, timezone) {
+        if (dateString.includes('T')) {
+            return dateString;
+        }
+        const tz = timezone || Intl.DateTimeFormat().resolvedOptions().timeZone;
+        try {
+            if (tz === 'UTC') {
+                const timeStr = isEndDate ? '23:59:59.999' : '00:00:00.000';
+                return `${dateString}T${timeStr}Z`;
+            }
+            // Correct approach: Create date in target timezone and convert to UTC
+            const [year, month, day] = dateString.split('-').map(Number);
+            const hour = isEndDate ? 23 : 0;
+            const minute = isEndDate ? 59 : 0;
+            const second = isEndDate ? 59 : 0;
+            const millisecond = isEndDate ? 999 : 0;
+            // Create a reference date to calculate offset
+            const referenceDate = new Date(year, month - 1, day, 12, 0, 0); // Use noon for stable offset
+            // Calculate timezone offset for this specific date (handles DST)
+            const offsetMs = referenceDate.getTimezoneOffset() * 60000;
+            // Create the target time in the specified timezone
+            const localTime = new Date(year, month - 1, day, hour, minute, second, millisecond);
+            // Get what this local time would be in the target timezone
+            const targetTzTime = new Date(localTime.toLocaleString('en-CA', { timeZone: tz }));
+            const utcTime = new Date(localTime.toLocaleString('en-CA', { timeZone: 'UTC' }));
+            // Calculate the difference between target timezone and UTC
+            const tzOffsetMs = targetTzTime.getTime() - utcTime.getTime();
+            // Adjust local time to get UTC equivalent
+            const utcResult = new Date(localTime.getTime() + offsetMs - tzOffsetMs);
+            const result = utcResult.toISOString();
+            console.log(`normalizeDate: ${dateString} (${isEndDate ? 'end' : 'start'}) in ${tz} -> ${result}`);
+            return result;
+        }
+        catch (error) {
+            console.warn(`Failed to process timezone ${tz}, falling back to simple conversion:`, error);
+            const fallback = `${dateString}T${isEndDate ? '23:59:59.999' : '00:00:00.000'}Z`;
+            console.log(`normalizeDate fallback: ${dateString} -> ${fallback}`);
+            return fallback;
+        }
+    }
+    async getConversationHistory(options = {}) {
+        const { sessionId, startDate, endDate, limit = 20, offset = 0, timezone, messageTypes } = options;
+        // Normalize date strings for proper comparison
+        const normalizedStartDate = startDate ? this.normalizeDate(startDate, false, timezone) : undefined;
+        const normalizedEndDate = endDate ? this.normalizeDate(endDate, true, timezone) : undefined;
+        // Determine which message types to include (default to user only to reduce data volume)
+        const allowedTypes = messageTypes && messageTypes.length > 0 ? messageTypes : ['user'];
+        // Load history from Claude Code's .jsonl files with pre-filtering
+        let allEntries = await this.loadClaudeHistoryEntries({
+            startDate: normalizedStartDate,
+            endDate: normalizedEndDate
+        });
+        // Filter by session ID if specified
+        if (sessionId) {
+            allEntries = allEntries.filter(entry => entry.sessionId === sessionId);
+        }
+        // Filter by message types (defaults to user only)
+        allEntries = allEntries.filter(entry => allowedTypes.includes(entry.type));
+        // Filter by date range if specified (additional in-memory filtering for precision)
+        if (normalizedStartDate) {
+            allEntries = allEntries.filter(entry => entry.timestamp >= normalizedStartDate);
+        }
+        if (normalizedEndDate) {
+            allEntries = allEntries.filter(entry => entry.timestamp <= normalizedEndDate);
+        }
+        // Sort by timestamp (newest first)
+        allEntries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        // Calculate pagination
+        const totalCount = allEntries.length;
+        const paginatedEntries = allEntries.slice(offset, offset + limit);
+        const hasMore = offset + limit < totalCount;
+        return {
+            entries: paginatedEntries,
+            pagination: {
+                total_count: totalCount,
+                limit,
+                offset,
+                has_more: hasMore
+            }
+        };
+    }
+    async searchConversations(searchQuery, options = {}) {
+        const { limit = 30, projectPath, startDate, endDate, timezone } = options;
+        // Normalize date strings for proper comparison
+        const normalizedStartDate = startDate ? this.normalizeDate(startDate, false, timezone) : undefined;
+        const normalizedEndDate = endDate ? this.normalizeDate(endDate, true, timezone) : undefined;
+        const allEntries = await this.loadClaudeHistoryEntries({
+            startDate: normalizedStartDate,
+            endDate: normalizedEndDate
+        });
+        const queryLower = searchQuery.toLowerCase();
+        let matchedEntries = allEntries.filter(entry => entry.content.toLowerCase().includes(queryLower));
+        // Filter by project path if specified
+        if (projectPath) {
+            matchedEntries = matchedEntries.filter(entry => entry.projectPath === projectPath);
+        }
+        // Filter by date range if specified (additional in-memory filtering for precision)
+        if (normalizedStartDate) {
+            matchedEntries = matchedEntries.filter(entry => entry.timestamp >= normalizedStartDate);
+        }
+        if (normalizedEndDate) {
+            matchedEntries = matchedEntries.filter(entry => entry.timestamp <= normalizedEndDate);
+        }
+        matchedEntries.sort((a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime());
+        return matchedEntries.slice(0, limit);
+    }
+    async listProjects() {
+        const projects = new Map();
+        try {
+            const projectsDir = path.join(this.claudeDir, 'projects');
+            const projectDirs = await fs.readdir(projectsDir);
+            for (const projectDir of projectDirs) {
+                const projectPath = path.join(projectsDir, projectDir);
+                const stats = await fs.stat(projectPath);
+                if (stats.isDirectory()) {
+                    const files = await fs.readdir(projectPath);
+                    const decodedPath = this.decodeProjectPath(projectDir);
+                    if (!projects.has(decodedPath)) {
+                        projects.set(decodedPath, {
+                            sessionIds: new Set(),
+                            messageCount: 0,
+                            lastActivityTime: '1970-01-01T00:00:00.000Z'
+                        });
+                    }
+                    const projectInfo = projects.get(decodedPath);
+                    if (!projectInfo)
+                        continue;
+                    for (const file of files) {
+                        if (file.endsWith('.jsonl')) {
+                            const sessionId = file.replace('.jsonl', '');
+                            projectInfo.sessionIds.add(sessionId);
+                            const filePath = path.join(projectPath, file);
+                            const fileStats = await fs.stat(filePath);
+                            if (fileStats.mtime.toISOString() > projectInfo.lastActivityTime) {
+                                projectInfo.lastActivityTime = fileStats.mtime.toISOString();
+                            }
+                            // Count messages in this session
+                            const entries = await this.parseJsonlFile(filePath, projectDir);
+                            projectInfo.messageCount += entries.length;
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error listing projects:', error);
+        }
+        return Array.from(projects.entries()).map(([projectPath, info]) => ({
+            projectPath,
+            sessionCount: info.sessionIds.size,
+            messageCount: info.messageCount,
+            lastActivityTime: info.lastActivityTime
+        }));
+    }
+    async listSessions(options = {}) {
+        const { projectPath, startDate, endDate, timezone } = options;
+        // Normalize date strings for proper comparison
+        const normalizedStartDate = startDate ? this.normalizeDate(startDate, false, timezone) : undefined;
+        const normalizedEndDate = endDate ? this.normalizeDate(endDate, true, timezone) : undefined;
+        const sessions = [];
+        try {
+            const projectsDir = path.join(this.claudeDir, 'projects');
+            const projectDirs = await fs.readdir(projectsDir);
+            for (const projectDir of projectDirs) {
+                const decodedPath = this.decodeProjectPath(projectDir);
+                // Filter by project path if specified
+                if (projectPath && decodedPath !== projectPath) {
+                    continue;
+                }
+                const projectDirPath = path.join(projectsDir, projectDir);
+                const stats = await fs.stat(projectDirPath);
+                if (stats.isDirectory()) {
+                    // Use fast parser if available
+                    if (USE_FAST_PARSER) {
+                        const fastSessions = await this.listSessionsFast(projectDirPath, projectDir, normalizedStartDate, normalizedEndDate);
+                        sessions.push(...fastSessions);
+                    }
+                    else {
+                        // Fallback to slow parser
+                        const files = await fs.readdir(projectDirPath);
+                        for (const file of files) {
+                            if (file.endsWith('.jsonl')) {
+                                const sessionId = file.replace('.jsonl', '');
+                                const filePath = path.join(projectDirPath, file);
+                                const entries = await this.parseJsonlFile(filePath, projectDir);
+                                if (entries.length === 0)
+                                    continue;
+                                const sessionStart = entries[entries.length - 1].timestamp;
+                                const sessionEnd = entries[0].timestamp;
+                                // Filter by date range if specified
+                                if (normalizedStartDate && sessionEnd < normalizedStartDate)
+                                    continue;
+                                if (normalizedEndDate && sessionStart > normalizedEndDate)
+                                    continue;
+                                const userMessageCount = entries.filter(e => e.type === 'user').length;
+                                const assistantMessageCount = entries.filter(e => e.type === 'assistant').length;
+                                // Calculate duration
+                                const startTime = new Date(sessionStart).getTime();
+                                const endTime = new Date(sessionEnd).getTime();
+                                const durationMs = endTime - startTime;
+                                // Find first user message for preview
+                                const firstUserEntry = entries.slice().reverse().find(e => e.type === 'user');
+                                const firstUserMessage = firstUserEntry
+                                    ? (firstUserEntry.content.length > 100
+                                        ? firstUserEntry.content.slice(0, 100) + '...'
+                                        : firstUserEntry.content)
+                                    : undefined;
+                                // Check for errors
+                                const hasErrors = entries.some(e => e.metadata?.isError === true);
+                                // Extract project name from path
+                                const projectName = decodedPath.split('/').pop() || decodedPath;
+                                sessions.push({
+                                    sessionId,
+                                    projectPath: decodedPath,
+                                    projectName,
+                                    startTime: sessionStart,
+                                    endTime: sessionEnd,
+                                    messageCount: entries.length,
+                                    userMessageCount,
+                                    assistantMessageCount,
+                                    firstUserMessage,
+                                    durationMs,
+                                    durationFormatted: this.formatDuration(durationMs),
+                                    hasErrors
+                                });
+                            }
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error listing sessions:', error);
+        }
+        // Sort by start time (newest first)
+        sessions.sort((a, b) => new Date(b.startTime).getTime() - new Date(a.startTime).getTime());
+        return sessions;
+    }
+    /**
+     * Fast path: List sessions using the Rust parser
+     * Groups entries by session_id from fast parser results
+     */
+    async listSessionsFast(projectDirPath, projectDir, startDate, endDate) {
+        const sessions = [];
+        const decodedPath = this.decodeProjectPath(projectDir);
+        // Use fast parser on the project directory
+        const parsedEntries = parseDir(projectDirPath, CLAUDE_CODE_FIELDS);
+        // Group entries by session_id
+        const sessionMap = new Map();
+        for (const entry of parsedEntries) {
+            // Skip entries with empty session_id
+            if (!entry.session_id)
+                continue;
+            // Apply date filtering
+            if (startDate && entry.timestamp < startDate)
+                continue;
+            if (endDate && entry.timestamp > endDate)
+                continue;
+            if (!sessionMap.has(entry.session_id)) {
+                sessionMap.set(entry.session_id, []);
+            }
+            sessionMap.get(entry.session_id).push(entry);
+        }
+        // Convert to SessionInfo
+        for (const [sessionId, entries] of sessionMap) {
+            if (entries.length === 0)
+                continue;
+            // Sort entries by timestamp
+            entries.sort((a, b) => a.timestamp.localeCompare(b.timestamp));
+            const sessionStart = entries[entries.length - 1].timestamp;
+            const sessionEnd = entries[0].timestamp;
+            // Filter by date range
+            if (startDate && sessionEnd < startDate)
+                continue;
+            if (endDate && sessionStart > endDate)
+                continue;
+            // Count message types
+            const userEntries = entries.filter(e => e.role?.toLowerCase() === 'user');
+            const assistantEntries = entries.filter(e => e.role?.toLowerCase() === 'assistant');
+            const userMessageCount = userEntries.length;
+            const assistantMessageCount = assistantEntries.length;
+            // Calculate duration
+            const startTime = new Date(sessionStart).getTime();
+            const endTime = new Date(sessionEnd).getTime();
+            const durationMs = endTime - startTime;
+            // Find first user message for preview
+            const firstUserEntry = userEntries[userEntries.length - 1]; // Last in sorted = earliest
+            const firstUserMessage = firstUserEntry?.content
+                ? (firstUserEntry.content.length > 100
+                    ? firstUserEntry.content.slice(0, 100) + '...'
+                    : firstUserEntry.content)
+                : undefined;
+            // Extract project name from path
+            const projectName = decodedPath.split('/').pop() || decodedPath;
+            sessions.push({
+                sessionId,
+                projectPath: decodedPath,
+                projectName,
+                startTime: sessionStart,
+                endTime: sessionEnd,
+                messageCount: entries.length,
+                userMessageCount,
+                assistantMessageCount,
+                firstUserMessage,
+                durationMs,
+                durationFormatted: this.formatDuration(durationMs),
+                hasErrors: false // Would need to scan for errors in fast mode
+            });
+        }
+        return sessions;
+    }
+    /**
+     * Get recent activity across all projects
+     * Returns what was asked, what was done, and when for the most recent sessions
+     */
+    async getRecentActivity(options = {}) {
+        const { limit = 10, includeSummaries = true } = options;
+        // Get all sessions (sorted by start time, newest first)
+        const allSessions = await this.listSessions();
+        // Take the most recent N sessions
+        const recentSessions = allSessions.slice(0, limit);
+        // Build activity items with summaries
+        const activities = [];
+        for (const session of recentSessions) {
+            const activity = {
+                sessionId: session.sessionId,
+                projectPath: session.projectPath,
+                projectName: session.projectName || session.projectPath.split('/').pop() || session.projectPath,
+                timestamp: session.startTime,
+                timeAgo: this.getTimeAgo(new Date(session.startTime)),
+                asked: session.firstUserMessage || 'No user message found',
+            };
+            // Generate summary from assistant messages if requested
+            if (includeSummaries) {
+                activity.done = await this.generateSessionSummary(session.sessionId);
+            }
+            activities.push(activity);
+        }
+        return activities;
+    }
+    /**
+     * Generate a brief summary of what was done in a session from assistant messages
+     */
+    async generateSessionSummary(sessionId) {
+        try {
+            const result = await this.getConversationHistory({
+                sessionId,
+                limit: 50, // Get first 50 messages for summary
+                messageTypes: ['assistant'],
+            });
+            if (result.entries.length === 0) {
+                return undefined;
+            }
+            // Extract the first meaningful assistant response
+            const firstAssistant = result.entries[result.entries.length - 1];
+            if (!firstAssistant || !firstAssistant.content) {
+                return undefined;
+            }
+            // Truncate summary to ~150 characters
+            const content = firstAssistant.content;
+            return content.length > 150 ? content.slice(0, 150) + '...' : content;
+        }
+        catch (error) {
+            console.error(`Error generating summary for session ${sessionId}:`, error);
+            return undefined;
+        }
+    }
+    async loadClaudeHistoryEntries(options = {}) {
+        const entries = [];
+        const { startDate, endDate } = options;
+        try {
+            const projectsDir = path.join(this.claudeDir, 'projects');
+            const projectDirs = await fs.readdir(projectsDir);
+            for (const projectDir of projectDirs) {
+                const projectPath = path.join(projectsDir, projectDir);
+                const stats = await fs.stat(projectPath);
+                if (stats.isDirectory()) {
+                    const files = await fs.readdir(projectPath);
+                    for (const file of files) {
+                        if (file.endsWith('.jsonl')) {
+                            const filePath = path.join(projectPath, file);
+                            // Pre-filter files based on modification time
+                            if (await this.shouldSkipFile(filePath, startDate, endDate)) {
+                                continue;
+                            }
+                            const sessionEntries = await this.parseJsonlFile(filePath, projectDir, startDate, endDate);
+                            entries.push(...sessionEntries);
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error loading Claude history:', error);
+        }
+        return entries;
+    }
+    async parseJsonlFile(filePath, projectDir, startDate, endDate) {
+        const entries = [];
+        try {
+            const fileStream = createReadStream(filePath);
+            const rl = createInterface({
+                input: fileStream,
+                crlfDelay: Infinity
+            });
+            for await (const line of rl) {
+                if (line.trim()) {
+                    try {
+                        const claudeMessage = JSON.parse(line);
+                        // Apply date filtering at message level for efficiency
+                        if (startDate && claudeMessage.timestamp < startDate) {
+                            continue;
+                        }
+                        if (endDate && claudeMessage.timestamp > endDate) {
+                            continue;
+                        }
+                        const entry = this.convertClaudeMessageToEntry(claudeMessage, projectDir);
+                        if (entry) {
+                            entries.push(entry);
+                        }
+                    }
+                    catch (parseError) {
+                        console.error('Error parsing line:', parseError);
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error reading file:', filePath, error);
+        }
+        return entries;
+    }
+    convertClaudeMessageToEntry(claudeMessage, projectDir) {
+        try {
+            let content = '';
+            if (claudeMessage.message?.content) {
+                if (typeof claudeMessage.message.content === 'string') {
+                    content = claudeMessage.message.content;
+                }
+                else if (Array.isArray(claudeMessage.message.content)) {
+                    // Handle array content (e.g., from assistant messages)
+                    content = claudeMessage.message.content
+                        .map(item => {
+                        if (typeof item === 'string')
+                            return item;
+                        if (item?.type === 'text' && item?.text)
+                            return item.text;
+                        return JSON.stringify(item);
+                    })
+                        .join(' ');
+                }
+            }
+            // Decode project path from directory name
+            const projectPath = this.decodeProjectPath(projectDir);
+            // Add enhanced time information
+            const timestamp = claudeMessage.timestamp;
+            const messageDate = new Date(timestamp);
+            return {
+                sessionId: claudeMessage.sessionId,
+                timestamp,
+                type: claudeMessage.type,
+                content,
+                projectPath,
+                uuid: claudeMessage.uuid,
+                formattedTime: messageDate.toLocaleString('en-US', {
+                    timeZone: 'Asia/Tokyo',
+                    year: 'numeric',
+                    month: '2-digit',
+                    day: '2-digit',
+                    hour: '2-digit',
+                    minute: '2-digit',
+                    second: '2-digit',
+                    hour12: false
+                }),
+                timeAgo: this.getTimeAgo(messageDate),
+                localDate: messageDate.toLocaleDateString('sv-SE', { timeZone: 'Asia/Tokyo' }),
+                metadata: {
+                    usage: claudeMessage.message?.usage,
+                    model: claudeMessage.message?.model,
+                    requestId: claudeMessage.requestId
+                }
+            };
+        }
+        catch (error) {
+            console.error('Error converting Claude message:', error);
+            return null;
+        }
+    }
+    getTimeAgo(date) {
+        const now = new Date();
+        const diffMs = now.getTime() - date.getTime();
+        const diffMins = Math.floor(diffMs / (1000 * 60));
+        const diffHours = Math.floor(diffMs / (1000 * 60 * 60));
+        const diffDays = Math.floor(diffMs / (1000 * 60 * 60 * 24));
+        if (diffMins < 1)
+            return 'just now';
+        if (diffMins < 60)
+            return `${diffMins}m ago`;
+        if (diffHours < 24)
+            return `${diffHours}h ago`;
+        if (diffDays < 7)
+            return `${diffDays}d ago`;
+        if (diffDays < 30)
+            return `${Math.floor(diffDays / 7)}w ago`;
+        if (diffDays < 365)
+            return `${Math.floor(diffDays / 30)}mo ago`;
+        return `${Math.floor(diffDays / 365)}y ago`;
+    }
+    /**
+     * Format duration in milliseconds to human-readable string
+     */
+    formatDuration(ms) {
+        if (ms < 1000)
+            return `${ms}ms`;
+        const seconds = Math.floor(ms / 1000);
+        if (seconds < 60)
+            return `${seconds}s`;
+        const minutes = Math.floor(seconds / 60);
+        const remainingSeconds = seconds % 60;
+        if (minutes < 60) {
+            return remainingSeconds > 0 ? `${minutes}m ${remainingSeconds}s` : `${minutes}m`;
+        }
+        const hours = Math.floor(minutes / 60);
+        const remainingMinutes = minutes % 60;
+        if (hours < 24) {
+            return remainingMinutes > 0 ? `${hours}h ${remainingMinutes}m` : `${hours}h`;
+        }
+        const days = Math.floor(hours / 24);
+        const remainingHours = hours % 24;
+        return remainingHours > 0 ? `${days}d ${remainingHours}h` : `${days}d`;
+    }
+    decodeProjectPath(projectDir) {
+        return projectDir.replace(/-/g, '/').replace(/^\//, '');
+    }
+    /**
+     * Determines whether to skip reading a file based on its modification time
+     */
+    async shouldSkipFile(filePath, startDate, endDate) {
+        if (!startDate && !endDate) {
+            return false; // Don't skip if no date filters are specified
+        }
+        try {
+            const fileStats = await fs.stat(filePath);
+            const fileModTime = fileStats.mtime.toISOString();
+            const fileCreateTime = fileStats.birthtime.toISOString();
+            // Get the earliest and latest possible times for file content
+            const oldestPossibleTime = fileCreateTime < fileModTime ? fileCreateTime : fileModTime;
+            const newestPossibleTime = fileModTime;
+            // If endDate is specified: skip if file's oldest time is after endDate
+            if (endDate && oldestPossibleTime > endDate) {
+                return true; // Skip
+            }
+            // If startDate is specified: skip if file's newest time is before startDate
+            if (startDate && newestPossibleTime < startDate) {
+                return true; // Skip
+            }
+            return false; // File might contain data in range, so read it
+        }
+        catch (error) {
+            console.warn(`Failed to get file stats for ${filePath}:`, error);
+            return false; // Safe fallback: read the file if stat fails
+        }
+    }
+    /**
+     * Gets the current active Claude Code session by reading the last line from history.jsonl
+     */
+    async getCurrentSession() {
+        try {
+            const historyPath = path.join(this.claudeDir, 'history.jsonl');
+            const lastLine = await this.readLastLineFromFile(historyPath);
+            if (!lastLine) {
+                return null;
+            }
+            const entry = JSON.parse(lastLine);
+            // Validate and parse timestamp
+            let timestamp;
+            if (typeof entry.timestamp === 'number') {
+                timestamp = new Date(entry.timestamp).toISOString();
+            }
+            else if (typeof entry.timestamp === 'string') {
+                const date = new Date(entry.timestamp);
+                if (isNaN(date.getTime())) {
+                    return null; // Invalid date
+                }
+                timestamp = date.toISOString();
+            }
+            else {
+                return null;
+            }
+            return {
+                sessionId: entry.sessionId,
+                timestamp,
+                projectPath: entry.project,
+                display: entry.display
+            };
+        }
+        catch (error) {
+            console.error('Error getting current session:', error);
+            return null;
+        }
+    }
+    /**
+     * Maps a process ID to a Claude Code session by examining the process tree
+     */
+    async getSessionByPid(pid) {
+        try {
+            // Get process info including parent PID and command
+            const { stdout } = await execAsync(`ps -p ${pid} -o pid,ppid,command`);
+            const lines = stdout.trim().split('\n');
+            if (lines.length < 2) {
+                return null;
+            }
+            // Parse the process line (skip header)
+            const parts = lines[1].trim().split(/\s+/);
+            const processPid = parseInt(parts[0], 10);
+            const parentPid = parseInt(parts[1], 10);
+            const command = parts.slice(2).join(' ');
+            // Check if this is a Claude Code process
+            if (!command.toLowerCase().includes('claude')) {
+                return null;
+            }
+            // Extract session ID from command arguments or trace process tree
+            let sessionId = await this.extractSessionIdFromProcess(processPid);
+            // Check if process is still alive
+            const isAlive = await this.isProcessAlive(processPid);
+            return {
+                sessionId,
+                pid: processPid,
+                command,
+                alive: isAlive
+            };
+        }
+        catch (error) {
+            console.error(`Error getting session by PID ${pid}:`, error);
+            return null;
+        }
+    }
+    /**
+     * Lists all session UUIDs from the session-env directory
+     */
+    async listAllSessionUuids() {
+        try {
+            const sessionEnvDir = path.join(this.claudeDir, 'session-env');
+            const entries = await fs.readdir(sessionEnvDir);
+            // Filter only UUID-like directory names
+            const uuids = entries.filter(entry => {
+                // UUID v4 pattern: xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx
+                const uuidPattern = /^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/i;
+                return uuidPattern.test(entry);
+            });
+            return uuids;
+        }
+        catch (error) {
+            console.error('Error listing session UUIDs:', error);
+            return [];
+        }
+    }
+    /**
+     * Reads only the last line from a file efficiently
+     */
+    async readLastLineFromFile(filePath) {
+        try {
+            const fileStream = createReadStream(filePath, { encoding: 'utf-8' });
+            const rl = createInterface({
+                input: fileStream,
+                crlfDelay: Infinity
+            });
+            let lastLine = null;
+            for await (const line of rl) {
+                if (line.trim()) {
+                    lastLine = line;
+                }
+            }
+            return lastLine;
+        }
+        catch (error) {
+            console.error('Error reading last line from file:', error);
+            return null;
+        }
+    }
+    /**
+     * Extracts session ID from a Claude Code process by examining command and environment
+     */
+    async extractSessionIdFromProcess(pid) {
+        try {
+            // First, check if the command contains a session ID argument (-r flag)
+            const { stdout: psOutput } = await execAsync(`ps -p ${pid} -o command`);
+            const command = psOutput.trim();
+            // Look for -r flag with session ID
+            const sessionMatch = command.match(/-r\s+([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12})/i);
+            if (sessionMatch) {
+                return sessionMatch[1];
+            }
+            // If not found in command, check the current session from history
+            const currentSession = await this.getCurrentSession();
+            if (currentSession) {
+                return currentSession.sessionId;
+            }
+            // Fallback: return empty string
+            return '';
+        }
+        catch (error) {
+            console.error('Error extracting session ID from process:', error);
+            return '';
+        }
+    }
+    /**
+     * Checks if a process is still alive
+     */
+    async isProcessAlive(pid) {
+        try {
+            // Send signal 0 to check if process exists
+            process.kill(pid, 0);
+            return true;
+        }
+        catch (error) {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=history-service.js.map