cccmemory 1.8.0

package/dist/parsers/ConversationParser.js

@@ -0,0 +1,795 @@
+/**
+ * Multi-pass JSONL Conversation Parser for Claude Code history.
+ *
+ * This parser reads conversation history from Claude Code's storage locations
+ * (~/.claude/projects) and extracts structured data including messages, tool uses,
+ * file edits, and thinking blocks.
+ *
+ * The parser handles two directory structures:
+ * - Modern: ~/.claude/projects/{sanitized-path}
+ * - Legacy: ~/.claude/projects/{original-project-name}
+ *
+ * It performs a multi-pass parsing approach:
+ * 1. First pass: Extract conversations and messages
+ * 2. Second pass: Link tool uses and results
+ * 3. Third pass: Extract file edits from snapshots
+ * 4. Fourth pass: Extract thinking blocks
+ *
+ * @example
+ * ```typescript
+ * const parser = new ConversationParser();
+ * const result = parser.parseProject('/path/to/project');
+ * console.error(`Parsed ${result.conversations.length} conversations`);
+ * console.error(`Found ${result.messages.length} messages`);
+ * console.error(`Extracted ${result.tool_uses.length} tool uses`);
+ * ```
+ */
+import { readFileSync, readdirSync, existsSync, statSync, createReadStream } from "fs";
+import { createInterface } from "readline";
+import { join } from "path";
+import { nanoid } from "nanoid";
+import { pathToProjectFolderName } from "../utils/sanitization.js";
+/**
+ * Parser for Claude Code conversation history.
+ *
+ * Extracts structured data from JSONL conversation files stored in
+ * ~/.claude/projects. Handles both modern and legacy naming conventions.
+ */
+export class ConversationParser {
+    /**
+     * Parse all conversations for a project.
+     *
+     * Searches for conversation files in Claude's storage directories and
+     * parses them into structured entities. Supports filtering by session ID
+     * and handles both modern and legacy directory naming conventions.
+     *
+     * @param projectPath - Absolute path to the project (used for folder lookup)
+     * @param sessionId - Optional session ID to filter for a single conversation
+     * @param projectIdentifier - Optional identifier to store as project_path
+     * @param lastIndexedMs - Optional timestamp to skip unchanged files (mtime)
+     * @returns ParseResult containing all extracted entities
+     *
+     * @example
+     * ```typescript
+     * const parser = new ConversationParser();
+     *
+     * // Parse all conversations
+     * const allResults = parser.parseProject('/Users/me/my-project');
+     *
+     * // Parse specific session
+     * const sessionResults = parser.parseProject('/Users/me/my-project', 'session-123');
+     * ```
+     */
+    parseProject(projectPath, sessionId, projectIdentifier, lastIndexedMs) {
+        console.error(`Parsing conversations for project: ${projectPath}`);
+        if (sessionId) {
+            console.error(`Filtering for session: ${sessionId}`);
+        }
+        // Convert project path to Claude projects directory name
+        const projectDirName = pathToProjectFolderName(projectPath);
+        const homeDir = process.env.HOME || process.env.USERPROFILE;
+        if (!homeDir) {
+            throw new Error("HOME or USERPROFILE environment variable is not set");
+        }
+        const projectsBaseDir = join(homeDir, ".claude", "projects");
+        // Generate path variants to handle Claude Code's potential encoding differences
+        // Claude Code may encode hyphens as underscores or vice versa in path components
+        const pathVariants = this.generatePathVariants(projectDirName);
+        // Collect directories that exist
+        const dirsToCheck = [];
+        const checkedPaths = [];
+        for (const variant of pathVariants) {
+            const variantDir = join(projectsBaseDir, variant);
+            checkedPaths.push(variantDir);
+            if (existsSync(variantDir)) {
+                // Check if this directory has any .jsonl files
+                try {
+                    const files = readdirSync(variantDir).filter(f => f.endsWith(".jsonl"));
+                    if (files.length > 0 && !dirsToCheck.includes(variantDir)) {
+                        dirsToCheck.push(variantDir);
+                        console.error(`Found conversation directory: ${variant}`);
+                    }
+                }
+                catch (_e) {
+                    // Directory exists but can't be read, skip it
+                }
+            }
+        }
+        if (dirsToCheck.length === 0) {
+            console.error(`⚠️ No conversation directories found`);
+            console.error(`  Checked ${checkedPaths.length} path variants:`);
+            for (const path of checkedPaths.slice(0, 5)) {
+                console.error(`    - ${path}`);
+            }
+            if (checkedPaths.length > 5) {
+                console.error(`    ... and ${checkedPaths.length - 5} more`);
+            }
+            return {
+                conversations: [],
+                messages: [],
+                tool_uses: [],
+                tool_results: [],
+                file_edits: [],
+                thinking_blocks: [],
+                indexed_folders: [],
+            };
+        }
+        console.error(`Looking in ${dirsToCheck.length} director(ies): ${dirsToCheck.join(", ")}`);
+        // Collect all .jsonl files from all directories
+        const fileMap = new Map(); // filename -> full path
+        for (const dir of dirsToCheck) {
+            const dirFiles = readdirSync(dir).filter((f) => f.endsWith(".jsonl"));
+            for (const file of dirFiles) {
+                const fullPath = join(dir, file);
+                // If file already exists in map, keep the one from the first directory (modern takes precedence)
+                if (!fileMap.has(file)) {
+                    fileMap.set(file, fullPath);
+                }
+            }
+        }
+        let files = Array.from(fileMap.keys());
+        // If session_id provided, filter to only that session file
+        if (sessionId) {
+            files = files.filter((f) => f === `${sessionId}.jsonl`);
+            if (files.length === 0) {
+                console.error(`⚠️ Session file not found: ${sessionId}.jsonl`);
+                console.error(`Available sessions: ${Array.from(fileMap.keys()).join(", ")}`);
+            }
+        }
+        console.error(`Found ${files.length} conversation file(s) to parse`);
+        // Parse each file
+        const result = {
+            conversations: [],
+            messages: [],
+            tool_uses: [],
+            tool_results: [],
+            file_edits: [],
+            thinking_blocks: [],
+            indexed_folders: dirsToCheck,
+        };
+        const projectPathForRecords = projectIdentifier || projectPath;
+        let skippedCount = 0;
+        for (const file of files) {
+            const filePath = fileMap.get(file);
+            if (filePath) {
+                if (lastIndexedMs) {
+                    try {
+                        const stats = statSync(filePath);
+                        if (stats.mtimeMs < lastIndexedMs) {
+                            skippedCount++;
+                            continue;
+                        }
+                    }
+                    catch (_e) {
+                        // If we can't stat the file, try to parse it anyway
+                    }
+                }
+                this.parseFile(filePath, result, projectPathForRecords);
+            }
+        }
+        if (skippedCount > 0) {
+            console.error(`⏭ Skipped ${skippedCount} unchanged file(s)`);
+        }
+        console.error(`Parsed ${result.conversations.length} conversations, ${result.messages.length} messages`);
+        return result;
+    }
+    /**
+     * Parse conversations across multiple project paths and merge results.
+     *
+     * @param projectPaths - Project paths to scan for conversation folders
+     * @param sessionId - Optional session ID to filter for a single conversation
+     * @param projectIdentifier - Optional identifier to store as project_path
+     */
+    parseProjects(projectPaths, sessionId, projectIdentifier, lastIndexedMs) {
+        const combined = {
+            conversations: [],
+            messages: [],
+            tool_uses: [],
+            tool_results: [],
+            file_edits: [],
+            thinking_blocks: [],
+            indexed_folders: [],
+            parse_errors: [],
+        };
+        const seen = {
+            conversations: new Set(),
+            messages: new Set(),
+            toolUses: new Set(),
+            toolResults: new Set(),
+            fileEdits: new Set(),
+            thinkingBlocks: new Set(),
+        };
+        const indexedFolders = new Set();
+        for (const path of projectPaths) {
+            const result = this.parseProject(path, sessionId, projectIdentifier, lastIndexedMs);
+            this.mergeParseResults(combined, result, seen, indexedFolders);
+        }
+        combined.indexed_folders = Array.from(indexedFolders);
+        if (combined.parse_errors && combined.parse_errors.length === 0) {
+            delete combined.parse_errors;
+        }
+        return combined;
+    }
+    mergeParseResults(target, source, seen, indexedFolders) {
+        for (const item of source.conversations) {
+            if (!seen.conversations.has(item.id)) {
+                seen.conversations.add(item.id);
+                target.conversations.push(item);
+            }
+        }
+        for (const item of source.messages) {
+            if (!seen.messages.has(item.id)) {
+                seen.messages.add(item.id);
+                target.messages.push(item);
+            }
+        }
+        for (const item of source.tool_uses) {
+            if (!seen.toolUses.has(item.id)) {
+                seen.toolUses.add(item.id);
+                target.tool_uses.push(item);
+            }
+        }
+        for (const item of source.tool_results) {
+            if (!seen.toolResults.has(item.id)) {
+                seen.toolResults.add(item.id);
+                target.tool_results.push(item);
+            }
+        }
+        for (const item of source.file_edits) {
+            if (!seen.fileEdits.has(item.id)) {
+                seen.fileEdits.add(item.id);
+                target.file_edits.push(item);
+            }
+        }
+        for (const item of source.thinking_blocks) {
+            if (!seen.thinkingBlocks.has(item.id)) {
+                seen.thinkingBlocks.add(item.id);
+                target.thinking_blocks.push(item);
+            }
+        }
+        if (source.indexed_folders) {
+            for (const folder of source.indexed_folders) {
+                indexedFolders.add(folder);
+            }
+        }
+        if (source.parse_errors && source.parse_errors.length > 0) {
+            if (!target.parse_errors) {
+                target.parse_errors = [];
+            }
+            target.parse_errors.push(...source.parse_errors);
+        }
+    }
+    /**
+     * Parse conversations directly from a Claude projects folder.
+     *
+     * This method is used when you already have the path to the conversation
+     * folder (e.g., ~/.claude/projects/-Users-me-my-project) rather than
+     * a project path that needs to be converted.
+     *
+     * @param folderPath - Absolute path to the Claude projects folder
+     * @param projectIdentifier - Optional identifier to use as project_path in records (defaults to folder path)
+     * @returns ParseResult containing all extracted entities
+     *
+     * @example
+     * ```typescript
+     * const parser = new ConversationParser();
+     * const result = parser.parseFromFolder('~/.claude/projects/-Users-me-my-project');
+     * ```
+     */
+    parseFromFolder(folderPath, projectIdentifier, lastIndexedMs) {
+        const result = {
+            conversations: [],
+            messages: [],
+            tool_uses: [],
+            tool_results: [],
+            file_edits: [],
+            thinking_blocks: [],
+            indexed_folders: [folderPath],
+        };
+        // Use folder path as project identifier if not provided
+        const projectPath = projectIdentifier || folderPath;
+        if (!existsSync(folderPath)) {
+            console.error(`⚠️ Folder does not exist: ${folderPath}`);
+            return result;
+        }
+        // Get all .jsonl files in the folder
+        const files = readdirSync(folderPath).filter((f) => f.endsWith(".jsonl"));
+        console.error(`Found ${files.length} conversation file(s) in ${folderPath}`);
+        // Parse each file, optionally skipping unchanged files in incremental mode
+        let skippedCount = 0;
+        for (const file of files) {
+            const filePath = join(folderPath, file);
+            // Skip unchanged files in incremental mode
+            if (lastIndexedMs) {
+                try {
+                    const stats = statSync(filePath);
+                    if (stats.mtimeMs < lastIndexedMs) {
+                        skippedCount++;
+                        continue;
+                    }
+                }
+                catch (_e) {
+                    // If we can't stat the file, try to parse it anyway
+                }
+            }
+            this.parseFile(filePath, result, projectPath);
+        }
+        if (skippedCount > 0) {
+            console.error(`⏭ Skipped ${skippedCount} unchanged file(s)`);
+        }
+        console.error(`Parsed ${result.conversations.length} conversations, ${result.messages.length} messages`);
+        return result;
+    }
+    /**
+     * Parse conversations from a Claude projects folder using streaming.
+     *
+     * This async method uses line-by-line streaming to efficiently handle
+     * large JSONL files without loading the entire file into memory.
+     * Use this method for large conversation histories.
+     *
+     * @param folderPath - Absolute path to the Claude projects folder
+     * @param projectIdentifier - Optional identifier to use as project_path in records
+     * @param lastIndexedMs - Optional timestamp for incremental indexing (skip unchanged files)
+     * @returns Promise<ParseResult> containing all extracted entities
+     *
+     * @example
+     * ```typescript
+     * const parser = new ConversationParser();
+     * const result = await parser.parseFromFolderAsync('~/.claude/projects/-Users-me-my-project');
+     * ```
+     */
+    async parseFromFolderAsync(folderPath, projectIdentifier, lastIndexedMs) {
+        const result = {
+            conversations: [],
+            messages: [],
+            tool_uses: [],
+            tool_results: [],
+            file_edits: [],
+            thinking_blocks: [],
+            indexed_folders: [folderPath],
+        };
+        // Use folder path as project identifier if not provided
+        const projectPath = projectIdentifier || folderPath;
+        if (!existsSync(folderPath)) {
+            console.error(`⚠️ Folder does not exist: ${folderPath}`);
+            return result;
+        }
+        // Get all .jsonl files in the folder
+        const files = readdirSync(folderPath).filter((f) => f.endsWith(".jsonl"));
+        console.error(`Found ${files.length} conversation file(s) in ${folderPath}`);
+        // Parse each file, optionally skipping unchanged files in incremental mode
+        let skippedCount = 0;
+        for (const file of files) {
+            const filePath = join(folderPath, file);
+            // Skip unchanged files in incremental mode
+            if (lastIndexedMs) {
+                try {
+                    const stats = statSync(filePath);
+                    if (stats.mtimeMs < lastIndexedMs) {
+                        skippedCount++;
+                        continue;
+                    }
+                }
+                catch (_e) {
+                    // If we can't stat the file, try to parse it anyway
+                }
+            }
+            await this.parseFileAsync(filePath, result, projectPath);
+        }
+        if (skippedCount > 0) {
+            console.error(`⏭ Skipped ${skippedCount} unchanged file(s)`);
+        }
+        console.error(`Parsed ${result.conversations.length} conversations, ${result.messages.length} messages`);
+        return result;
+    }
+    /**
+     * Parse a single .jsonl file using streaming (async).
+     *
+     * Uses readline interface with createReadStream to read the file
+     * line by line, avoiding loading the entire file into memory.
+     */
+    async parseFileAsync(filePath, result, projectPath) {
+        const fileMessages = [];
+        // Create readline interface for streaming
+        const fileStream = createReadStream(filePath, { encoding: "utf-8" });
+        const rl = createInterface({
+            input: fileStream,
+            crlfDelay: Infinity, // Handle both \n and \r\n
+        });
+        let lineNumber = 0;
+        for await (const line of rl) {
+            lineNumber++;
+            const trimmedLine = line.trim();
+            if (!trimmedLine) {
+                continue;
+            }
+            try {
+                const msg = JSON.parse(trimmedLine);
+                fileMessages.push(msg);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`Error parsing line ${lineNumber} in ${filePath}: ${errorMsg}`);
+                // Track the error
+                if (!result.parse_errors) {
+                    result.parse_errors = [];
+                }
+                result.parse_errors.push({
+                    file: filePath,
+                    line: lineNumber,
+                    error: errorMsg,
+                });
+            }
+        }
+        if (fileMessages.length === 0) {
+            return;
+        }
+        // Run multi-pass extraction (same as sync version)
+        this.extractConversation(fileMessages, result, projectPath);
+        this.extractMessages(fileMessages, result);
+        this.extractToolCalls(fileMessages, result);
+        this.extractFileEdits(fileMessages, result);
+        this.extractThinkingBlocks(fileMessages, result);
+    }
+    /**
+     * Parse a single .jsonl file
+     */
+    parseFile(filePath, result, projectPath) {
+        const content = readFileSync(filePath, "utf-8");
+        const lines = content.split("\n").filter((l) => l.trim());
+        // Parse messages from this file
+        const fileMessages = [];
+        for (let i = 0; i < lines.length; i++) {
+            const line = lines[i];
+            try {
+                const msg = JSON.parse(line);
+                fileMessages.push(msg);
+            }
+            catch (error) {
+                const errorMsg = error instanceof Error ? error.message : String(error);
+                console.error(`Error parsing line ${i + 1} in ${filePath}: ${errorMsg}`);
+                // Track the error
+                if (!result.parse_errors) {
+                    result.parse_errors = [];
+                }
+                result.parse_errors.push({
+                    file: filePath,
+                    line: i + 1,
+                    error: errorMsg,
+                });
+            }
+        }
+        if (fileMessages.length === 0) {
+            return;
+        }
+        // Pass 1: Extract conversation info
+        this.extractConversation(fileMessages, result, projectPath);
+        // Pass 2: Extract messages
+        this.extractMessages(fileMessages, result);
+        // Pass 3: Extract tool uses and results
+        this.extractToolCalls(fileMessages, result);
+        // Pass 4: Extract file edits
+        this.extractFileEdits(fileMessages, result);
+        // Pass 5: Extract thinking blocks
+        this.extractThinkingBlocks(fileMessages, result);
+    }
+    /**
+     * Pass 1: Extract conversation metadata
+     */
+    extractConversation(messages, result, projectPath) {
+        // Get sessionId from first message
+        const firstMsg = messages.find((m) => m.sessionId);
+        if (!firstMsg || !firstMsg.sessionId) {
+            return;
+        }
+        const sessionId = firstMsg.sessionId;
+        // Check if conversation already exists
+        if (result.conversations.some((c) => c.id === sessionId)) {
+            return;
+        }
+        // Find timestamps (filter out invalid/NaN timestamps)
+        const timestamps = messages
+            .filter((m) => !!m.timestamp)
+            .map((m) => new Date(m.timestamp).getTime())
+            .filter((t) => !isNaN(t))
+            .sort((a, b) => a - b);
+        if (timestamps.length === 0) {
+            return;
+        }
+        // Get most common git branch and version
+        const branches = messages
+            .filter((m) => !!m.gitBranch)
+            .map((m) => m.gitBranch);
+        const versions = messages
+            .filter((m) => !!m.version)
+            .map((m) => m.version);
+        // Detect MCP tool usage
+        const mcpUsage = this.detectMcpUsage(messages);
+        const conversation = {
+            id: sessionId,
+            project_path: projectPath,
+            first_message_at: timestamps[0],
+            last_message_at: timestamps[timestamps.length - 1],
+            message_count: messages.filter((m) => m.type === "user" || m.type === "assistant").length,
+            git_branch: branches[branches.length - 1],
+            claude_version: versions[versions.length - 1],
+            metadata: {
+                total_messages: messages.length,
+                mcp_usage: mcpUsage,
+            },
+            created_at: timestamps[0],
+            updated_at: Date.now(),
+        };
+        result.conversations.push(conversation);
+    }
+    /**
+     * Detect MCP tool usage in conversation messages
+     */
+    detectMcpUsage(messages) {
+        const servers = new Set();
+        for (const msg of messages) {
+            const messageData = msg.message;
+            if (!messageData?.content || !Array.isArray(messageData.content)) {
+                continue;
+            }
+            for (const item of messageData.content) {
+                const contentItem = item;
+                if (contentItem.type === "tool_use" && contentItem.name?.startsWith("mcp__")) {
+                    // Extract server name from tool name
+                    // Format: mcp__server-name__tool-name
+                    const parts = contentItem.name.split("__");
+                    if (parts.length >= 2) {
+                        servers.add(parts[1]);
+                    }
+                }
+            }
+        }
+        return {
+            detected: servers.size > 0,
+            servers: Array.from(servers),
+        };
+    }
+    /**
+     * Pass 2: Extract individual messages
+     */
+    extractMessages(messages, result) {
+        for (const msg of messages) {
+            if (!msg.uuid || !msg.sessionId) {
+                continue;
+            }
+            const message = {
+                id: msg.uuid,
+                conversation_id: msg.sessionId,
+                parent_id: msg.parentUuid || undefined,
+                message_type: msg.type,
+                role: msg.message?.role,
+                content: this.extractContent(msg),
+                timestamp: msg.timestamp ? new Date(msg.timestamp).getTime() : Date.now(),
+                is_sidechain: msg.isSidechain || false,
+                agent_id: msg.agentId,
+                request_id: msg.requestId,
+                git_branch: msg.gitBranch,
+                cwd: msg.cwd,
+                metadata: msg,
+            };
+            result.messages.push(message);
+        }
+    }
+    /**
+     * Pass 3: Extract tool uses and results
+     */
+    extractToolCalls(messages, result) {
+        for (const msg of messages) {
+            const messageData = msg.message;
+            if (!messageData?.content || !Array.isArray(messageData.content) || !msg.uuid) {
+                continue;
+            }
+            const timestamp = msg.timestamp
+                ? new Date(msg.timestamp).getTime()
+                : Date.now();
+            for (const item of messageData.content) {
+                const contentItem = item;
+                // Tool use
+                if (contentItem.type === "tool_use") {
+                    const toolUse = {
+                        id: contentItem.id || "",
+                        message_id: msg.uuid,
+                        tool_name: contentItem.name || "",
+                        tool_input: contentItem.input || {},
+                        timestamp,
+                    };
+                    result.tool_uses.push(toolUse);
+                }
+                // Tool result
+                if (contentItem.type === "tool_result") {
+                    const toolUseResult = msg.toolUseResult;
+                    const toolResult = {
+                        id: nanoid(),
+                        tool_use_id: contentItem.tool_use_id || "",
+                        message_id: msg.uuid,
+                        content: typeof contentItem.content === "string" ? contentItem.content : JSON.stringify(contentItem.content),
+                        is_error: contentItem.is_error || false,
+                        stdout: toolUseResult?.stdout,
+                        stderr: toolUseResult?.stderr,
+                        is_image: toolUseResult?.isImage || false,
+                        timestamp,
+                    };
+                    result.tool_results.push(toolResult);
+                }
+            }
+        }
+    }
+    /**
+     * Pass 4: Extract file edits from snapshots
+     */
+    extractFileEdits(messages, result) {
+        // Build a Set of stored message IDs for quick lookup
+        const storedMessageIds = new Set(result.messages.map(m => m.id));
+        for (const msg of messages) {
+            if (msg.type !== "file-history-snapshot" || !msg.snapshot) {
+                continue;
+            }
+            // Get the message ID that would reference this snapshot
+            const messageId = msg.messageId || msg.uuid;
+            if (!messageId) {
+                continue; // No message ID to reference
+            }
+            // Skip if the message wasn't stored (e.g., lacks uuid or sessionId)
+            if (!storedMessageIds.has(messageId)) {
+                // This is expected for file-history-snapshot messages that don't have uuid/sessionId
+                continue;
+            }
+            const snapshot = msg.snapshot;
+            const trackedFiles = snapshot.trackedFileBackups || {};
+            const conversationId = msg.sessionId;
+            if (!conversationId) {
+                continue; // Need conversation ID for foreign key
+            }
+            for (const [filePath, fileInfo] of Object.entries(trackedFiles)) {
+                const info = fileInfo;
+                const fileEdit = {
+                    id: nanoid(),
+                    conversation_id: conversationId,
+                    file_path: filePath,
+                    message_id: messageId,
+                    backup_version: info.version,
+                    backup_time: info.backupTime
+                        ? new Date(info.backupTime).getTime()
+                        : undefined,
+                    snapshot_timestamp: snapshot.timestamp
+                        ? new Date(snapshot.timestamp).getTime()
+                        : Date.now(),
+                    metadata: info,
+                };
+                result.file_edits.push(fileEdit);
+            }
+        }
+    }
+    /**
+     * Pass 5: Extract thinking blocks
+     */
+    extractThinkingBlocks(messages, result) {
+        for (const msg of messages) {
+            const messageData = msg.message;
+            if (!messageData?.content || !Array.isArray(messageData.content) || !msg.uuid) {
+                continue;
+            }
+            const timestamp = msg.timestamp
+                ? new Date(msg.timestamp).getTime()
+                : Date.now();
+            for (const item of messageData.content) {
+                const contentItem = item;
+                if (contentItem.type === "thinking") {
+                    const thinking = {
+                        id: nanoid(),
+                        message_id: msg.uuid,
+                        thinking_content: contentItem.thinking || "",
+                        signature: contentItem.signature,
+                        timestamp,
+                    };
+                    result.thinking_blocks.push(thinking);
+                }
+            }
+        }
+    }
+    /**
+     * Generate path variants to handle potential encoding differences.
+     *
+     * Claude Code may encode paths differently than expected:
+     * - Hyphens in path components might become underscores
+     * - Underscores might become hyphens
+     * - Dots might become hyphens (legacy)
+     *
+     * This method generates multiple variants to try when searching for directories.
+     *
+     * @example
+     * Input: "-Users-myid-GIT-projects-myProject"
+     * Output: [
+     *   "-Users-myid-GIT-projects-myProject",     // Original
+     *   "-Users-myid-GIT_projects-myProject",     // Hyphens in components -> underscores
+     *   "-Users-myid-GIT-projects-myProject",     // Dots -> hyphens (legacy)
+     * ]
+     */
+    generatePathVariants(projectDirName) {
+        const variants = new Set();
+        // 1. Original encoding (as computed by pathToProjectFolderName)
+        variants.add(projectDirName);
+        // 2. Legacy: dots replaced with hyphens
+        const legacyVariant = projectDirName.replace(/\./g, '-');
+        variants.add(legacyVariant);
+        // 3. Try swapping hyphens and underscores within path components
+        // Path format: "-Component1-Component2-Component3" or "Drive-Component1-Component2"
+        // We need to be careful not to change the leading hyphen or the separating hyphens
+        // Split into components by hyphen (the first element might be empty for Unix paths starting with -)
+        const parts = projectDirName.split('-');
+        // Try converting internal hyphens within multi-hyphen component names to underscores
+        // This handles cases like "GIT-projects" becoming "GIT_projects"
+        // Strategy: For each part that looks like it might have been originally hyphenated,
+        // create a variant with underscores
+        const hyphenToUnderscoreVariant = parts
+            .map((part) => {
+            // Skip empty parts and single chars (likely path separators)
+            if (part.length === 0) {
+                return part;
+            }
+            // Convert any underscores in parts to hyphens (in case source had underscores)
+            return part.replace(/_/g, '-');
+        })
+            .join('-');
+        const underscoreToHyphenVariant = parts
+            .map((part) => {
+            if (part.length === 0) {
+                return part;
+            }
+            // Convert any hyphens that might be internal to underscores
+            // This is tricky because hyphens are also used as separators
+            return part;
+        })
+            .join('-');
+        variants.add(hyphenToUnderscoreVariant);
+        variants.add(underscoreToHyphenVariant);
+        // 4. Try a variant where we replace all underscores with hyphens
+        const allUnderscoresToHyphens = projectDirName.replace(/_/g, '-');
+        variants.add(allUnderscoresToHyphens);
+        // 5. Try a variant where path components with hyphens have them as underscores
+        // e.g., "GIT-projects" -> "GIT_projects"
+        // We need to identify which consecutive hyphens are part of component names vs separators
+        // A simple heuristic: look for patterns like "X-Y" where X and Y are both alphanumeric
+        const internalHyphensToUnderscores = projectDirName.replace(/([a-zA-Z0-9])[-]([a-zA-Z0-9])/g, '$1_$2');
+        variants.add(internalHyphensToUnderscores);
+        // 6. Also try the reverse: convert underscores to hyphens
+        const internalUnderscoresToHyphens = projectDirName.replace(/([a-zA-Z0-9])[_]([a-zA-Z0-9])/g, '$1-$2');
+        variants.add(internalUnderscoresToHyphens);
+        // Apply the same transformations to the legacy variant
+        const legacyInternalHyphensToUnderscores = legacyVariant.replace(/([a-zA-Z0-9])[-]([a-zA-Z0-9])/g, '$1_$2');
+        variants.add(legacyInternalHyphensToUnderscores);
+        return Array.from(variants);
+    }
+    /**
+     * Extract text content from message
+     */
+    extractContent(msg) {
+        // System messages
+        if (msg.type === "system" && typeof msg.content === "string") {
+            return msg.content;
+        }
+        // Summary messages
+        if (msg.type === "summary" && msg.summary) {
+            return msg.summary;
+        }
+        // User/Assistant messages
+        const messageData = msg.message;
+        if (messageData?.content) {
+            if (typeof messageData.content === "string") {
+                return messageData.content;
+            }
+            if (Array.isArray(messageData.content)) {
+                // Extract text blocks
+                const textBlocks = messageData.content.filter((item) => item.type === "text");
+                return textBlocks.map((item) => item.text || "").join("\n");
+            }
+        }
+        return undefined;
+    }
+}
+//# sourceMappingURL=ConversationParser.js.map