claude-mem 2.0.2

package/src/claude-mem.js

@@ -0,0 +1,859 @@
+#!/usr/bin/env node
+
+import { query } from '@anthropic-ai/claude-code';
+import fs from 'fs';
+import path, { join } from 'path';
+import os, { homedir } from 'os';
+import { fileURLToPath } from 'url';
+import { createAnalysisPrompt, DEBUG_MESSAGES } from '../dist/constants.js';
+
+const DEBUG_MODE = true;
+const CLAUDE_MEM_HOME = path.join(homedir(), '.claude-mem');
+const INDEX_PATH = path.join(
+  CLAUDE_MEM_HOME,
+  'index',
+  'claude_mem_index.jsonl'
+);
+const ARCHIVES_DIR = path.join(CLAUDE_MEM_HOME, 'archives');
+const LOGS_DIR = path.join(CLAUDE_MEM_HOME, 'logs');
+
+let debugLogFile = null;
+let debugLogStream = null;
+
+function initDebugLog() {
+  if (!DEBUG_MODE) return;
+
+  ensureClaudeMemStructure();
+
+  const logsDir = LOGS_DIR;
+  if (!fs.existsSync(logsDir)) {
+    fs.mkdirSync(logsDir, { recursive: true });
+  }
+
+  const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+  debugLogFile = path.join(logsDir, `claude-mem-${timestamp}.log`);
+  debugLogStream = fs.createWriteStream(debugLogFile, { flags: 'a' });
+
+  debugLog('🚀 DEBUG LOG STARTED');
+  debugLog(`📁 Log file: ${debugLogFile}`);
+  debugLog('═'.repeat(60));
+}
+
+function debugLog(message) {
+  if (!DEBUG_MODE || !debugLogStream) return;
+
+  const timestamp = new Date().toISOString();
+  const logLine = `[${timestamp}] ${message}\n`;
+  debugLogStream.write(logLine);
+}
+
+function closeDebugLog() {
+  if (debugLogStream) {
+    debugLog('✅ DEBUG LOG ENDED');
+    debugLogStream.end();
+  }
+}
+
+function ensureClaudeMemStructure() {
+  if (!fs.existsSync(CLAUDE_MEM_HOME)) {
+    fs.mkdirSync(CLAUDE_MEM_HOME, { recursive: true });
+  }
+  if (!fs.existsSync(path.join(CLAUDE_MEM_HOME, 'index'))) {
+    fs.mkdirSync(path.join(CLAUDE_MEM_HOME, 'index'), { recursive: true });
+  }
+  if (!fs.existsSync(ARCHIVES_DIR)) {
+    fs.mkdirSync(ARCHIVES_DIR, { recursive: true });
+  }
+  if (!fs.existsSync(LOGS_DIR)) {
+    fs.mkdirSync(LOGS_DIR, { recursive: true });
+  }
+}
+
+class TranscriptCompressor {
+  constructor() {
+    ensureClaudeMemStructure();
+    debugLog('🤖 TranscriptCompressor initialized');
+  }
+
+  extractToolUseChains(messages) {
+    const chains = [];
+    const toolUseMap = new Map();
+
+    messages.forEach((msg) => {
+      if (msg.parent_tool_use_id) {
+        const parentId = msg.parent_tool_use_id;
+        if (!toolUseMap.has(parentId)) {
+          toolUseMap.set(parentId, {
+            id: parentId,
+            tools: [],
+            messages: [],
+          });
+        }
+        toolUseMap.get(parentId).messages.push(msg);
+
+        if (msg.type === 'assistant' && msg.message?.content) {
+          const content = Array.isArray(msg.message.content)
+            ? msg.message.content[0]?.text || ''
+            : msg.message.content;
+          const toolMatch = content.match(/Using (\w+) tool/i);
+          if (toolMatch) {
+            toolUseMap.get(parentId).tools.push(toolMatch[1]);
+          }
+        }
+      }
+    });
+
+    toolUseMap.forEach((chain, id) => {
+      if (chain.tools.length > 0) {
+        chains.push(chain);
+      }
+    });
+
+    return chains;
+  }
+
+  extractProjectName(transcriptPath) {
+    const dir = path.dirname(transcriptPath);
+    const dirName = path.basename(dir);
+
+    let projectName = dirName;
+    if (dirName.includes('-Scripts-')) {
+      const parts = dirName.split('-Scripts-');
+      if (parts.length > 1) {
+        projectName = parts[1];
+      }
+    }
+
+    return projectName.replace(/[^a-zA-Z0-9]/g, '_');
+  }
+
+  async compress(transcriptPath, sessionId) {
+    debugLog(DEBUG_MESSAGES.COMPRESSION_STARTED);
+    debugLog(DEBUG_MESSAGES.TRANSCRIPT_PATH(transcriptPath));
+    debugLog(DEBUG_MESSAGES.SESSION_ID(sessionId || 'auto-detected'));
+    debugLog('═'.repeat(60));
+
+    debugLog(DEBUG_MESSAGES.CLAUDE_SDK_CALL);
+
+    try {
+      const projectName = this.extractProjectName(transcriptPath);
+      debugLog(DEBUG_MESSAGES.PROJECT_NAME(projectName));
+      debugLog('─'.repeat(40));
+
+      debugLog('📖 READING ENTIRE TRANSCRIPT (per CLAUDE.md spec)...');
+      const content = fs.readFileSync(transcriptPath, 'utf-8');
+      debugLog(`  Size: ${content.length} bytes`);
+
+      const lines = content
+        .trim()
+        .split('\n')
+        .filter((line) => line.trim());
+      debugLog(`  Lines: ${lines.length}`);
+
+      const messages = [];
+      let parseErrors = 0;
+
+      for (let i = 0; i < lines.length; i++) {
+        try {
+          const parsed = JSON.parse(lines[i]);
+          messages.push(parsed);
+        } catch (e) {
+          parseErrors++;
+          debugLog(`  ⚠️ Parse error on line ${i + 1}: ${e.message}`);
+        }
+      }
+
+      debugLog(`  Messages parsed: ${messages.length}`);
+      if (parseErrors > 0) {
+        debugLog(`  Parse errors: ${parseErrors}`);
+      }
+      debugLog('─'.repeat(40));
+
+      debugLog(
+        DEBUG_MESSAGES.TRANSCRIPT_STATS(content.length, messages.length)
+      );
+
+
+      debugLog('\n🎯 MAKING ONE CLAUDE SDK CALL (per CLAUDE.md spec)');
+      debugLog(`  Analyzing ${messages.length} messages in a single call`);
+      debugLog('─'.repeat(40));
+
+      const prompt = this.createAnalysisPrompt(
+        messages,
+        projectName,
+        sessionId
+      );
+
+      debugLog('📤 FULL PROMPT BEING SENT TO CLAUDE:');
+      debugLog('═'.repeat(80));
+      debugLog(prompt);
+      debugLog('═'.repeat(80));
+      debugLog(`📊 PROMPT STATS: ${prompt.length} characters`);
+
+      debugLog('🤖 CALLING CLAUDE SDK...');
+
+      // Try to find Claude Code executable
+      const possibleClaudePaths = [
+        '/opt/homebrew/bin/claude',
+        '/usr/local/bin/claude',
+        process.env.CLAUDE_CODE_PATH,
+      ].filter(Boolean);
+      
+      let claudePath = null;
+      for (const path of possibleClaudePaths) {
+        if (path && fs.existsSync(path)) {
+          claudePath = path;
+          break;
+        }
+      }
+      
+      if (claudePath) {
+        debugLog(DEBUG_MESSAGES.CLAUDE_PATH_FOUND(claudePath));
+      } else {
+        debugLog('⚠️ Claude Code executable not found, SDK will use default');
+      }
+      
+      // Determine which MCP config to use based on what exists
+      const possibleMcpConfigs = [
+        join(process.cwd(), '.mcp.json'), // Project-level config
+        join(os.homedir(), '.claude.json'), // User-level config (correct location)
+        join(os.homedir(), '.claude', '.mcp.json'), // Legacy location for backwards compatibility
+      ];
+      
+      let mcpConfigPath = possibleMcpConfigs.find(fs.existsSync);
+      if (!mcpConfigPath) {
+        debugLog('⚠️ No MCP config found, defaulting to ~/.claude.json');
+        mcpConfigPath = join(os.homedir(), '.claude.json');
+      } else {
+        debugLog(DEBUG_MESSAGES.MCP_CONFIG_USED(mcpConfigPath));
+      }
+      
+      const response = await query({
+        prompt: prompt,
+        options: {
+          pathToClaudeCodeExecutable: claudePath,
+          mcpConfig: mcpConfigPath,
+          allowedTools: [
+            'mcp__claude-mem__create_entities',
+            'mcp__claude-mem__create_relations',
+          ],
+          outputFormat: 'stream-json',
+        },
+      });
+
+      debugLog('📥 PROCESSING CLAUDE RESPONSE...');
+
+      const summaries = [];
+      let fullContent = '';
+      let messageCount = 0;
+
+      if (
+        response &&
+        typeof response === 'object' &&
+        Symbol.asyncIterator in response
+      ) {
+        debugLog('  Streaming response detected');
+
+        for await (const message of response) {
+          messageCount++;
+
+          if (message?.content) {
+            fullContent += message.content;
+          }
+          if (message?.text) {
+            fullContent += message.text;
+          }
+          if (message?.data) {
+            fullContent += message.data;
+          }
+          if (message?.message) {
+            if (
+              message.message.content &&
+              Array.isArray(message.message.content)
+            ) {
+              message.message.content.forEach((item) => {
+                if (item.type === 'text' && item.text) {
+                  fullContent += item.text;
+                }
+              });
+            }
+          }
+
+          if (message?.type === 'result' && message?.result) {
+            debugLog(`🎯 FINAL RESULT RECEIVED:`);
+            debugLog(message.result);
+            fullContent = message.result;
+          }
+        }
+
+        debugLog(
+          `📊 RESPONSE SUMMARY: ${messageCount} messages, ${fullContent.length} chars content`
+        );
+
+        if (fullContent) {
+          debugLog(`  📄 Parsing response as JSONL...`);
+          const lines = fullContent.split('\n');
+          let validLines = 0;
+          let invalidLines = 0;
+
+          lines.forEach((line, idx) => {
+            const trimmed = line.trim();
+            if (!trimmed) return;
+
+            try {
+              const parsed = JSON.parse(trimmed);
+
+              if (
+                parsed.session_id &&
+                parsed.summary &&
+                parsed.nodes &&
+                parsed.keywords
+              ) {
+                summaries.push(parsed);
+
+                validLines++;
+                debugLog(`  ✅ Line ${idx + 1}: Valid index entry`);
+
+                if (validLines === 1) {
+                  debugLog(
+                    `    Sample: ${parsed.summary.substring(0, 100)}...`
+                  );
+                  debugLog(`    Nodes: ${parsed.nodes.join(', ')}`);
+                  debugLog(`    Keywords: ${parsed.keywords.join(', ')}`);
+                }
+              } else {
+                debugLog(
+                  `  ⚠️ Line ${idx + 1}: Missing required fields (session_id, summary, nodes, or keywords)`
+                );
+                invalidLines++;
+              }
+            } catch (e) {
+              debugLog(`  ❌ Line ${idx + 1}: Invalid JSON - ${e.message}`);
+              invalidLines++;
+            }
+          });
+
+          debugLog(
+            `  📊 Parsing complete: ${validLines} valid, ${invalidLines} invalid`
+          );
+        }
+      } else {
+        debugLog('  ⚠️ NON-STREAMING RESPONSE DETECTED');
+        debugLog('  RAW RESPONSE:');
+        debugLog(JSON.stringify(response, null, 2));
+
+        if (response) {
+          debugLog(`  Response type: ${typeof response}`);
+
+          if (typeof response === 'string') {
+            debugLog(`  Response is string with ${response.length} chars`);
+
+            const lines = response.split('\n');
+            let validLines = 0;
+
+            lines.forEach((line, idx) => {
+              const trimmed = line.trim();
+              if (!trimmed) return;
+
+              try {
+                const parsed = JSON.parse(trimmed);
+                if (
+                  parsed.session_id &&
+                  parsed.summary &&
+                  parsed.nodes &&
+                  parsed.keywords
+                ) {
+                  summaries.push(parsed);
+
+                  validLines++;
+                  debugLog(`  ✅ Line ${idx + 1}: Valid index entry`);
+                }
+              } catch (e) {
+                debugLog(`  ❌ Line ${idx + 1}: Invalid JSON - ${e.message}`);
+              }
+            });
+
+            debugLog(`  📊 Parsed ${validLines} valid summaries`);
+          } else if (Array.isArray(response)) {
+            debugLog(`  Response is array with ${response.length} items`);
+            response.forEach((item) => {
+              if (
+                item.session_id &&
+                item.summary &&
+                item.nodes &&
+                item.keywords
+              ) {
+                summaries.push(item);
+              }
+            });
+          } else if (typeof response === 'object') {
+            debugLog('  Response is object with keys:', Object.keys(response));
+
+            if (
+              response.session_id &&
+              response.summary &&
+              response.nodes &&
+              response.keywords
+            ) {
+              summaries.push(response);
+            }
+          }
+        } else {
+          debugLog('  ⚠️ Response is null/undefined');
+        }
+      }
+
+      debugLog('─'.repeat(40));
+      debugLog(DEBUG_MESSAGES.COMPRESSION_COMPLETE(summaries.length));
+
+      if (summaries.length === 0) {
+        debugLog('  ⚠️ WARNING: No summaries were extracted!');
+        debugLog(
+          '  This likely means Claude did not return the expected format.'
+        );
+        return;
+      }
+
+      const archivePath = this.createArchive(
+        transcriptPath,
+        projectName,
+        sessionId,
+        content
+      );
+
+      this.appendToIndex(
+        summaries,
+        projectName,
+        sessionId,
+        messages,
+        archivePath
+      );
+
+      debugLog(`\n✅ SUCCESS`);
+      debugLog(`  Archive created: ${archivePath}`);
+      debugLog(`  Index updated: ${INDEX_PATH}`);
+      debugLog(`  Original size: ${content.length} bytes`);
+      debugLog(`  Summaries created: ${summaries.length}`);
+      debugLog('═'.repeat(60));
+
+      return archivePath;
+    } catch (error) {
+      console.error(`\n❌ COMPRESSION FAILED`);
+      console.error(`  Error: ${error.message}`);
+      console.error(`  Stack: ${error.stack}`);
+      throw error;
+    }
+  }
+
+  createAnalysisPrompt(messages, projectName, sessionId) {
+    const conversationText = this.formatConversationForPrompt(
+      messages,
+      false
+    );
+
+    const toolUseChains = this.extractToolUseChains(messages);
+
+    return `You are analyzing a Claude Code conversation transcript to create a sophisticated memory index system using the Model Context Protocol knowledge graph.
+
+Your task:
+1. Extract ALL key technical entities following MCP memory best practices
+2. Create rich, searchable entities with detailed observations using MCP tools
+3. Create specific, active-voice relationships between entities
+4. Return compressed summaries in STRICT JSONL format with memory/keyword references
+
+${
+  toolUseChains.length > 0
+    ? `TOOL USE CHAINS DETECTED:
+${toolUseChains.map((chain) => `- Tool chain ${chain.id}: ${chain.tools.join(' → ')}`).join('\n')}
+Create relationships for these tool use sequences in the knowledge graph.
+`
+    : ''
+}
+
+ENTITY EXTRACTION GUIDELINES:
+Focus on these categories for creating a searchable index:
+- **Technical Components**: Functions, classes, services, APIs, databases, modules
+- **Architectural Patterns**: State management, authentication flows, data pipelines, design patterns
+- **Development Decisions**: Design choices, trade-offs, problem solutions, optimizations
+- **Workflows & Processes**: Build processes, deployment strategies, testing approaches
+- **Integration Points**: External APIs, third-party services, data sources
+- **Performance & Reliability**: Caching strategies, error handling, optimization techniques
+- **Bugs & Fixes**: Issues encountered, debugging approaches, solutions applied
+
+ENTITY FORMAT:
+- name: "${projectName}_EntityName" 
+  (Use clear, searchable names that describe WHAT it is, not session-specific IDs)
+  IMPORTANT: Include entity type in name for better categorization:
+  * "${projectName}_Component_Name" for UI/modules/services
+  * "${projectName}_Decision_Name" for architectural choices
+  * "${projectName}_Pattern_Name" for design patterns
+  * "${projectName}_Tool_Name" for libraries/tools
+  * "${projectName}_Fix_Name" for bug fixes
+  * "${projectName}_Workflow_Name" for processes
+- entityType: Choose from:
+  * "component" - UI components, modules, services
+  * "pattern" - Architectural or design patterns
+  * "workflow" - Processes, pipelines, sequences
+  * "integration" - APIs, external services, data sources
+  * "concept" - Abstract ideas, methodologies, principles
+  * "decision" - Design choices, trade-offs, solutions
+  * "tool" - Utilities, libraries, development tools
+  * "fix" - Bug fixes, patches, workarounds
+- observations: Rich, structured details for future recall:
+  * "Core purpose: [what it fundamentally does]"
+  * "Brief description: [one-line summary for session-start display]"
+  * "Implementation: [key technical details, code patterns]"
+  * "Dependencies: [what it requires or builds upon]"
+  * "Usage context: [when/why it's used]"
+  * "Performance characteristics: [speed, reliability, constraints]"
+  * "Integration points: [how it connects to other systems]"
+  * "Keywords: [searchable terms for this concept]"
+  * "Decision rationale: [why this approach was chosen]"
+  * "Next steps: [what needs to be done next with this component]"
+  * "Files modified: [list of files changed]"
+  * "Tools used: [development tools/commands used]"
+  * "UUID: ${sessionId}"
+  * "Session: ${sessionId}"
+
+RELATIONSHIP FORMAT (Use specific, active voice):
+Be precise with relationships to create a meaningful graph:
+- "executes_via", "orchestrates_through", "validates_using"
+- "provides_auth_to", "manages_state_for", "processes_events_from"
+- "caches_data_from", "routes_requests_to", "transforms_data_for"
+- "extends", "enhances_performance_of", "builds_upon"
+- "fixes_issue_in", "replaces", "optimizes"
+- "uses_tool_chain", "triggers_tool", "receives_result_from"
+
+OUTPUT FORMAT REQUIREMENTS:
+Return ONLY valid JSONL format (one JSON object per line, NOT an array) with this EXACT structure:
+
+EXAMPLE OUTPUT:
+{"timestamp":"${new Date().toISOString()}","session_id":"${sessionId}","project":"${projectName}","summary":"Implemented Redis caching system with TTL support and connection pooling","nodes":["${projectName}_Component_RedisCache","${projectName}_Pattern_ConnectionPool"],"keywords":["redis","caching","ttl","connection_pooling"],"message_count":42,"uuid":"${sessionId}","archive_path":"~/.claude-mem/archives/${sessionId}.jsonl.archive"}
+{"timestamp":"${new Date().toISOString()}","session_id":"${sessionId}","project":"${projectName}","summary":"Built JWT authentication with refresh tokens and role-based access control","nodes":["${projectName}_Component_JWTAuth","${projectName}_Decision_RoleManager","${projectName}_Pattern_RefreshToken"],"keywords":["jwt","authentication","rbac","security","refresh_token"],"message_count":35,"uuid":"${sessionId}","archive_path":"~/.claude-mem/archives/${sessionId}.jsonl.archive"}
+{"timestamp":"${new Date().toISOString()}","session_id":"${sessionId}","project":"${projectName}","summary":"Fixed WebSocket memory leak by implementing proper connection cleanup handlers","nodes":["${projectName}_Fix_WebSocketLeak","${projectName}_Component_ConnectionCleanup"],"keywords":["websocket","memory_leak","cleanup","debugging"],"message_count":28,"uuid":"${sessionId}","archive_path":"~/.claude-mem/archives/${sessionId}.jsonl.archive"}
+
+SUMMARY REQUIREMENTS:
+Each index entry must:
+- Be a valid JSON object with ALL required fields: timestamp, session_id, project, summary, nodes, keywords, message_count, uuid, archive_path
+- timestamp: Current ISO timestamp
+- session_id: Use EXACT session ID "${sessionId}" (no "session-" prefix)
+- project: "${projectName}"
+- summary: Describe WHAT was accomplished and WHY it matters (active voice, specific, actionable)
+  * Start with action verb: "Implemented", "Fixed", "Refactored", "Designed", "Optimized"
+  * Include the main component/feature affected
+  * Mention the key outcome or improvement
+- nodes: Array of 2-4 entity names created in knowledge graph (use type-prefixed names)
+- keywords: Array of 3-5 searchable terms (include tool names, patterns, technologies)
+- message_count: Total messages in conversation (use actual count)
+- uuid: "${sessionId}"
+- archive_path: "~/.claude-mem/archives/${sessionId}.jsonl.archive"
+
+MCP TOOL USAGE:
+1. FIRST: Call create_entities for each distinct concept/component/decision
+   - Create session entity: ${projectName}_Session_${sessionId}
+   - Create entities for major components/patterns/decisions
+   - Include rich observations with keywords and metadata
+2. THEN: Call create_relations to link related entities
+   - Link entities to session entity
+   - Create tool chain relationships via parent_tool_use_id
+   - Connect new entities to existing ones (if incremental)
+3. FINALLY: Return JSONL summaries referencing created entities
+
+INDEXING PRIORITIES:
+- Prioritize entities that will be valuable for future code recall
+- Focus on reusable patterns and solutions
+- Capture decision rationale and trade-offs
+- Include error patterns and their fixes
+- Document integration points and API usage
+- Note performance optimizations and their impact
+- Create entities for tool chains and workflows
+
+Project: ${projectName}
+Session ID: ${sessionId}
+
+CRITICAL REQUIREMENTS:
+- Create 3-15 entities depending on conversation complexity
+- Create 5-20 relationships showing entity connections
+- Return 3-10 JSONL index entries (one JSON object per line, NOT an array)
+- Each line must be valid JSON parseable with JSON.parse()
+- Each line must have ALL required fields (timestamp, session_id, project, summary, nodes, keywords, message_count, uuid, archive_path)
+- Use EXACT session ID without prefixes
+- Focus on creating a searchable index for future development
+- Original transcript will be archived as ${sessionId}.jsonl.archive
+
+Conversation to compress:
+${conversationText}`;
+  }
+
+  formatConversationForPrompt(messages, hasCompressedContent) {
+    const jsonlLines = [];
+
+    messages.forEach((m, index) => {
+      let role = 'unknown';
+      let messageType = m.type;
+
+      if (m.type === 'assistant') {
+        role = 'assistant';
+      } else if (m.type === 'user') {
+        role = 'user';
+      } else if (m.type === 'result') {
+        role = 'system';
+      } else if (m.type === 'system') {
+        role = 'system';
+      } else {
+        role = m.message?.role || m.role || 'unknown';
+      }
+
+      let content = this.extractContent(m);
+
+      if (!content || content.trim() === '') {
+        debugLog(`  ⚠️ Skipping message ${index + 1}: empty content`);
+        return;
+      }
+
+      const timestamp = this.normalizeTimestamp(m);
+
+      const messageObj = {
+        type: messageType,
+        role: role,
+        content: content,
+      };
+
+      if (m.uuid) messageObj.uuid = m.uuid;
+      if (m.session_id) messageObj.session_id = m.session_id;
+      if (m.parent_tool_use_id)
+        messageObj.parent_tool_use_id = m.parent_tool_use_id;
+
+      if (timestamp) {
+        messageObj.ts = timestamp;
+      }
+
+
+      try {
+        jsonlLines.push(JSON.stringify(messageObj));
+      } catch (e) {
+        const safeObj = {
+          type: messageType,
+          role: role,
+          content: String(content).replace(/[\u0000-\u001F\u007F-\u009F]/g, ''),
+          error: 'content_sanitized',
+        };
+        if (m.uuid) safeObj.uuid = m.uuid;
+        if (m.session_id) safeObj.session_id = m.session_id;
+        if (timestamp) safeObj.ts = timestamp;
+        jsonlLines.push(JSON.stringify(safeObj));
+        debugLog(
+          `  ⚠️ Message ${index + 1} sanitized due to JSON error: ${e.message}`
+        );
+      }
+    });
+
+    debugLog(
+      `📊 Field filtering complete: ${jsonlLines.length} messages processed`
+    );
+
+    return `\`\`\`\n${jsonlLines.join('\n')}\n\`\`\`\n\n* All dates/times are in UTC`;
+  }
+
+  extractContent(m) {
+    if (m.type === 'assistant' || m.type === 'user') {
+      const messageContent = m.message?.content;
+      if (messageContent) {
+        if (Array.isArray(messageContent)) {
+          return messageContent
+            .map((item) => {
+              if (typeof item === 'string') return item;
+              if (item.text) return item.text;
+              if (item.content) return item.content;
+              return '';
+            })
+            .filter(Boolean)
+            .join(' ');
+        }
+        return String(messageContent).trim();
+      }
+    } else if (m.type === 'result') {
+      if (m.subtype === 'success' && m.result) {
+        return `[Result: ${m.result}]`;
+      } else if (m.subtype === 'error_max_turns') {
+        return '[Error: Maximum turns reached]';
+      } else if (m.subtype === 'error_during_execution') {
+        return '[Error during execution]';
+      }
+    } else if (m.type === 'system' && m.subtype === 'init') {
+      return `[System initialized: ${m.model}, tools: ${m.tools?.length || 0}, MCP servers: ${m.mcp_servers?.length || 0}]`;
+    }
+
+    let content = m.message?.content || m.content || '';
+
+    if (Array.isArray(content)) {
+      content = content
+        .map((item) => {
+          if (typeof item === 'string') return item;
+          if (item.text) return item.text;
+          if (item.content) return item.content;
+          return '';
+        })
+        .filter(Boolean)
+        .join(' ');
+    }
+
+    if (m.toolUseResult) {
+      const toolSummary = this.summarizeToolResult(m.toolUseResult, content);
+      if (toolSummary) {
+        content = content ? `${content}\n\n${toolSummary}` : toolSummary;
+      }
+    }
+
+    return String(content).trim();
+  }
+
+  summarizeToolResult(toolResult, existingContent) {
+    if (!toolResult) return '';
+
+    const summaryParts = [];
+
+    if (toolResult.stdout) {
+      const stdout = String(toolResult.stdout);
+      if (stdout.length > 200) {
+        const lineCount = stdout.split('\n').length;
+        const charCount = stdout.length;
+
+        const lines = stdout.split('\n');
+        const preview = lines.slice(0, 3).join('\n');
+        const suffix =
+          lines.length > 6 ? `\n...\n${lines.slice(-2).join('\n')}` : '';
+
+        summaryParts.push(
+          `Result: ${preview}${suffix} (${lineCount} lines, ${charCount} chars)`
+        );
+      } else {
+        summaryParts.push(`Result: ${stdout}`);
+      }
+    }
+
+    if (toolResult.stderr && toolResult.stderr.trim()) {
+      summaryParts.push(
+        `Error: ${toolResult.stderr.substring(0, 150)}${toolResult.stderr.length > 150 ? '...' : ''}`
+      );
+    }
+
+    if (toolResult.interrupted) {
+      summaryParts.push('(interrupted)');
+    }
+
+    if (toolResult.isImage) {
+      summaryParts.push('(image output)');
+    }
+
+    return summaryParts.join('\n');
+  }
+
+  normalizeTimestamp(m) {
+    const ts =
+      m.timestamp ||
+      m.message?.timestamp ||
+      m.created_at ||
+      m.message?.created_at;
+
+    if (!ts) return '';
+
+    try {
+      const date = new Date(ts);
+      if (isNaN(date.getTime())) return '';
+
+      return date.toISOString().slice(0, 19).replace('T', ' ');
+    } catch (e) {
+      debugLog(`  ⚠️ Invalid timestamp format: ${ts}`);
+      return '';
+    }
+  }
+
+  createArchive(transcriptPath, projectName, sessionId, content) {
+    const projectArchiveDir = path.join(ARCHIVES_DIR, projectName);
+    if (!fs.existsSync(projectArchiveDir)) {
+      fs.mkdirSync(projectArchiveDir, { recursive: true });
+    }
+
+    const archivePath = path.join(
+      projectArchiveDir,
+      `${sessionId}.jsonl.archive`
+    );
+
+    fs.writeFileSync(archivePath, content);
+
+    debugLog(`📦 Created archive: ${archivePath}`);
+    return archivePath;
+  }
+
+  appendToIndex(summaries, projectName, sessionId, messages, archivePath) {
+    const indexDir = path.dirname(INDEX_PATH);
+    if (!fs.existsSync(indexDir)) {
+      fs.mkdirSync(indexDir, { recursive: true });
+    }
+
+    const messageCount = messages.length;
+
+    const indexEntries = summaries.map((entry) => {
+      return {
+        ...entry,
+
+        session_id: sessionId,
+
+        project: projectName,
+
+        message_count: entry.message_count || messageCount,
+
+        archive_path: archivePath,
+      };
+    });
+
+    const indexContent =
+      indexEntries.map((entry) => JSON.stringify(entry)).join('\n') + '\n';
+    fs.appendFileSync(INDEX_PATH, indexContent);
+
+    debugLog(`📝 Appended ${indexEntries.length} entries to index`);
+    debugLog(`  Index path: ${INDEX_PATH}`);
+  }
+}
+
+async function main() {
+  initDebugLog();
+
+  const args = process.argv.slice(2);
+
+  if (args.length === 0) {
+    console.error(
+      'Usage: node src/claude-mem.js <transcript-path> [session-id]'
+    );
+    closeDebugLog();
+    process.exit(1);
+  }
+
+  const transcriptPath = args[0];
+  const sessionId = args[1] || path.basename(transcriptPath, '.jsonl');
+
+  debugLog(`🚀 Starting compression for: ${transcriptPath}`);
+  debugLog(`📋 Session ID: ${sessionId}`);
+
+  const compressor = new TranscriptCompressor();
+
+  try {
+    await compressor.compress(transcriptPath, sessionId);
+    debugLog('✅ Compression successful');
+    closeDebugLog();
+    process.exit(0);
+  } catch (error) {
+    debugLog(`❌ Compression failed: ${error.message}`);
+    debugLog(`💥 Stack trace: ${error.stack}`);
+    closeDebugLog();
+    console.error('❌ Compression failed:', error.message);
+    process.exit(1);
+  }
+}
+
+export { TranscriptCompressor };
+
+if (import.meta.url === `file://${process.argv[1]}`) {
+  main();
+}