System Architecture

export class TranscriptCompressor {
  private paths: PathResolver;
  private promptOrchestrator: PromptOrchestrator;
  private chunkManager: ChunkManager;

  // Main compression workflow
  async compress(transcriptPath: string, sessionId?: string): Promise<string>
}

export class PromptOrchestrator {
  // Creates analysis prompts for LLM processing
  createAnalysisPrompt(context: AnalysisContext): AnalysisPrompt

  // Creates session start messages for human context
  createSessionStartPrompt(context: SessionContext): SessionPrompt

  // Creates hook responses for system integration
  createHookResponse(context: HookContext): HookResponse
}

export class ChunkManager {
  // Determines if content needs chunking
  needsChunking(content: string): boolean

  // Splits content into manageable chunks
  chunkTranscript(filteredContent: string): Array<ChunkResult>

  // Estimates token usage
  estimateTokenCount(text: string): number
}

// MCP tool calls in TranscriptCompressor
await query({
  prompt: analysisPrompt.prompt,
  options: {
    allowedTools: [
      'mcp__claude-mem__chroma_add_documents',
      'mcp__claude-mem__chroma_query_documents',
      'mcp__claude-mem__chroma_update_documents',
      // ... other Chroma tools
    ],
    pathToClaudeCodeExecutable: getClaudePath(),
  },
});

interface MemoryDocument {
  type: "memory";
  text: string;           // Natural language description
  document_id: string;    // project_session_index format
  keywords: string;       // Comma-separated search terms
  session_id: string;     // Session identifier
  project: string;        // Project name
  timestamp: string;      // ISO timestamp
  archive: string;        // Archive filename reference
}

// Standardized hook structure
process.stdin.on('end', async () => {
  try {
    const payload = JSON.parse(input);

    // 1. Validate payload
    const validation = validateHookPayload(payload, 'HookType');

    // 2. Execute hook logic
    const result = await executeHookLogic(payload);

    // 3. Create standardized response
    const response = createHookResponse('HookType', result.success, result.data);

    console.log(JSON.stringify(response));
    process.exit(0);
  } catch (error) {
    // Standardized error handling
    const errorResponse = createHookResponse('HookType', false, {
      error: error.message
    });
    console.log(JSON.stringify(errorResponse));
    process.exit(0);
  }
});

export class PathResolver {
  // Discovers paths across different environments
  getConfigDir(): string      // ~/.claude-mem/
  getArchiveDir(): string     // ~/.claude-mem/archives/
  getIndexDir(): string       // ~/.claude-mem/
  getLogsDir(): string        // ~/.claude-mem/logs/

  // Project-specific paths
  getProjectArchiveDir(project: string): string
  getProjectPrefix(): string
}

// Natural failure - let real problems surface
const content = fs.readFileSync(transcriptPath, 'utf-8');
const messages = content.split('\n').map(line => JSON.parse(line));

// Continue processing even with parse errors
messages.forEach((msg, index) => {
  try {
    processMessage(msg);
  } catch (e) {
    log.debug(`Parse error on line ${index}: ${e.message}`);
    // Continue with next message
  }
});

// Adding new MCP tools to TranscriptCompressor
const allowedTools = [
  'mcp__claude-mem__chroma_add_documents',
  'mcp__claude-mem__chroma_query_documents',
  // Add new tools here
  'mcp__your-extension__custom_tool',
];