@qiaolei81/copilot-session-viewer 0.3.4 → 0.3.6

package/lib/parsers/README.md

@@ -1,239 +0,0 @@
-# Session Event Parsers
-
-Strategy pattern implementation for parsing session events from multiple formats.
-
-## Architecture
-
-```
-lib/parsers/
-├── base-parser.js       # Base parser interface
-├── copilot-parser.js    # Copilot CLI format parser
-├── claude-parser.js     # Claude Code format parser
-├── pi-mono-parser.js    # Pi-Mono format parser
-├── parser-factory.js    # Parser factory (auto-detection)
-└── index.js             # Export all parsers
-```
-
-## Design Pattern
-
-### Strategy Pattern
-
-- **Strategy Interface**: `BaseSessionParser` defines methods all parsers must implement
-- **Concrete Strategies**: `CopilotSessionParser`, `ClaudeSessionParser`, `PiMonoSessionParser` implement specific parsing logic
-- **Context**: `ParserFactory` automatically selects the appropriate strategy
-
-### Benefits
-
-1. **Extensible**: Add new formats by simply implementing `BaseSessionParser`
-2. **Decoupled**: Parsing logic is separated from consumers
-3. **Auto-detection**: `ParserFactory` automatically identifies formats
-4. **Unified Interface**: Different formats output the same data structure
-
-## Usage
-
-### Auto-detect Format
-
-```javascript
-const { ParserFactory } = require('./lib/parsers');
-
-const events = [...]; // Events read from jsonl
-const factory = new ParserFactory();
-
-// Auto-detect and parse
-const result = factory.parse(events);
-
-// Get parser type
-const parserType = factory.getParserType(events); // 'copilot', 'claude', or 'pi-mono'
-```
-
-### Use Specific Parser Directly
-
-```javascript
-const { CopilotSessionParser, ClaudeSessionParser, PiMonoSessionParser } = require('./lib/parsers');
-
-// Copilot CLI
-const copilotParser = new CopilotSessionParser();
-if (copilotParser.canParse(events)) {
-  const result = copilotParser.parse(events);
-}
-
-// Claude Code
-const claudeParser = new ClaudeSessionParser();
-if (claudeParser.canParse(events)) {
-  const result = claudeParser.parse(events);
-}
-
-// Pi-Mono
-const piMonoParser = new PiMonoSessionParser();
-if (piMonoParser.canParse(events)) {
-  const result = piMonoParser.parse(events);
-}
-```
-
-## Unified Output Format
-
-All parsers output the same data structure:
-
-```javascript
-{
-  metadata: {
-    sessionId: "...",
-    startTime: "...",
-    model: "...",
-    version: "...",
-    cwd: "...",
-    branch: "...",
-    // ...
-  },
-  turns: [
-    {
-      turnId: "...",
-      userMessage: {
-        id: "...",
-        content: "...",
-        timestamp: "..."
-      },
-      assistantMessages: [
-        {
-          id: "...",
-          content: "...",
-          toolRequests: [...],
-          timestamp: "..."
-        }
-      ],
-      toolCalls: [...]
-    }
-  ],
-  toolCalls: [...],
-  allEvents: [...] // Raw events
-}
-```
-
-## Supported Formats
-
-### 1. Copilot CLI Format
-
-**Characteristics:**
-- Event types: `session.start`, `user.message`, `assistant.message`, `tool.execution_start`
-- Structure: `{type, data: {...}, id, parentId}`
-- Tree relationship: Connected via `parentId`
-
-**Example:**
-```json
-{
-  "type": "session.start",
-  "data": {
-    "sessionId": "...",
-    "selectedModel": "claude-sonnet-4.5"
-  },
-  "id": "...",
-  "timestamp": "..."
-}
-```
-
-### 2. Claude Code Format
-
-**Characteristics:**
-- Event types: `user`, `assistant`, `file-history-snapshot`, `queue-operation`
-- Structure: `{type, uuid, parentUuid, message: {...}}`
-- Tree relationship: Connected via `parentUuid`
-
-**Example:**
-```json
-{
-  "type": "user",
-  "uuid": "...",
-  "parentUuid": null,
-  "sessionId": "...",
-  "message": {
-    "role": "user",
-    "content": "..."
-  }
-}
-```
-
-### 3. Pi-Mono Format
-
-**Characteristics:**
-- Event types: `message` (with role), `model_change`, `thinking_change`
-- Structure: `{type, role, message, toolResult, timestamp}`
-- Flat structure with parentId linkage for tool results
-
-**Example:**
-```json
-{
-  "type": "message",
-  "role": "user",
-  "message": "...",
-  "timestamp": "...",
-  "id": "..."
-}
-```
-
-## Adding New Formats
-
-1. Extend `BaseSessionParser`
-2. Implement all required methods
-3. Register in `ParserFactory`
-
-```javascript
-const BaseSessionParser = require('./base-parser');
-
-class MyCustomParser extends BaseSessionParser {
-  canParse(events) {
-    // Detection logic
-    return events.some(e => e.customField);
-  }
-
-  parse(events) {
-    return {
-      metadata: this.getMetadata(events),
-      turns: this.extractTurns(events),
-      toolCalls: this.extractToolCalls(events),
-      allEvents: events
-    };
-  }
-
-  getMetadata(events) { /* ... */ }
-  extractTurns(events) { /* ... */ }
-  extractToolCalls(events) { /* ... */ }
-}
-
-// Add to parser-factory.js
-this.parsers.push(new MyCustomParser());
-```
-
-## Testing
-
-Run example:
-```bash
-node examples/parser-usage.js
-```
-
-## API Documentation
-
-### BaseSessionParser
-
-Base class for all parsers.
-
-#### Methods
-
-- `canParse(events)` - Check if this format can be parsed
-- `parse(events)` - Parse events and return unified format
-- `getMetadata(events)` - Extract session metadata
-- `extractTurns(events)` - Extract conversation turns
-- `extractToolCalls(events)` - Extract tool calls
-
-### ParserFactory
-
-Parser factory for automatic format detection.
-
-#### Methods
-
-- `getParser(events)` - Return appropriate parser instance
-- `parse(events)` - Auto-detect and parse
-- `getParserType(events)` - Return parser type name
-
-## License
-
-MIT

package/lib/parsers/base-parser.js

@@ -1,53 +0,0 @@
-/**
- * Base Session Parser Interface
- * 
- * All session parsers must implement these methods
- */
-class BaseSessionParser {
-  /**
-   * Detect if this parser can handle the given events
-   * @param {Array<Object>} _events - Raw events from jsonl
-   * @returns {boolean}
-   */
-  canParse(_events) {
-    throw new Error('canParse() must be implemented');
-  }
-
-  /**
-   * Parse raw events into normalized format
-   * @param {Array<Object>} _events - Raw events from jsonl
-   * @returns {Object} Parsed session data
-   */
-  parse(_events) {
-    throw new Error('parse() must be implemented');
-  }
-
-  /**
-   * Get session metadata (sessionId, startTime, model, etc.)
-   * @param {Array<Object>} _events - Raw events
-   * @returns {Object} Session metadata
-   */
-  getMetadata(_events) {
-    throw new Error('getMetadata() must be implemented');
-  }
-
-  /**
-   * Extract turns (user message + assistant response pairs)
-   * @param {Array<Object>} _events - Raw events
-   * @returns {Array<Object>} Array of turns
-   */
-  extractTurns(_events) {
-    throw new Error('extractTurns() must be implemented');
-  }
-
-  /**
-   * Extract tool calls/executions
-   * @param {Array<Object>} _events - Raw events
-   * @returns {Array<Object>} Array of tool calls
-   */
-  extractToolCalls(_events) {
-    throw new Error('extractToolCalls() must be implemented');
-  }
-}
-
-module.exports = BaseSessionParser;

package/lib/parsers/claude-parser.js

@@ -1,181 +0,0 @@
-const BaseSessionParser = require('./base-parser');
-
-/**
- * Claude Code Session Parser
- * 
- * Parses events from Anthropic Claude Code CLI
- * Format: {type: "user"|"assistant", uuid: "...", parentUuid: "...", message: {...}}
- */
-class ClaudeSessionParser extends BaseSessionParser {
-  canParse(events) {
-    if (!events || events.length === 0) return false;
-    
-    // Check for Claude Code specific structure
-    return events.some(e => 
-      e.type && ['user', 'assistant'].includes(e.type) &&
-      e.uuid && Object.prototype.hasOwnProperty.call(e, 'parentUuid') && e.sessionId
-    );
-  }
-
-  parse(events) {
-    return {
-      metadata: this.getMetadata(events),
-      turns: this.extractTurns(events),
-      toolCalls: this.extractToolCalls(events),
-      allEvents: events
-    };
-  }
-
-  getMetadata(events) {
-    const firstUserMessage = events.find(e => e.type === 'user');
-    if (!firstUserMessage) return null;
-
-    // Extract model from assistant messages
-    const firstAssistant = events.find(e => e.type === 'assistant' && e.message?.model);
-    const model = firstAssistant?.message?.model || 'unknown';
-
-    return {
-      sessionId: firstUserMessage.sessionId,
-      startTime: firstUserMessage.timestamp,
-      model: model,
-      version: firstUserMessage.version,
-      producer: 'claude-code',
-      cwd: firstUserMessage.cwd,
-      gitRoot: null, // Not available in Claude format
-      branch: firstUserMessage.gitBranch,
-      repository: null // Not available in Claude format
-    };
-  }
-
-  extractTurns(events) {
-    const turns = [];
-    const messageEvents = events.filter(e => 
-      ['user', 'assistant'].includes(e.type) &&
-      e.type !== 'file-history-snapshot' &&
-      e.type !== 'queue-operation'
-    );
-
-    // Build parent-child tree
-    const eventMap = new Map();
-    for (const event of messageEvents) {
-      eventMap.set(event.uuid, event);
-    }
-
-    // Find root user messages (no parentUuid or parent is not a message)
-    const rootMessages = messageEvents.filter(e => 
-      e.type === 'user' && (!e.parentUuid || !eventMap.has(e.parentUuid))
-    );
-
-    for (const userMsg of rootMessages) {
-      const turn = {
-        turnId: userMsg.uuid,
-        userMessage: {
-          id: userMsg.uuid,
-          content: this._extractMessageContent(userMsg.message),
-          timestamp: userMsg.timestamp
-        },
-        assistantMessages: [],
-        toolCalls: []
-      };
-
-      // Find all children of this user message
-      this._collectAssistantResponses(userMsg.uuid, eventMap, turn);
-
-      turns.push(turn);
-    }
-
-    return turns;
-  }
-
-  _collectAssistantResponses(parentUuid, eventMap, turn) {
-    for (const [_uuid, event] of eventMap.entries()) {
-      if (event.parentUuid === parentUuid) {
-        if (event.type === 'assistant') {
-          const assistantMsg = {
-            id: event.uuid,
-            messageId: event.message?.id,
-            content: this._extractMessageContent(event.message),
-            model: event.message?.model,
-            timestamp: event.timestamp
-          };
-
-          // Extract tool calls from content
-          const toolUseBlocks = this._extractToolUse(event.message);
-          if (toolUseBlocks.length > 0) {
-            assistantMsg.toolRequests = toolUseBlocks;
-            turn.toolCalls.push(...toolUseBlocks.map(t => ({
-              toolCallId: t.id,
-              name: t.name,
-              arguments: t.input,
-              parentUuid: event.uuid
-            })));
-          }
-
-          turn.assistantMessages.push(assistantMsg);
-
-          // Recursively collect children (follow-up messages)
-          this._collectAssistantResponses(event.uuid, eventMap, turn);
-        }
-      }
-    }
-  }
-
-  _extractMessageContent(message) {
-    if (!message || !message.content) return '';
-    
-    if (typeof message.content === 'string') {
-      return message.content;
-    }
-
-    if (Array.isArray(message.content)) {
-      return message.content
-        .filter(block => block.type === 'text')
-        .map(block => block.text)
-        .join('\n');
-    }
-
-    return '';
-  }
-
-  _extractToolUse(message) {
-    if (!message || !message.content || !Array.isArray(message.content)) {
-      return [];
-    }
-
-    return message.content
-      .filter(block => block.type === 'tool_use')
-      .map(block => ({
-        id: block.id,
-        name: block.name,
-        input: block.input
-      }));
-  }
-
-  extractToolCalls(events) {
-    const toolCalls = [];
-
-    for (const event of events) {
-      if (event.type === 'assistant' && event.message?.content) {
-        const toolUseBlocks = this._extractToolUse(event.message);
-        
-        for (const tool of toolUseBlocks) {
-          toolCalls.push({
-            toolCallId: tool.id,
-            name: tool.name,
-            arguments: tool.input,
-            parentUuid: event.uuid,
-            timestamp: event.timestamp,
-            // Claude format doesn't have separate execution events
-            // Tool result would be in a following user message with tool_result
-            result: null,
-            exitCode: null
-          });
-        }
-      }
-    }
-
-    return toolCalls;
-  }
-}
-
-module.exports = ClaudeSessionParser;

package/lib/parsers/copilot-parser.js

@@ -1,143 +0,0 @@
-const BaseSessionParser = require('./base-parser');
-
-/**
- * Copilot CLI Session Parser
- * 
- * Parses events from GitHub Copilot CLI (copilot-agent)
- * Format: {type: "session.start", data: {...}, id: "...", parentId: "..."}
- */
-class CopilotSessionParser extends BaseSessionParser {
-  canParse(events) {
-    if (!events || events.length === 0) return false;
-    
-    // Check for Copilot CLI specific event types
-    const copilotEventTypes = [
-      'session.start',
-      'user.message',
-      'assistant.turn_start',
-      'assistant.message',
-      'tool.execution_start'
-    ];
-    
-    return events.some(e => 
-      e.type && copilotEventTypes.some(t => e.type.startsWith(t))
-    );
-  }
-
-  parse(events) {
-    return {
-      metadata: this.getMetadata(events),
-      turns: this.extractTurns(events),
-      toolCalls: this.extractToolCalls(events),
-      allEvents: events
-    };
-  }
-
-  getMetadata(events) {
-    const sessionStart = events.find(e => e.type === 'session.start');
-    if (!sessionStart) return null;
-
-    const data = sessionStart.data || {};
-    return {
-      sessionId: data.sessionId,
-      startTime: data.startTime,
-      model: data.selectedModel,
-      version: data.copilotVersion,
-      producer: data.producer,
-      cwd: data.context?.cwd,
-      gitRoot: data.context?.gitRoot,
-      branch: data.context?.branch,
-      repository: data.context?.repository
-    };
-  }
-
-  extractTurns(events) {
-    const turns = [];
-    let currentTurn = null;
-
-    for (const event of events) {
-      if (event.type === 'user.message') {
-        // Start new turn
-        if (currentTurn) {
-          turns.push(currentTurn);
-        }
-        currentTurn = {
-          turnId: event.id,
-          userMessage: {
-            id: event.id,
-            content: event.data?.content || '',
-            transformedContent: event.data?.transformedContent,
-            timestamp: event.timestamp
-          },
-          assistantMessages: [],
-          toolCalls: []
-        };
-      } else if (event.type === 'assistant.message' && currentTurn) {
-        currentTurn.assistantMessages.push({
-          id: event.id,
-          messageId: event.data?.messageId,
-          content: event.data?.content || '',
-          toolRequests: event.data?.toolRequests || [],
-          reasoningText: event.data?.reasoningText,
-          timestamp: event.timestamp
-        });
-      } else if (event.type.startsWith('tool.execution_') && currentTurn) {
-        const toolCallId = event.data?.toolCallId;
-        let toolCall = currentTurn.toolCalls.find(tc => tc.toolCallId === toolCallId);
-        
-        if (!toolCall) {
-          toolCall = { toolCallId, events: [] };
-          currentTurn.toolCalls.push(toolCall);
-        }
-        
-        toolCall.events.push(event);
-        
-        if (event.type === 'tool.execution_start') {
-          toolCall.name = event.data?.toolName;
-          toolCall.arguments = event.data?.arguments;
-        } else if (event.type === 'tool.execution_complete') {
-          toolCall.result = event.data?.result;
-          toolCall.exitCode = event.data?.exitCode;
-        }
-      }
-    }
-
-    // Push last turn
-    if (currentTurn) {
-      turns.push(currentTurn);
-    }
-
-    return turns;
-  }
-
-  extractToolCalls(events) {
-    const toolCalls = [];
-    const toolCallMap = new Map();
-
-    for (const event of events) {
-      if (event.type === 'tool.execution_start') {
-        const toolCallId = event.data?.toolCallId;
-        toolCallMap.set(toolCallId, {
-          toolCallId,
-          name: event.data?.toolName,
-          arguments: event.data?.arguments,
-          startEvent: event,
-          completeEvent: null
-        });
-      } else if (event.type === 'tool.execution_complete') {
-        const toolCallId = event.data?.toolCallId;
-        const toolCall = toolCallMap.get(toolCallId);
-        if (toolCall) {
-          toolCall.completeEvent = event;
-          toolCall.result = event.data?.result;
-          toolCall.exitCode = event.data?.exitCode;
-          toolCalls.push(toolCall);
-        }
-      }
-    }
-
-    return toolCalls;
-  }
-}
-
-module.exports = CopilotSessionParser;

package/lib/parsers/index.js

@@ -1,15 +0,0 @@
-const BaseSessionParser = require('./base-parser');
-const CopilotSessionParser = require('./copilot-parser');
-const ClaudeSessionParser = require('./claude-parser');
-const PiMonoParser = require('./pi-mono-parser');
-const VsCodeParser = require('./vscode-parser');
-const ParserFactory = require('./parser-factory');
-
-module.exports = {
-  BaseSessionParser,
-  CopilotSessionParser,
-  ClaudeSessionParser,
-  PiMonoParser,
-  VsCodeParser,
-  ParserFactory
-};

package/lib/parsers/parser-factory.js

@@ -1,77 +0,0 @@
-const CopilotSessionParser = require('./copilot-parser');
-const ClaudeSessionParser = require('./claude-parser');
-const PiMonoParser = require('./pi-mono-parser');
-
-/**
- * Parser Factory
- * 
- * Automatically detects the session format and returns the appropriate parser
- */
-class ParserFactory {
-  constructor() {
-    this.parsers = [
-      new CopilotSessionParser(),
-      new ClaudeSessionParser(),
-      new PiMonoParser()
-    ];
-    
-    // Name-to-parser mapping
-    this.parserMap = {
-      'copilot': new CopilotSessionParser(),
-      'claude': new ClaudeSessionParser(),
-      'pi-mono': new PiMonoParser()
-    };
-  }
-
-  /**
-   * Get parser by name or auto-detect from events
-   * @param {string|Array<Object>} nameOrEvents - Parser name or events array
-   * @returns {BaseSessionParser|null}
-   */
-  getParser(nameOrEvents) {
-    // If it's a string, get parser by name
-    if (typeof nameOrEvents === 'string') {
-      return this.parserMap[nameOrEvents] || null;
-    }
-    
-    // Otherwise, auto-detect from events
-    const events = nameOrEvents;
-    for (const parser of this.parsers) {
-      if (parser.canParse(events)) {
-        return parser;
-      }
-    }
-    return null;
-  }
-
-  /**
-   * Parse events using the appropriate parser
-   * @param {Array<Object>} events - Raw events from jsonl
-   * @returns {Object|null} Parsed session data or null if no parser found
-   */
-  parse(events) {
-    const parser = this.getParser(events);
-    if (!parser) {
-      return null;
-    }
-    return parser.parse(events);
-  }
-
-  /**
-   * Get parser type name
-   * @param {Array<Object>} events - Raw events from jsonl
-   * @returns {string|null} Parser name ('copilot', 'claude', 'pi-mono') or null
-   */
-  getParserType(events) {
-    const parser = this.getParser(events);
-    if (!parser) return null;
-    
-    if (parser instanceof CopilotSessionParser) return 'copilot';
-    if (parser instanceof ClaudeSessionParser) return 'claude';
-    if (parser instanceof PiMonoParser) return 'pi-mono';
-    
-    return 'unknown';
-  }
-}
-
-module.exports = ParserFactory;