@qiaolei81/copilot-session-viewer 0.1.8 → 0.2.0

package/src/services/eventNormalizer.js

@@ -0,0 +1,291 @@
+/**
+ * EventNormalizer - Unified Event Format Transformer
+ *
+ * Converts tool events from different AI session formats (Copilot, Claude, Pi-Mono)
+ * into a single, consistent schema for frontend consumption.
+ *
+ * Key transformations:
+ * - Normalizes tool call structure to UnifiedToolCall schema
+ * - Computes consistent status fields ('pending' | 'running' | 'completed' | 'error')
+ * - Adds timing metadata (startTime, endTime, duration)
+ * - Handles edge cases (orphaned events, missing fields)
+ *
+ * Usage:
+ *   const normalizer = new EventNormalizer();
+ *   const normalizedEvents = normalizer.normalizeEvents(rawEvents, 'copilot');
+ */
+
+class EventNormalizer {
+  /**
+   * Normalize all events to unified format
+   * @param {Array} events - Raw events from parsers (after matching)
+   * @param {string} _source - 'copilot' | 'claude' | 'pi-mono'
+   * @returns {Array} - Normalized events
+   */
+  normalizeEvents(events, _source) {
+    if (!Array.isArray(events)) {
+      console.warn('[EventNormalizer] normalizeEvents: events is not an array', typeof events);
+      return [];
+    }
+
+    return events
+      .filter(event => {
+        // Filter out Claude tool_result wrappers (marked by sessionService._matchClaudeToolResults)
+        if (event._isToolResultWrapper) {
+          return false;
+        }
+        return true;
+      })
+      .map(event => this.normalizeEvent(event, _source));
+  }
+
+  /**
+   * Normalize a single event
+   * @param {Object} event - Raw event
+   * @param {string} source - Source format
+   * @returns {Object} - Normalized event
+   */
+  normalizeEvent(event, source) {
+    if (!event || typeof event !== 'object') {
+      console.warn('[EventNormalizer] normalizeEvent: invalid event', event);
+      return event;
+    }
+
+    // Handle assistant messages with tools
+    if (this._isAssistantMessage(event)) {
+      return this._normalizeAssistantMessage(event, source);
+    }
+
+    // Handle timeline events (tool.execution_start/complete, subagent events)
+    if (this._isTimelineEvent(event)) {
+      return this._normalizeTimelineEvent(event, source);
+    }
+
+    // Pass through other events unchanged
+    return event;
+  }
+
+  /**
+   * Check if event is an assistant message with tools (needs normalization)
+   * @private
+   */
+  _isAssistantMessage(event) {
+    // Check if event has tools array (works for all sources)
+    if (event.data?.tools && Array.isArray(event.data.tools) && event.data.tools.length > 0) {
+      return true;
+    }
+    // Fallback: check specific types (Copilot/Claude legacy)
+    return event.type === 'assistant.message' || event.type === 'assistant' || event.type === 'user.message' || event.type === 'user';
+  }
+
+  /**
+   * Check if event is a timeline event (tool/subagent events)
+   * @private
+   */
+  _isTimelineEvent(event) {
+    return event.type?.startsWith('tool.') || event.type?.startsWith('subagent.');
+  }
+
+  /**
+   * Normalize assistant message with embedded tools
+   * @private
+   */
+  _normalizeAssistantMessage(event, source) {
+    const normalized = { ...event };
+
+    // Normalize tools array if present
+    if (event.data?.tools && Array.isArray(event.data.tools)) {
+      normalized.data = {
+        ...event.data,
+        tools: event.data.tools
+          .filter(tool => tool.type !== 'tool_result')  // Filter out orphan tool_result
+          .map(tool => this._normalizeToolCall(tool, source, event.timestamp))
+      };
+    }
+
+    return normalized;
+  }
+
+  /**
+   * Normalize a tool call to unified schema
+   *
+   * UnifiedToolCall schema:
+   * {
+   *   id: string,
+   *   name: string,
+   *   startTime: string (ISO 8601),
+   *   endTime: string | null,
+   *   status: 'pending' | 'running' | 'completed' | 'error',
+   *   input: Record<string, any>,
+   *   result: string | null,
+   *   error: string | null,
+   *   metadata: {
+   *     source: string,
+   *     duration?: number,
+   *     ...
+   *   }
+   * }
+   *
+   * @private
+   */
+  _normalizeToolCall(tool, source, messageTimestamp) {
+    // Handle Copilot/Claude format with _matched flag
+    if (tool.type === 'tool_use') {
+      const status = this._computeStatus(tool);
+      const startTime = messageTimestamp;
+      const endTime = tool._matched ? messageTimestamp : null;
+
+      return {
+        type: 'tool_use',  // Preserve type for frontend compatibility
+        id: tool.id,
+        name: tool.name,
+        startTime,
+        endTime,
+        status,
+        input: tool.input || {},
+        result: tool.result || null,
+        error: tool.error || null,
+        metadata: {
+          source,
+          matched: tool._matched,
+          duration: this._computeDuration(startTime, endTime)
+        }
+      };
+    }
+
+    // Handle Pi-Mono format (already has status)
+    if (tool.name && tool.status) {
+      const startTime = messageTimestamp;
+      // Normalize 'success' to 'completed' for backward compatibility
+      const normalizedStatus = tool.status === 'success' ? 'completed' : tool.status;
+      const endTime = normalizedStatus === 'completed' || normalizedStatus === 'error'
+        ? messageTimestamp
+        : null;
+
+      return {
+        id: tool.id || this._generateToolId(),
+        name: tool.name,
+        startTime,
+        endTime,
+        status: normalizedStatus,
+        input: tool.input || {},
+        result: tool.isError ? null : (tool.result || null),
+        error: tool.isError ? tool.result : null,
+        metadata: {
+          source,
+          duration: this._computeDuration(startTime, endTime)
+        }
+      };
+    }
+
+    // Fallback: minimal normalization for unknown formats
+    console.warn('[EventNormalizer] Unknown tool format, applying fallback normalization', tool);
+    return {
+      id: tool.id || this._generateToolId(),
+      name: tool.name || 'unknown',
+      startTime: messageTimestamp,
+      endTime: null,
+      status: 'running',
+      input: tool.input || {},
+      result: null,
+      error: null,
+      metadata: {
+        source,
+        fallback: true
+      }
+    };
+  }
+
+  /**
+   * Compute tool status from tool object
+   * @private
+   */
+  _computeStatus(tool) {
+    // Explicit error indication
+    if (tool.error) {
+      return 'error';
+    }
+
+    // Has result = completed (regardless of _matched flag)
+    if (tool.result !== undefined && tool.result !== null && tool.result !== '') {
+      return 'completed';
+    }
+
+    // Explicitly unmatched with no result
+    if (tool._matched === false) {
+      return 'running';
+    }
+
+    // Matched = completed
+    if (tool._matched) {
+      return 'completed';
+    }
+
+    // No match info: assume running
+    return 'running';
+  }
+
+  /**
+   * Compute duration in milliseconds from start/end timestamps
+   * @private
+   */
+  _computeDuration(startTime, endTime) {
+    if (!startTime || !endTime) {
+      return undefined;
+    }
+
+    try {
+      const start = new Date(startTime);
+      const end = new Date(endTime);
+
+      if (isNaN(start.getTime()) || isNaN(end.getTime())) {
+        return undefined;
+      }
+
+      const duration = end.getTime() - start.getTime();
+      return duration >= 0 ? duration : undefined;
+    } catch (err) {
+      return undefined;
+    }
+  }
+
+  /**
+   * Generate a unique tool ID
+   * @private
+   */
+  _generateToolId() {
+    return `tool-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+
+  /**
+   * Normalize timeline events (tool.execution_start/complete, subagent events)
+   * Ensures consistent schema for these events
+   * @private
+   */
+  _normalizeTimelineEvent(event) {
+    // For tool.execution_start/complete, ensure consistent schema
+    if (event.type === 'tool.execution_start' || event.type === 'tool.execution_complete') {
+      return {
+        ...event,
+        data: {
+          ...event.data,
+          // Normalize field names for consistency
+          toolCallId: event.data?.toolCallId || event.data?.id,
+          toolName: event.data?.toolName || event.data?.tool || event.data?.name,
+          // Preserve original fields
+          ...event.data
+        }
+      };
+    }
+
+    // Subagent events: pass through (already have consistent schema)
+    if (event.type?.startsWith('subagent.')) {
+      return event;
+    }
+
+    // Unknown timeline event: pass through
+    return event;
+  }
+}
+
+module.exports = EventNormalizer;

package/src/services/insightService.js

@@ -12,21 +12,74 @@ const config = require('../config');
 const processManager = require('../utils/processManager');
 
 class InsightService {
-  constructor(sessionDir) {
-    this.sessionDir = sessionDir;
+  constructor() {
+    // No longer needs session directories - paths are passed directly
+  }
+
+  /**
+   * Get CLI tool configuration based on session source
+   * @private
+   */
+  _getToolConfig(source, sessionPath) {
+    const configs = {
+      copilot: {
+        name: 'Copilot',
+        cli: 'copilot',
+        args: (tmpDir, prompt) => ['--config-dir', tmpDir, '--yolo', '-p', prompt],
+        cwd: sessionPath
+      },
+      claude: {
+        name: 'Claude Code',
+        cli: 'claude',
+        args: (_tmpDir, prompt) => ['-p', prompt, '--dangerously-skip-permissions'],
+        cwd: sessionPath
+      },
+      'pi-mono': {
+        name: 'Pi',
+        cli: 'pi',
+        args: (_tmpDir, prompt) => ['-p', prompt],
+        cwd: sessionPath
+      }
+    };
+
+    return configs[source] || configs.copilot; // fallback to copilot
   }
 
   /**
    * Generate or retrieve insight report
-   * @param {string} sessionId - Session UUID
+   * @param {string} sessionId - Session ID
+   * @param {string} sessionPath - Full path to session directory
+   * @param {string} source - Session source: 'copilot', 'claude', or 'pi-mono'
    * @param {boolean} forceRegenerate - Force new generation
    * @returns {Promise<Object>} Insight status and report
    */
-  async generateInsight(sessionId, forceRegenerate = false) {
-    const sessionPath = path.join(this.sessionDir, sessionId);
+  async generateInsight(sessionId, sessionPath, source = 'copilot', forceRegenerate = false) {
     const insightFile = path.join(sessionPath, 'agent-review.md');
     const lockFile = path.join(sessionPath, 'agent-review.md.lock');
-    const eventsFile = path.join(sessionPath, 'events.jsonl');
+    
+    // Determine events file location based on directory structure
+    // Try standard events.jsonl first, then <sessionId>.jsonl (for file-type sessions),
+    // finally *_<sessionId>.jsonl (for Pi-Mono timestamped sessions)
+    let eventsFile = path.join(sessionPath, 'events.jsonl');
+    try {
+      await fs.access(eventsFile);
+    } catch {
+      // Try <sessionId>.jsonl (common for Claude file-type sessions)
+      try {
+        eventsFile = path.join(sessionPath, `${sessionId}.jsonl`);
+        await fs.access(eventsFile);
+      } catch {
+        // Try *_<sessionId>.jsonl (Pi-Mono format: YYYY-MM-DDTHH-mm-ss-SSSZ_<uuid>.jsonl)
+        const entries = await fs.readdir(sessionPath);
+        const piFile = entries.find(f => f.endsWith(`_${sessionId}.jsonl`));
+        if (piFile) {
+          eventsFile = path.join(sessionPath, piFile);
+        }
+      }
+    }
+
+    const toolConfig = this._getToolConfig(source, sessionPath);
+    const toolName = toolConfig.name;
 
     // Check if complete insight exists
     if (!forceRegenerate) {
@@ -63,7 +116,7 @@ class InsightService {
             // Still valid, return generating status
             return {
               status: 'generating',
-              report: '# Generating Copilot Insight...\n\nAnother request is currently generating this insight. Please wait.',
+              report: `# Generating ${toolName} Insight...\n\nAnother request is currently generating this insight. Please wait.`,
               startedAt: lockStats.birthtime,
               lastUpdate: lockStats.mtime,
               ageMs: Date.now() - lockStats.birthtime.getTime()
@@ -106,77 +159,92 @@ class InsightService {
     }
 
     // Start generation
-    await this._spawnCopilotProcess(sessionId, sessionPath, eventsFile, insightFile, lockFile);
+    await this._spawnAnalysisProcess(sessionPath, eventsFile, insightFile, lockFile, toolConfig);
 
     return {
       status: 'generating',
-      report: '# Generating Copilot Insight...\n\nAnalysis in progress. Please wait.',
+      report: `# Generating ${toolName} Insight...\n\nAnalysis in progress. Please wait.`,
       startedAt: new Date()
     };
   }
 
   /**
-   * Spawn copilot process safely (no shell)
+   * Spawn analysis process safely (no shell)
    * @private
    */
-  async _spawnCopilotProcess(sessionId, sessionPath, eventsFile, insightFile, lockFile) {
+  async _spawnAnalysisProcess(sessionPath, eventsFile, insightFile, lockFile, toolConfig) {
+    const sessionId = path.basename(sessionPath); // Extract session ID from path
     const tmpDir = path.join(os.tmpdir(), `agent-review-${sessionId}-${Date.now()}`);
-    await fs.mkdir(tmpDir, { recursive: true });
+    await fs.mkdir(tmpDir, { recursive: true});
 
-    const prompt = this._buildPrompt(insightFile);
+    const prompt = this._buildPrompt(insightFile, eventsFile);
     const outputFile = path.join(sessionPath, 'agent-review.md.tmp');
 
-    // Spawn copilot directly (no shell)
-    const copilotPath = 'copilot';
-    const args = ['--config-dir', tmpDir, '--yolo', '-p', prompt];
+    // Spawn analysis tool directly (no shell)
+    const cliPath = toolConfig.cli;
+    const args = toolConfig.args(tmpDir, prompt);
+    
+    console.log(`🤖 Starting ${toolConfig.name} analysis: ${cliPath} ${args.slice(0, 2).join(' ')}...`);
+    console.log(`📋 Args count: ${args.length}, prompt length: ${prompt.length} chars`);
     
-    // Use system PATH - copilot should be in the user's PATH
-    const copilotProcess = spawn(copilotPath, args, {
+    // Use system PATH - CLI should be in the user's PATH
+    const analysisProcess = spawn(cliPath, args, {
       env: { ...process.env },
       cwd: sessionPath,
       stdio: ['pipe', 'pipe', 'pipe']
     });
 
     // Register for cleanup
-    processManager.register(copilotProcess, { name: `insight-${sessionId}` });
-
-    // Pipe events file to stdin
-    const eventsStream = fsSync.createReadStream(eventsFile);
-    // Handle EPIPE: if copilot exits before stdin is fully written, suppress the error
-    copilotProcess.stdin.on('error', (err) => {
-      if (err.code === 'EPIPE') {
-        eventsStream.destroy();
-      } else {
-        console.error('❌ stdin error:', err);
-      }
-    });
-    eventsStream.pipe(copilotProcess.stdin);
+    processManager.register(analysisProcess, { name: `insight-${sessionId}` });
+
+    // Pipe events file to stdin (for tools that read from stdin like copilot)
+    // Claude Code and Pi read files directly, so they don't need stdin
+    if (toolConfig.cli === 'copilot') {
+      const eventsStream = fsSync.createReadStream(eventsFile);
+      // Handle EPIPE: if process exits before stdin is fully written, suppress the error
+      analysisProcess.stdin.on('error', (err) => {
+        if (err.code === 'EPIPE') {
+          eventsStream.destroy();
+        } else {
+          console.error('❌ stdin error:', err);
+        }
+      });
+      eventsStream.pipe(analysisProcess.stdin);
+    } else {
+      // Close stdin for tools that don't need it
+      analysisProcess.stdin.end();
+    }
 
     // Capture output
     const outputStream = fsSync.createWriteStream(outputFile);
-    copilotProcess.stdout.pipe(outputStream);
+    analysisProcess.stdout.pipe(outputStream);
 
     // Capture stderr with size limit
     const stderrChunks = [];
     let stderrSize = 0;
     const MAX_STDERR = 64 * 1024; // 64KB cap
 
-    copilotProcess.stderr.on('data', (data) => {
+    analysisProcess.stderr.on('data', (data) => {
       if (stderrSize < MAX_STDERR) {
         stderrChunks.push(data);
         stderrSize += data.length;
       }
     });
 
-    copilotProcess.on('close', async (code) => {
+    analysisProcess.on('close', async (code) => {
       try {
         outputStream.end();
 
+        const stderr = Buffer.concat(stderrChunks).toString('utf-8').slice(0, MAX_STDERR);
+        console.log(`📋 ${toolConfig.name} process exited with code ${code}`);
+        if (stderr) {
+          console.log(`📋 ${toolConfig.name} stderr:`, stderr.substring(0, 500));
+        }
+
         if (code !== 0) {
-          const stderr = Buffer.concat(stderrChunks).toString('utf-8').slice(0, MAX_STDERR);
-          console.error('❌ Copilot CLI failed:', stderr);
+          console.error(`❌ ${toolConfig.name} CLI failed (code ${code}):`, stderr);
           await fs.writeFile(insightFile,
-            `# ❌ Generation Failed\n\n\`\`\`\n${stderr}\n\`\`\`\n`,
+            `# ❌ Generation Failed\n\nExit code: ${code}\n\n\`\`\`\n${stderr || '(no error output)'}\n\`\`\`\n`,
             'utf-8'
           );
         } else {
@@ -212,8 +280,8 @@ class InsightService {
       }
     });
 
-    copilotProcess.on('error', async (err) => {
-      console.error('❌ Failed to spawn copilot:', err);
+    analysisProcess.on('error', async (err) => {
+      console.error(`❌ Failed to spawn ${toolConfig.name}:`, err);
       await fs.unlink(lockFile).catch(() => {});
       await fs.rm(tmpDir, { recursive: true, force: true }).catch(() => {});
     });
@@ -223,19 +291,26 @@ class InsightService {
    * Build insight generation prompt
    * @private
    */
-  _buildPrompt(outputPath) {
+  _buildPrompt(outputPath, eventsFile) {
     const sessionDir = path.dirname(outputPath);
+    const eventsFilename = path.basename(eventsFile);
     const workDir = `${sessionDir}/.output`;
-    return `You are an expert AI agent evaluator. The current working directory is a Copilot CLI session folder (located at ~/.copilot/session-state/<session_id>/). It contains the raw session data from an AI coding agent run.
-
+    
+    // For Pi-Mono: emphasize analyzing ONLY the specified file
+    const fileInstruction = eventsFilename.includes('_') 
+      ? `\n**IMPORTANT**: This directory may contain multiple .jsonl files. You MUST analyze ONLY the file named \`${eventsFilename}\`. Do NOT read or analyze any other .jsonl files in this directory.\n`
+      : '';
+    
+    return `You are an expert AI agent evaluator. The current working directory is an AI coding agent session folder. It contains the raw session data from an agent run.
+${fileInstruction}
 **Step 1 — Discover session files.** Run \`ls -la\` to see what's available, then note which files exist:
-- \`events.jsonl\` — the main session event log (JSONL, one JSON event per line). Primary data source. May be large.
+- \`${eventsFilename}\` — the main session event log (JSONL, one JSON event per line). Primary data source. May be large. **This is the ONLY events file you should analyze.**
 - \`plan.md\` — the agent's plan (if it exists).
 - \`workspace.yaml\` — workspace configuration (if it exists).
 - Any other relevant files.
 
 **Step 2 — Spawn 3 sub-agents for parallel analysis.** First create the working directory: \`mkdir -p ${workDir}\`. Then use the Task tool to launch ALL of the following sub-agents simultaneously (in a single message with multiple Task tool calls). Each sub-agent should:
-- Read \`events.jsonl\` from \`${sessionDir}\` (use Bash: \`cat\`, \`jq\`, or \`python3\` to parse)
+- Read \`${eventsFilename}\` from \`${sessionDir}\` (use Bash: \`cat\`, \`jq\`, or \`python3\` to parse) **— ONLY this file, ignore others**
 - Read other session files as needed
 - Write its findings to an intermediate file in \`${workDir}/\`
 - Return a summary of its findings
@@ -362,8 +437,22 @@ IMPORTANT CONSTRAINTS:
   /**
    * Get insight status
    */
-  async getInsightStatus(sessionId) {
-    const sessionPath = path.join(this.sessionDir, sessionId);
+  /**
+   * Get insight status
+   * @param {string} sessionId - Session ID
+   * @param {string} sessionPath - Full path to session directory
+   * @param {string} source - Session source
+   * @returns {Promise<Object>} Status object
+   */
+  async getInsightStatus(sessionId, sessionPath, _source = 'copilot') {
+    return await this._getStatusForSource(sessionPath);
+  }
+
+  /**
+   * Get status for a specific session directory
+   * @private
+   */
+  async _getStatusForSource(sessionPath) {
     const insightFile = path.join(sessionPath, 'agent-review.md');
     const lockFile = path.join(sessionPath, 'agent-review.md.lock');
     const tmpFile = path.join(sessionPath, 'agent-review.md.tmp');
@@ -416,9 +505,12 @@ IMPORTANT CONSTRAINTS:
 
   /**
    * Delete insight report
+   * @param {string} sessionId - Session ID
+   * @param {string} sessionPath - Full path to session directory
+   * @param {string} source - Session source
+   * @returns {Promise<Object>} Result object
    */
-  async deleteInsight(sessionId) {
-    const sessionPath = path.join(this.sessionDir, sessionId);
+  async deleteInsight(sessionId, sessionPath, _source = 'copilot') {
     const insightFile = path.join(sessionPath, 'agent-review.md');
 
     try {