byterover-cli 0.2.1 → 0.3.0

package/dist/infra/parsers/clean/clean-claude-service.js

@@ -0,0 +1,271 @@
+/**
+ * Claude Clean Service
+ * Transforms Claude raw parsed data to clean normalized format
+ * Consolidates agent sessions and normalizes messages
+ */
+import { readdir, readFile } from 'node:fs/promises';
+import path from 'node:path';
+import { normalizeClaudeSession } from './shared.js';
+/**
+ * Claude Clean Service
+ * Transforms Claude raw parsed sessions to clean normalized format
+ */
+export class ClaudeCleanService {
+    ide;
+    /**
+     * Initialize Claude Clean Service
+     *
+     * @param ide - The IDE type (Claude Code)
+     */
+    constructor(ide) {
+        this.ide = ide;
+    }
+    /**
+     * Parse and transform raw Claude sessions to clean normalized format
+     *
+     * Reads raw sessions organized by workspace, consolidates agent sessions into main
+     * conversations, and normalizes message format. Returns sessions in-memory without file writing.
+     *
+     * @param rawDir - Path to directory containing raw Claude session files organized by workspace
+     * @returns Promise resolving to array of clean normalized sessions
+     */
+    /* eslint-disable no-await-in-loop */
+    async parse(rawDir) {
+        console.log('🔍 Starting Claude clean transformation...');
+        console.log(`📁 Raw directory: ${rawDir}`);
+        try {
+            const entries = await readdir(rawDir);
+            const allCleanSessions = [];
+            for (const entry of entries) {
+                const workspacePath = path.join(rawDir, entry);
+                const files = await readdir(workspacePath);
+                const jsonFiles = files.filter((f) => f.endsWith('.json') && f !== 'summary.json');
+                if (jsonFiles.length === 0)
+                    continue;
+                const { agentSessions, allSessions } = await this.loadSessions(workspacePath, jsonFiles);
+                const cleanedSession = await this.processMainSessions(allSessions, agentSessions);
+                allCleanSessions.push(...cleanedSession);
+            }
+            console.log(`\n🎉 Claude clean transformation complete! ${allCleanSessions.length} sessions processed`);
+            return Object.freeze(allCleanSessions);
+        }
+        catch (error) {
+            console.error('❌ Error during transformation:', error instanceof Error ? error.message : 'Unknown error');
+            return Object.freeze([]);
+        }
+    }
+    /* eslint-enable no-await-in-loop */
+    /**
+     * Calculate string similarity score using word overlap method
+     *
+     * Computes similarity by comparing words with length > 3 characters.
+     * Returns fraction of matching words relative to max length.
+     *
+     * @param str1 - First string to compare
+     * @param str2 - Second string to compare
+     * @returns Similarity score between 0 (no match) and 1 (perfect match)
+     */
+    calculateSimilarity(str1, str2) {
+        const words1 = str1
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((w) => w.length > 3);
+        const words2 = str2
+            .toLowerCase()
+            .split(/\s+/)
+            .filter((w) => w.length > 3);
+        if (words1.length === 0 || words2.length === 0)
+            return 0;
+        const matches = words1.filter((w) => words2.some((w2) => w2.includes(w) || w.includes(w2)));
+        return matches.length / Math.max(words1.length, words2.length);
+    }
+    /**
+     * Consolidate agent session data into main conversation
+     *
+     * When main conversation contains Task subagent invocation, flattens the agent
+     * session messages into the main message stream. Two-pass algorithm: first identify
+     * Task invocations with matching agent sessions, then insert agent messages.
+     *
+     * @param mainSession - Main Claude conversation session to consolidate into
+     * @param agentSessions - Map of agent sessions keyed by agent session ID
+     * @returns Promise resolving to consolidated session with agent messages merged
+     */
+    async consolidateAgentSessions(mainSession, agentSessions) {
+        if (!mainSession.messages || mainSession.messages.length === 0) {
+            return mainSession;
+        }
+        // First pass: identify Task tool_use invocations that have matching agent sessions
+        const taskToolUseIds = this.identifyTaskToolIds(mainSession.messages, agentSessions);
+        // Second pass: flatten messages, inserting agent messages after Task invocations
+        const newMessages = this.flattenMessagesWithAgentSessions(mainSession.messages, taskToolUseIds, agentSessions);
+        return {
+            ...mainSession,
+            messages: newMessages,
+        };
+    }
+    /**
+     * Find best matching agent session for a task description and timestamp
+     *
+     * Locates matching agent session using similarity scoring and timestamp proximity.
+     * Considers both task description similarity and temporal closeness (within 5 seconds).
+     *
+     * @param description - Task description from Task tool_use invocation
+     * @param messageTimestamp - Timestamp of message containing Task invocation
+     * @param agentSessions - Map of available agent sessions
+     * @returns Matching agent session or null if no good match found
+     */
+    findMatchingAgentSession(description, messageTimestamp, agentSessions) {
+        let matchedAgent = null;
+        let bestScore = 0.2; // Minimum similarity threshold
+        for (const agentSession of agentSessions.values()) {
+            const agentTitle = agentSession.title || '';
+            const agentTimestamp = new Date(agentSession.timestamp).getTime();
+            // Calculate similarity score
+            let score = this.calculateSimilarity(description, agentTitle);
+            // Boost score for nearby timestamps (within 5 seconds)
+            const timeDiff = Math.abs(messageTimestamp - agentTimestamp);
+            if (timeDiff < 5000) {
+                score += 0.3;
+            }
+            // If this is the best match so far, use it
+            if (score > bestScore) {
+                bestScore = score;
+                matchedAgent = agentSession;
+            }
+        }
+        return matchedAgent;
+    }
+    /**
+     * Flatten messages with agent sessions inserted after Task invocations
+     *
+     * Inserts agent session messages into message stream after Task tool_use invocations
+     * that have matching agent sessions. Preserves message order.
+     *
+     * @param messages - Array of raw session messages
+     * @param taskToolUseIds - Set of Task tool_use IDs that have matching agent sessions
+     * @param agentSessions - Map of available agent sessions
+     * @returns Flattened message array with agent messages interleaved
+     */
+    flattenMessagesWithAgentSessions(messages, taskToolUseIds, agentSessions) {
+        const newMessages = [];
+        for (const message of messages) {
+            newMessages.push(message);
+            if (message.type !== 'assistant' || !message.content || !Array.isArray(message.content)) {
+                continue;
+            }
+            for (const content of message.content) {
+                if (content.type !== 'tool_use' || content.name !== 'Task') {
+                    continue;
+                }
+                const contentId = content.id;
+                if (!taskToolUseIds.has(contentId)) {
+                    continue;
+                }
+                const taskInput = content.input || {};
+                const description = taskInput.description || '';
+                const messageTimestamp = new Date(message.timestamp).getTime();
+                const matchedAgent = this.findMatchingAgentSession(description, messageTimestamp, agentSessions);
+                if (matchedAgent && matchedAgent.messages && Array.isArray(matchedAgent.messages)) {
+                    newMessages.push(...matchedAgent.messages);
+                }
+            }
+        }
+        return newMessages;
+    }
+    /**
+     * Identify Task tool_use IDs that have matching agent sessions
+     *
+     * Scans messages for Task tool_use invocations and identifies which ones
+     * have corresponding agent sessions that can be consolidated.
+     *
+     * @param messages - Array of session messages
+     * @param agentSessions - Map of available agent sessions
+     * @returns Set of tool_use IDs that have matching agent sessions
+     */
+    identifyTaskToolIds(messages, agentSessions) {
+        const taskToolUseIds = new Set();
+        for (const message of messages) {
+            if (message.type !== 'assistant' || !message.content || !Array.isArray(message.content)) {
+                continue;
+            }
+            for (const content of message.content) {
+                if (content.type !== 'tool_use' || content.name !== 'Task') {
+                    continue;
+                }
+                const taskInput = content.input || {};
+                const description = taskInput.description || '';
+                const messageTimestamp = new Date(message.timestamp).getTime();
+                const matchedAgent = this.findMatchingAgentSession(description, messageTimestamp, agentSessions);
+                if (matchedAgent && matchedAgent.messages) {
+                    const contentId = content.id;
+                    taskToolUseIds.add(contentId);
+                }
+            }
+        }
+        return taskToolUseIds;
+    }
+    /**
+     * Load and organize sessions from workspace directory
+     *
+     * Reads JSON files from workspace directory and organizes them into main sessions
+     * and agent sessions based on filename prefix ('agent-' for agent sessions).
+     *
+     * @param workspacePath - Path to workspace directory containing session files
+     * @param jsonFiles - Array of JSON filenames to load
+     * @returns Promise resolving to object with separated agentSessions and allSessions maps
+     */
+    async loadSessions(workspacePath, jsonFiles) {
+        const allSessions = new Map();
+        const agentSessions = new Map();
+        /* eslint-disable no-await-in-loop */
+        for (const file of jsonFiles) {
+            try {
+                const content = await readFile(path.join(workspacePath, file), 'utf8');
+                const session = JSON.parse(content);
+                const sessionId = file.replace('.json', '');
+                if (file.startsWith('agent-')) {
+                    agentSessions.set(sessionId, session);
+                }
+                else {
+                    allSessions.set(sessionId, session);
+                }
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to read ${file}:`, error instanceof Error ? error.message : String(error));
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        return { agentSessions, allSessions };
+    }
+    /**
+     * Process main sessions and return normalized outputs
+     *
+     * Consolidates agent sessions and normalizes each session.
+     * Returns normalized sessions in-memory without writing to disk.
+     *
+     * @param allSessions - Map of main sessions to process
+     * @param agentSessions - Map of available agent sessions for consolidation
+     * @returns Promise resolving to array of clean normalized sessions
+     */
+    async processMainSessions(allSessions, agentSessions) {
+        const cleanedSessions = [];
+        /* eslint-disable no-await-in-loop */
+        for (const [sessionId, session] of allSessions) {
+            try {
+                // Consolidate agent sessions if any exist
+                let consolidatedSession = session;
+                if (agentSessions.size > 0) {
+                    consolidatedSession = await this.consolidateAgentSessions(session, agentSessions);
+                }
+                const normalized = normalizeClaudeSession(consolidatedSession, 'Claude');
+                cleanedSessions.push(normalized);
+                console.log(`    ✅ ${session.title}`);
+            }
+            catch (error) {
+                console.warn(`⚠️  Failed to transform ${sessionId}:`, error instanceof Error ? error.message : 'Unknown error');
+            }
+        }
+        /* eslint-enable no-await-in-loop */
+        return cleanedSessions;
+    }
+}

package/dist/infra/parsers/clean/clean-codex-service.d.ts

@@ -0,0 +1,231 @@
+/**
+ * Codex Clean Service
+ * Transforms Codex raw parsed data to clean normalized format
+ */
+import type { CleanSession } from '../../../core/domain/entities/parser.js';
+import { Agent } from '../../../core/domain/entities/agent.js';
+import { ICleanParserService } from '../../../core/interfaces/parser/i-clean-parser-service.js';
+/**
+ * Codex Clean Service
+ * Transforms Codex raw parsed sessions to clean normalized format
+ */
+export declare class CodexCleanService implements ICleanParserService {
+    private ide;
+    constructor(ide: Agent);
+    /**
+     * Parse and transform Codex raw sessions to clean normalized format
+     *
+     * Reads Codex raw session files organized by date, transforms them to a unified
+     * format, and returns the normalized sessions. Each session is processed using
+     * Codex-specific transformation logic. Returns sessions in-memory without file writing.
+     *
+     * @param rawDir - Absolute path to the directory containing raw Codex session files organized by date
+     * @returns Promise resolving to array of clean normalized sessions
+     */
+    parse(rawDir: string): Promise<readonly CleanSession[]>;
+    /**
+     * Extract tool execution output from Codex payload
+     *
+     * Attempts to parse the output field from a tool execution payload. Handles both
+     * stringified JSON output and direct string/object output. Returns the extracted
+     * output or nested output data if present.
+     *
+     * @param payload - Tool execution payload object containing output field
+     * @returns Extracted output as object or string, empty string if parsing fails
+     */
+    private extractToolOutput;
+    /**
+     * Extract workspace paths from a Codex payload entry
+     *
+     * Searches payload for workspace path information in two locations:
+     * 1. Direct cwd (current working directory) field
+     * 2. writable_roots field (either direct or nested in sandbox_policy)
+     * Handles both string and array values for writable_roots.
+     *
+     * @param payload - Codex payload object to extract paths from
+     * @returns Array of workspace path strings found in the payload
+     */
+    private extractWorkspacePathsFromPayload;
+    /**
+     * Normalize a Codex content block to unified ContentBlock format
+     *
+     * Transforms Codex-specific content block formats to standardized format.
+     * Handles multiple block types:
+     * - String blocks → text blocks
+     * - input_text/output_text → text blocks
+     * - thinking blocks
+     * - tool_use blocks
+     * - tool_result blocks
+     * Returns null for invalid or unrecognized blocks.
+     *
+     * @param block - Codex content block to normalize (string, object, or other)
+     * @returns Normalized ContentBlock or null if block is invalid
+     */
+    private normalizeCodexContentBlock;
+    /**
+     * Normalize Codex session data to unified session format
+     *
+     * Transforms raw Codex session structure to standardized format:
+     * 1. Extracts session metadata from session_meta entry
+     * 2. Transforms rawEntries to normalized messages
+     * 3. Extracts unique workspace paths from all entries
+     * 4. Combines tool use/result messages
+     * 5. Assigns turn IDs
+     *
+     * @param session - Raw Codex session object with rawEntries and metadata
+     * @returns Normalized session object with messages, metadata, and workspace paths
+     */
+    private normalizeCodexSession;
+    /**
+     * Normalize input_text or output_text blocks to standard text format
+     *
+     * Extracts text content from Codex input_text or output_text blocks and
+     * converts them to the unified text content block format.
+     *
+     * @param blockObj - Codex input/output text block object
+     * @returns TextContentBlock with extracted text content
+     */
+    private normalizeInputTextBlock;
+    /**
+     * Normalize standard text content blocks
+     *
+     * Extracts text field from a content block object and returns it in
+     * the standardized text content block format.
+     *
+     * @param blockObj - Content block object with text field
+     * @returns TextContentBlock with extracted text content
+     */
+    private normalizeTextBlock;
+    /**
+     * Normalize thinking content blocks
+     *
+     * Extracts thinking content from block object, using either the thinking field
+     * or falling back to text field. Returns standardized thinking content block.
+     *
+     * @param blockObj - Content block object with thinking or text field
+     * @returns ThinkingContentBlock with extracted thinking content
+     */
+    private normalizeThinkingBlock;
+    /**
+     * Normalize tool result content blocks
+     *
+     * Extracts tool result data from block object, mapping content and tool_use_id
+     * fields to the standardized tool result format.
+     *
+     * @param blockObj - Tool result block object with content and tool_use_id
+     * @returns ToolResultContentBlock with extracted result data
+     */
+    private normalizeToolResultBlock;
+    /**
+     * Normalize tool use content blocks
+     *
+     * Extracts tool invocation data from block object, mapping id, name, input,
+     * and tool_use_id fields to the standardized tool use format.
+     *
+     * @param blockObj - Tool use block object with tool invocation data
+     * @returns ToolUseContentBlock with extracted tool invocation data
+     */
+    private normalizeToolUseBlock;
+    /**
+     * Parse tool input from payload supporting multiple Codex formats
+     *
+     * Extracts and normalizes tool input arguments from different payload formats:
+     * - custom_tool_call: wraps input in an object
+     * - function_call: parses arguments (string or object)
+     * Handles JSON parsing for stringified arguments with fallback to wrapped format.
+     *
+     * @param payload - Tool call payload with input or arguments field
+     * @returns Parsed tool input as object, empty object if no input found
+     */
+    private parseToolInput;
+    /**
+     * Process message payload and append content blocks to array
+     *
+     * Extracts message content array from payload and processes each content block,
+     * appending normalized blocks to the provided content array.
+     *
+     * @param payload - Message payload object with content array
+     * @param content - Array to append processed content blocks to (modified in place)
+     */
+    private processMessage;
+    /**
+     * Process and normalize message content blocks from array
+     *
+     * Iterates through message content array, normalizing each block to the
+     * unified ContentBlock format. Filters out any null results from normalization.
+     *
+     * @param msgContent - Array of raw message content blocks
+     * @returns Array of normalized ContentBlock objects
+     */
+    private processMessageContent;
+    /**
+     * Process reasoning payload and append thinking blocks to content array
+     *
+     * Extracts summary array from reasoning payload and processes it into
+     * thinking content blocks, appending them to the provided content array.
+     *
+     * @param payload - Reasoning payload object with summary array
+     * @param content - Array to append thinking blocks to (modified in place)
+     */
+    private processReasoning;
+    /**
+     * Process reasoning summary into thinking content blocks
+     *
+     * Extracts text from summary_text type blocks in the summary array and
+     * converts them to thinking content blocks.
+     *
+     * @param summary - Array of summary blocks from reasoning payload
+     * @returns Array of ThinkingContentBlock objects extracted from summary
+     */
+    private processReasoningContent;
+    /**
+     * Process Codex response item into a CleanMessage
+     *
+     * Transforms a Codex raw entry (response_item) into a normalized message.
+     * Handles different item types:
+     * - custom_tool_call/function_call → tool use blocks (assistant)
+     * - custom_tool_call_output/function_call_output → tool result blocks (assistant)
+     * - message → text content (user or assistant based on role)
+     * - reasoning → thinking blocks (assistant)
+     * Returns null if no content blocks are generated.
+     *
+     * @param item - Codex raw entry to process
+     * @returns CleanMessage with type, content, and timestamp, or null if no content
+     */
+    private processResponseItem;
+    /**
+     * Process tool call payload and append tool use block to content
+     *
+     * Parses tool input from payload and creates a tool_use content block with
+     * call ID, input, and tool name. Appends the block to the provided array.
+     *
+     * @param payload - Tool call payload with name, input/arguments, and call_id
+     * @param content - Array to append tool use block to (modified in place)
+     */
+    private processToolCall;
+    /**
+     * Process tool output payload and append tool result block to content
+     *
+     * Extracts tool execution output from payload and creates a tool_result
+     * content block with the output content and tool_use_id. Appends the block
+     * to the provided array.
+     *
+     * @param payload - Tool output payload with output field and call_id
+     * @param content - Array to append tool result block to (modified in place)
+     */
+    private processToolOutput;
+    /**
+     * Transform Codex rawEntries to unified message format with turn IDs
+     *
+     * Performs complete transformation pipeline:
+     * 1. Filters out event_msg and turn_context entries
+     * 2. Processes each response_item into a message
+     * 3. Sorts messages by timestamp
+     * 4. Combines tool_use and tool_result messages
+     * 5. Assigns turn IDs to all messages
+     *
+     * @param rawEntries - Array of Codex raw entries from session
+     * @returns Array of CleanMessage objects with turn IDs and combined tool blocks
+     */
+    private transformCodexEntries;
+}