/** * ChunkBuilder service - Builds visualization chunks from parsed session data. * * Responsibilities: * - Group messages into chunks (user message + responses) * - Attach subagents to chunks * - Build waterfall chart data * - Calculate chunk metrics * * This module orchestrates chunk building using specialized modules: * - MessageClassifier: Classify messages into categories * - ChunkFactory: Create individual chunk objects * - ProcessLinker: Link subagent processes to chunks * - SemanticStepExtractor: Extract semantic steps from AI chunks * - SemanticStepGrouper: Group semantic steps for UI * - ToolExecutionBuilder: Build tool execution tracking * - SubagentDetailBuilder: Build subagent drill-down details * - ConversationGroupBuilder: Alternative grouping strategy */ import {  type Chunk,  type ConversationGroup,  EMPTY_METRICS,  type EnhancedChunk,  isAIChunk,  isCompactChunk,  isSystemChunk,  isUserChunk,  type MessageCategory,  type ParsedMessage,  type Process,  type Session,  type SessionDetail,  type SessionMetrics,  type SubagentDetail,  type TokenUsage,} from '@main/types';import { calculateMetrics } from '@main/utils/jsonl';import { createLogger } from '@shared/utils/logger'; import type { WaterfallData, WaterfallItem } from '@shared/types'; const logger = createLogger('Service:ChunkBuilder'); import { classifyMessages } from '../parsing/MessageClassifier'; import {  buildAIChunkFromBuffer,  buildCompactChunk,  buildSystemChunk,  buildUserChunk,} from './ChunkFactory';import { buildGroups as buildConversationGroups } from './ConversationGroupBuilder';import { buildSubagentDetail as buildSubagentDetailFn } from './SubagentDetailBuilder'; import type { SubagentResolver } from '../discovery/SubagentResolver';import type { FileSystemProvider } from '../infrastructure/FileSystemProvider';import type { SessionParser } from '../parsing/SessionParser'; export class ChunkBuilder {  // ===========================================================================  // Chunk Building  // ===========================================================================   /**   * Build chunks from messages using 4-category classification.   * Produces independent UserChunks, AIChunks, and SystemChunks.   *   * Categories:   * - User: Genuine user input (creates UserChunk, renders RIGHT)   * - System: Command output <local-command-stdout> (creates SystemChunk, renders LEFT)   * - Hard Noise: Filtered out entirely (system metadata, caveats, reminders)   * - AI: All other messages grouped into AIChunks (renders LEFT)   *   * All chunk types are INDEPENDENT - no pairing between User and AI.   */  buildChunks(messages: ParsedMessage[], subagents: Process[] = []): EnhancedChunk[] {    const chunks: EnhancedChunk[] = [];     // Filter to main thread messages (non-sidechain)    const mainMessages = messages.filter((m) => !m.isSidechain);    logger.debug(`Total messages: ${messages.length}, Main thread: ${mainMessages.length}`);     // Classify each message into categories using MessageClassifier    const classified = classifyMessages(mainMessages);     // Log classification summary    const categoryCounts = new Map<MessageCategory, number>();    for (const { category } of classified) {      categoryCounts.set(category, (categoryCounts.get(category) ?? 0) + 1);    }    logger.debug('Message classification:', Object.fromEntries(categoryCounts));     // Build chunks from classification - AI chunks are INDEPENDENT    let aiBuffer: ParsedMessage[] = [];     for (const { message, category } of classified) {      switch (category) {        case 'hardNoise':          // Skip - filtered out          break;         case 'compact':          // Flush any buffered AI messages first          if (aiBuffer.length > 0) {            chunks.push(buildAIChunkFromBuffer(aiBuffer, subagents, messages));            aiBuffer = [];          }          chunks.push(buildCompactChunk(message));          break;         case 'user':          // Flush any buffered AI messages first          if (aiBuffer.length > 0) {            chunks.push(buildAIChunkFromBuffer(aiBuffer, subagents, messages));            aiBuffer = [];          }          chunks.push(buildUserChunk(message));          break;         case 'system':          // Flush any buffered AI messages first          if (aiBuffer.length > 0) {            chunks.push(buildAIChunkFromBuffer(aiBuffer, subagents, messages));            aiBuffer = [];          }          chunks.push(buildSystemChunk(message));          break;         case 'ai':          aiBuffer.push(message);          break;      }    }     // Flush remaining AI buffer    if (aiBuffer.length > 0) {      chunks.push(buildAIChunkFromBuffer(aiBuffer, subagents, messages));    }     // Log final chunk summary    const userChunkCount = chunks.filter(isUserChunk).length;    const aiChunkCount = chunks.filter(isAIChunk).length;    const systemChunkCount = chunks.filter(isSystemChunk).length;    const compactChunkCount = chunks.filter(isCompactChunk).length;    logger.debug(      `Created ${chunks.length} chunks: ${userChunkCount} user, ${aiChunkCount} AI, ${systemChunkCount} system, ${compactChunkCount} compact`    );     return chunks;  }   // ===========================================================================  // Simplified Grouping Strategy (delegates to ConversationGroupBuilder)  // ===========================================================================   /**   * Build conversation groups using simplified grouping strategy.   * Groups one user message with all AI responses until the next user message.   *   * This is a cleaner alternative to buildChunks() that:   * - Uses simpler time-based grouping   * - Separates Task executions from regular tool executions   * - Links subagents more explicitly via TaskExecution   */  buildGroups(messages: ParsedMessage[], subagents: Process[]): ConversationGroup[] {    return buildConversationGroups(messages, subagents);  }   // ===========================================================================  // Session Detail Building  // ===========================================================================   /**   * Build a complete SessionDetail from parsed data.   */  buildSessionDetail(    session: Session,    messages: ParsedMessage[],    subagents: Process[]  ): SessionDetail {    // Build chunks    const chunks = this.buildChunks(messages, subagents);     // Calculate overall metrics    const metrics = calculateMetrics(messages);     return {      session,      messages,      chunks,      processes: subagents,      metrics,    };  }   /**   * Build waterfall chart data from chunks and resolved processes.   */  buildWaterfallData(chunks: Chunk[], processes: Process[]): WaterfallData {    const items: WaterfallItem[] = [];     for (const chunk of chunks) {      const baseChunkItem: WaterfallItem = {        id: chunk.id,        label: this.getChunkLabel(chunk),        startTime: chunk.startTime,        endTime: chunk.endTime,        durationMs: chunk.durationMs,        tokenUsage: this.toTokenUsage(chunk.metrics),        level: 0,        type: 'chunk',        isParallel: false,      };      items.push(baseChunkItem);       if (isAIChunk(chunk)) {        for (const toolExec of chunk.toolExecutions) {          const endTime = toolExec.endTime ?? toolExec.startTime;          items.push({            id: `tool-${toolExec.toolCall.id}`,            label: toolExec.toolCall.name,            startTime: toolExec.startTime,            endTime,            durationMs:              toolExec.durationMs ?? Math.max(endTime.getTime() - toolExec.startTime.getTime(), 0),            tokenUsage: {              input_tokens: 0,              output_tokens: 0,            },            level: 1,            type: 'tool',            isParallel: false,            parentId: chunk.id,          });        }         for (const process of chunk.processes) {          items.push({            id: `subagent-${process.id}`,            label: process.description || process.subagentType || process.id,            startTime: process.startTime,            endTime: process.endTime,            durationMs: process.durationMs,            tokenUsage: this.toTokenUsage(process.metrics),            level: 1,            type: 'subagent',            isParallel: process.isParallel,            parentId: chunk.id,            metadata: {              subagentType: process.subagentType,              messageCount: process.messages.length,            },          });        }      }    }     // Add any process that was not attached to an AI chunk (defensive fallback)    for (const process of processes) {      const itemId = `subagent-${process.id}`;      if (items.some((item) => item.id === itemId)) {        continue;      }      items.push({        id: itemId,        label: process.description || process.subagentType || process.id,        startTime: process.startTime,        endTime: process.endTime,        durationMs: process.durationMs,        tokenUsage: this.toTokenUsage(process.metrics),        level: 0,        type: 'subagent',        isParallel: process.isParallel,        metadata: {          subagentType: process.subagentType,          messageCount: process.messages.length,        },      });    }     const sortedItems = [...items];    sortedItems.sort((a, b) => a.startTime.getTime() - b.startTime.getTime());     if (sortedItems.length === 0) {      const now = new Date();      return {        items: [],        minTime: now,        maxTime: now,        totalDurationMs: 0,      };    }     const minTime = sortedItems.reduce(      (min, item) => (item.startTime.getTime() < min.getTime() ? item.startTime : min),      sortedItems[0].startTime    );    const maxTime = sortedItems.reduce(      (max, item) => (item.endTime.getTime() > max.getTime() ? item.endTime : max),      sortedItems[0].endTime    );     return {      items: sortedItems,      minTime,      maxTime,      totalDurationMs: Math.max(maxTime.getTime() - minTime.getTime(), 0),    };  }   // ===========================================================================  // Utility Methods  // ===========================================================================   /**   * Get total metrics for all chunks.   */  getTotalChunkMetrics(chunks: (Chunk | EnhancedChunk)[]): SessionMetrics {    if (chunks.length === 0) {      return { ...EMPTY_METRICS };    }     let durationMs = 0;    let inputTokens = 0;    let outputTokens = 0;    let cacheReadTokens = 0;    let cacheCreationTokens = 0;    let messageCount = 0;     for (const chunk of chunks) {      durationMs += chunk.durationMs;      inputTokens += chunk.metrics.inputTokens;      outputTokens += chunk.metrics.outputTokens;      cacheReadTokens += chunk.metrics.cacheReadTokens;      cacheCreationTokens += chunk.metrics.cacheCreationTokens;      messageCount += chunk.metrics.messageCount;    }     return {      durationMs,      totalTokens: inputTokens + outputTokens,      inputTokens,      outputTokens,      cacheReadTokens,      cacheCreationTokens,      messageCount,    };  }   /**   * Find chunk containing a specific message UUID.   */  findChunkByMessageId(    chunks: (Chunk | EnhancedChunk)[],    messageUuid: string  ): Chunk | EnhancedChunk | undefined {    return chunks.find((c) => {      // UserChunk: check userMessage      if (isUserChunk(c)) {        return c.userMessage.uuid === messageUuid;      }      // AIChunk: check responses      if (isAIChunk(c)) {        return c.responses.some((r) => r.uuid === messageUuid);      }      return false;    });  }   /**   * Find chunk containing a specific subagent.   * Only AIChunks have processes.   */  findChunkBySubagentId(    chunks: (Chunk | EnhancedChunk)[],    subagentId: string  ): Chunk | EnhancedChunk | undefined {    return chunks.find((c) => {      if (isAIChunk(c)) {        return c.processes.some((s: Process) => s.id === subagentId);      }      return false;    });  }   private getChunkLabel(chunk: Chunk): string {    switch (chunk.chunkType) {      case 'user':        return 'User';      case 'ai':        return 'Assistant';      case 'system':        return 'System';      case 'compact':        return 'Compact';      default:        return 'Chunk';    }  }   private toTokenUsage(metrics: SessionMetrics): TokenUsage {    return {      input_tokens: metrics.inputTokens,      output_tokens: metrics.outputTokens,      cache_read_input_tokens: metrics.cacheReadTokens || undefined,      cache_creation_input_tokens: metrics.cacheCreationTokens || undefined,    };  }   // ===========================================================================  // Subagent Detail Building (for drill-down)  // ===========================================================================   /**   * Build detailed information for a specific subagent.   * Used for drill-down modal to show subagent's internal execution.   *   * @param projectId - Project ID   * @param sessionId - Parent session ID (currently unused, kept for API consistency)   * @param subagentId - Subagent ID to load   * @param sessionParser - SessionParser instance for parsing subagent file   * @param subagentResolver - SubagentResolver instance for nested subagents   * @returns SubagentDetail or null if not found   */  async buildSubagentDetail(    projectId: string,    sessionId: string,    subagentId: string,    sessionParser: SessionParser,    subagentResolver: SubagentResolver,    fsProvider: FileSystemProvider,    projectsDir: string  ): Promise<SubagentDetail | null> {    // Delegate to the extracted module, passing buildChunks as a callback    return buildSubagentDetailFn(      projectId,      sessionId,      subagentId,      sessionParser,      subagentResolver,      (messages, subagents) => this.buildChunks(messages, subagents),      fsProvider,      projectsDir    );  }}