claudecto 0.1.0

package/dist/services/insights.js

@@ -0,0 +1,1035 @@
+/**
+ * Insights service - AI-powered session analysis using Claude Code
+ * Provides rich interactive insights including sentiment analysis,
+ * topic segmentation, quality scoring, and comprehensive metadata.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { exec } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+const INSIGHT_VERSION = 2;
+export class InsightsService extends EventEmitter {
+    claudeDir;
+    sessionService;
+    analyticsService;
+    generatingInsights = new Map();
+    progressMap = new Map();
+    constructor(claudeDir, sessionService, analyticsService) {
+        super();
+        this.claudeDir = claudeDir;
+        this.sessionService = sessionService;
+        this.analyticsService = analyticsService;
+    }
+    // --------------------------------------------------------------------------
+    // Progress & Error Helpers
+    // --------------------------------------------------------------------------
+    emitProgress(sessionId, stage, progress, message, error) {
+        const progressData = {
+            sessionId,
+            stage,
+            progress,
+            message,
+            startedAt: this.progressMap.get(sessionId)?.startedAt || new Date().toISOString(),
+            error,
+        };
+        this.progressMap.set(sessionId, progressData);
+        this.emit('progress', progressData);
+    }
+    getProgress(sessionId) {
+        return this.progressMap.get(sessionId) || null;
+    }
+    createAIError(code, message, recoverable, details, suggestion) {
+        return {
+            code,
+            message,
+            details,
+            recoverable,
+            suggestion,
+        };
+    }
+    mapErrorToAIError(error) {
+        const msg = error.message.toLowerCase();
+        if (msg.includes('timeout')) {
+            return this.createAIError('EXECUTION_TIMEOUT', 'Insight generation timed out', true, error.message, 'Try again with a shorter session or increase timeout');
+        }
+        if (msg.includes('not found') && msg.includes('claude')) {
+            return this.createAIError('CLAUDE_NOT_FOUND', 'Claude Code CLI not installed', false, error.message, 'Install Claude Code CLI: npm install -g @anthropic-ai/claude-code');
+        }
+        if (msg.includes('session not found')) {
+            return this.createAIError('SESSION_NOT_FOUND', 'Session not found', false, error.message);
+        }
+        if (msg.includes('parse') || msg.includes('json')) {
+            return this.createAIError('PARSE_ERROR', 'Failed to parse AI response', true, error.message, 'Try regenerating the insight');
+        }
+        if (msg.includes('rate') || msg.includes('limit')) {
+            return this.createAIError('RATE_LIMITED', 'Rate limited by Claude API', true, error.message, 'Wait a moment and try again');
+        }
+        return this.createAIError('UNKNOWN', 'An unexpected error occurred', true, error.message, 'Try again or check the logs for details');
+    }
+    // --------------------------------------------------------------------------
+    // File Paths
+    // --------------------------------------------------------------------------
+    getInsightPath(sessionId) {
+        return path.join(this.claudeDir.insightsDir, `${sessionId}.json`);
+    }
+    // --------------------------------------------------------------------------
+    // Read/Write Operations
+    // --------------------------------------------------------------------------
+    async getInsight(sessionId) {
+        const insightPath = this.getInsightPath(sessionId);
+        return this.claudeDir.readJSON(insightPath);
+    }
+    async saveInsight(insight) {
+        await this.claudeDir.ensureInsightsDir();
+        const insightPath = this.getInsightPath(insight.sessionId);
+        await this.claudeDir.writeJSON(insightPath, insight);
+    }
+    async listInsights(projectFilter) {
+        const insights = [];
+        try {
+            const insightsDir = this.claudeDir.insightsDir;
+            const fs = await import('node:fs/promises');
+            const entries = await fs.readdir(insightsDir, { withFileTypes: true });
+            for (const entry of entries) {
+                if (entry.isFile() && entry.name.endsWith('.json')) {
+                    const insightPath = path.join(insightsDir, entry.name);
+                    const insight = await this.claudeDir.readJSON(insightPath);
+                    if (insight) {
+                        if (projectFilter) {
+                            const session = await this.sessionService.getSession(insight.sessionId);
+                            if (session && session.projectPath !== projectFilter) {
+                                continue;
+                            }
+                        }
+                        insights.push(insight);
+                    }
+                }
+            }
+        }
+        catch {
+            // Insights directory doesn't exist yet
+        }
+        return insights.sort((a, b) => new Date(b.generatedAt).getTime() - new Date(a.generatedAt).getTime());
+    }
+    // --------------------------------------------------------------------------
+    // Insight Generation
+    // --------------------------------------------------------------------------
+    async generateInsight(sessionId, force = false) {
+        const existing = this.generatingInsights.get(sessionId);
+        if (existing) {
+            return existing;
+        }
+        if (!force) {
+            const cached = await this.getInsight(sessionId);
+            if (cached && cached.status === 'completed') {
+                return cached;
+            }
+        }
+        const pendingInsight = {
+            sessionId,
+            version: INSIGHT_VERSION,
+            generatedAt: new Date().toISOString(),
+            status: 'generating',
+        };
+        await this.saveInsight(pendingInsight);
+        const generationPromise = this.doGenerateInsight(sessionId);
+        this.generatingInsights.set(sessionId, generationPromise);
+        try {
+            const result = await generationPromise;
+            return result;
+        }
+        finally {
+            this.generatingInsights.delete(sessionId);
+        }
+    }
+    async doGenerateInsight(sessionId) {
+        try {
+            // Stage 1: Starting
+            this.emitProgress(sessionId, 'starting', 0, 'Initializing insight generation...');
+            console.log(`[Insights] Starting insight generation for session: ${sessionId}`);
+            // Check if Claude is available first
+            const claudeAvailable = await this.isClaudeCodeAvailable();
+            if (!claudeAvailable) {
+                const error = this.createAIError('CLAUDE_NOT_FOUND', 'Claude Code CLI is not installed', false, undefined, 'Install Claude Code: npm install -g @anthropic-ai/claude-code');
+                this.emitProgress(sessionId, 'error', 0, 'Claude Code not found', error);
+                throw new Error('Claude Code CLI not found. Please install it first.');
+            }
+            // Stage 2: Loading session
+            this.emitProgress(sessionId, 'loading_session', 10, 'Loading session data...');
+            const session = await this.sessionService.getSession(sessionId);
+            if (!session) {
+                const error = this.createAIError('SESSION_NOT_FOUND', `Session ${sessionId} not found`, false);
+                this.emitProgress(sessionId, 'error', 10, 'Session not found', error);
+                throw new Error('Session not found');
+            }
+            console.log(`[Insights] Session loaded with ${session.messages?.length ?? 0} messages`);
+            // Stage 3: Loading analytics
+            this.emitProgress(sessionId, 'loading_analytics', 20, 'Loading session analytics...');
+            const projectDirs = await this.claudeDir.listProjects();
+            let analytics = null;
+            for (const projectDir of projectDirs) {
+                const sessionFiles = await this.claudeDir.listSessionFiles(projectDir);
+                for (const filePath of sessionFiles) {
+                    const fileName = path.basename(filePath, '.jsonl');
+                    if (fileName === sessionId || fileName.startsWith(sessionId)) {
+                        analytics = await this.analyticsService.getSessionAnalytics(filePath, projectDir);
+                        break;
+                    }
+                }
+                if (analytics)
+                    break;
+            }
+            console.log(`[Insights] Analytics loaded: ${analytics ? 'yes' : 'no'}`);
+            // Stage 4: Building context
+            this.emitProgress(sessionId, 'building_context', 30, 'Building comprehensive context...');
+            const context = this.buildComprehensiveContext(session, analytics);
+            console.log(`[Insights] Context built, length: ${context.length} chars`);
+            // Stage 5: Calling Claude
+            this.emitProgress(sessionId, 'calling_claude', 40, 'Analyzing with Claude AI (this may take a few minutes)...');
+            console.log(`[Insights] Calling Claude Code for analysis...`);
+            const aiResponse = await this.callClaudeCode(context);
+            console.log(`[Insights] Claude response received, length: ${aiResponse.length} chars`);
+            // Check for empty response
+            if (!aiResponse || aiResponse.trim().length === 0) {
+                const error = this.createAIError('EMPTY_RESPONSE', 'Claude returned an empty response', true, undefined, 'Try regenerating the insight');
+                this.emitProgress(sessionId, 'error', 50, 'Empty response from Claude', error);
+                throw new Error('Empty response from Claude Code');
+            }
+            // Stage 6: Parsing response
+            this.emitProgress(sessionId, 'parsing_response', 70, 'Parsing AI response...');
+            const parsed = this.parseRichResponse(aiResponse, session, analytics);
+            // Build final insight
+            const insight = {
+                sessionId,
+                version: INSIGHT_VERSION,
+                generatedAt: new Date().toISOString(),
+                status: 'completed',
+                ...parsed,
+            };
+            // Merge analytics data into metadata
+            if (insight.metadata && analytics) {
+                insight.metadata.tokens.total = analytics.tokens?.totalTokens ?? 0;
+                insight.metadata.tokens.input = analytics.tokens?.inputTokens ?? 0;
+                insight.metadata.tokens.output = analytics.tokens?.outputTokens ?? 0;
+                insight.metadata.tokens.cached = analytics.tokens?.cacheReadTokens ?? 0;
+                insight.metadata.duration.total = analytics.durationMinutes ?? 0;
+            }
+            if (insight.costOptimization && analytics?.cost) {
+                insight.costOptimization.totalCost = analytics.cost.totalCost;
+            }
+            // Stage 7: Saving
+            this.emitProgress(sessionId, 'saving', 90, 'Saving insight...');
+            await this.saveInsight(insight);
+            // Stage 8: Complete
+            this.emitProgress(sessionId, 'completed', 100, 'Insight generation complete!');
+            this.progressMap.delete(sessionId); // Clean up
+            return insight;
+        }
+        catch (error) {
+            const aiError = this.mapErrorToAIError(error);
+            this.emitProgress(sessionId, 'error', 0, aiError.message, aiError);
+            const errorInsight = {
+                sessionId,
+                version: INSIGHT_VERSION,
+                generatedAt: new Date().toISOString(),
+                status: 'error',
+                error: aiError.message,
+                // Include structured error info in the insight for the UI
+                errorDetails: {
+                    code: aiError.code,
+                    message: aiError.message,
+                    recoverable: aiError.recoverable,
+                    suggestion: aiError.suggestion,
+                },
+            };
+            await this.saveInsight(errorInsight);
+            return errorInsight;
+        }
+    }
+    buildComprehensiveContext(session, analytics) {
+        const messages = session.messages;
+        // Build detailed message list with indices
+        const messageDetails = messages.map((m, i) => {
+            let detail = `[${i}] ${m.type.toUpperCase()} (${m.timestamp})`;
+            if (m.type === 'tool-use' && m.metadata?.toolName) {
+                detail += ` - Tool: ${m.metadata.toolName}`;
+            }
+            if (m.metadata?.tokens) {
+                detail += ` - Tokens: ${m.metadata.tokens.input + m.metadata.tokens.output}`;
+            }
+            detail += `\n${m.content.substring(0, 500)}${m.content.length > 500 ? '...' : ''}`;
+            return detail;
+        }).join('\n\n');
+        // Tool usage summary
+        const toolCalls = messages.filter(m => m.type === 'tool-use');
+        const toolSummary = toolCalls.reduce((acc, m) => {
+            const name = m.metadata?.toolName || 'unknown';
+            acc[name] = (acc[name] || 0) + 1;
+            return acc;
+        }, {});
+        // Thinking messages for duration analysis
+        const thinkingMessages = messages.filter(m => m.type === 'thinking').length;
+        // Code-related tools
+        const codeTools = ['Edit', 'Write', 'Read', 'Bash'];
+        const codeChanges = toolCalls.filter(m => codeTools.includes(m.metadata?.toolName || ''));
+        let context = `# Comprehensive Session Analysis Request
+
+## Session Statistics
+- Total messages: ${messages.length}
+- User messages: ${messages.filter(m => m.type === 'user').length}
+- Assistant messages: ${messages.filter(m => m.type === 'assistant').length}
+- Tool calls: ${toolCalls.length}
+- Thinking blocks: ${thinkingMessages}
+- Code-related operations: ${codeChanges.length}
+`;
+        if (analytics) {
+            context += `
+## Analytics Data
+- Total cost: $${analytics.cost?.totalCost?.toFixed(4) ?? 'N/A'}
+- Total tokens: ${analytics.tokens?.totalTokens ?? 'N/A'}
+- Input tokens: ${analytics.tokens?.inputTokens ?? 'N/A'}
+- Output tokens: ${analytics.tokens?.outputTokens ?? 'N/A'}
+- Cached tokens: ${analytics.tokens?.cacheReadTokens ?? 'N/A'}
+- Duration: ${analytics.durationMinutes ?? 'N/A'} minutes
+`;
+        }
+        context += `
+## Tool Usage Summary
+${Object.entries(toolSummary).map(([name, count]) => `- ${name}: ${count} calls`).join('\n') || 'No tools used'}
+
+## Full Message Transcript (with indices)
+${messageDetails}
+`;
+        return context;
+    }
+    async callClaudeCode(context) {
+        const prompt = `You are an expert AI session analyst. Analyze this Claude Code session transcript and provide comprehensive insights.
+
+IMPORTANT: Return ONLY a valid JSON object. No markdown, no explanation, no code blocks - just the raw JSON.
+
+The JSON must follow this exact structure:
+{
+  "title": "Brief title describing the session (5-10 words)",
+  "summary": "2-3 sentence summary of what was accomplished",
+  "keyAccomplishments": ["accomplishment 1", "accomplishment 2", "accomplishment 3"],
+
+  "sentiment": {
+    "overall": "positive|neutral|negative|mixed",
+    "averageScore": 0.5,
+    "timeline": [
+      {"messageIndex": 0, "timestamp": "ISO timestamp", "sentiment": "positive|neutral|negative|frustrated", "score": 0.7, "reason": "brief reason"}
+    ],
+    "frustrationSpikes": [
+      {"messageIndex": 5, "reason": "why user seemed frustrated"}
+    ],
+    "moodShifts": [
+      {"fromIndex": 2, "toIndex": 5, "from": "positive", "to": "frustrated", "trigger": "what caused the shift"}
+    ]
+  },
+
+  "topics": [
+    {
+      "id": "topic-1",
+      "name": "Topic Name",
+      "description": "What this segment covers",
+      "startIndex": 0,
+      "endIndex": 10,
+      "messageCount": 11,
+      "category": "debugging|feature|explanation|refactoring|testing|documentation|setup|other",
+      "keywords": ["keyword1", "keyword2"]
+    }
+  ],
+
+  "quality": {
+    "averageScore": 85,
+    "distribution": {"excellent": 5, "good": 10, "fair": 3, "poor": 1},
+    "responses": [
+      {"messageIndex": 1, "score": 90, "metrics": {"relevance": 95, "completeness": 85, "accuracy": 90, "helpfulness": 90}, "issues": []}
+    ],
+    "bestResponses": [{"index": 5, "reason": "why this response was excellent"}],
+    "improvementAreas": ["area that could be improved"]
+  },
+
+  "metadata": {
+    "duration": {"total": 30, "thinking": 5, "toolExecution": 10, "userWaiting": 15},
+    "tokens": {"total": 0, "input": 0, "output": 0, "cached": 0, "bySection": [{"topic": "Topic Name", "tokens": 1000}]},
+    "tools": {
+      "total": 15,
+      "byName": [{"name": "Edit", "count": 5, "successRate": 100}],
+      "mostUsed": ["Edit", "Read", "Bash"]
+    },
+    "codeChanges": {
+      "filesEdited": 3,
+      "filesCreated": 1,
+      "linesAdded": 150,
+      "linesRemoved": 50,
+      "files": [{"path": "src/file.ts", "action": "edit", "changes": 50}]
+    },
+    "errors": {
+      "count": 2,
+      "types": [{"type": "TypeScript", "count": 2}],
+      "details": [{"message": "error message", "resolved": true, "messageIndex": 10}]
+    }
+  },
+
+  "actionableSummary": {
+    "mainTasks": [{"task": "task description", "status": "completed|partial|failed"}],
+    "errorsEncountered": [{"error": "error description", "resolution": "how it was resolved"}],
+    "codeChanges": [{"file": "filename", "description": "what changed"}],
+    "keyDecisions": [{"decision": "what was decided", "rationale": "why"}],
+    "learnings": ["key insight or learning from the session"]
+  },
+
+  "costOptimization": {
+    "suggestions": [
+      {"type": "model|caching|context|tool-usage", "title": "suggestion title", "description": "detailed explanation", "impact": "low|medium|high"}
+    ],
+    "potentialSavings": 0.05
+  },
+
+  "followUps": [
+    {"type": "incomplete|test|documentation|refactor", "title": "follow-up title", "description": "what to do next", "priority": "low|medium|high"}
+  ]
+}
+
+Analyze the following session thoroughly. Pay special attention to:
+1. Sentiment changes throughout the conversation
+2. Natural topic boundaries and transitions
+3. Quality of assistant responses
+4. Code changes and their impact
+5. Errors and how they were handled
+6. Opportunities for cost optimization
+
+Session Data:
+${context}`;
+        // Write prompt to temp file to avoid shell argument limits
+        const tempFile = path.join(os.tmpdir(), `claude-insight-${Date.now()}.txt`);
+        await fs.writeFile(tempFile, prompt, 'utf-8');
+        console.log(`[Insights] Prompt written to temp file: ${tempFile}`);
+        return new Promise((resolve, reject) => {
+            const timeout = 300000; // 5 minutes
+            const timer = setTimeout(() => {
+                console.log(`[Insights] TIMEOUT after 5 minutes`);
+                fs.unlink(tempFile).catch(() => { });
+                reject(new Error('Insight generation timed out after 5 minutes'));
+            }, timeout);
+            // Use shell with cat to pipe content to claude
+            const command = `cat "${tempFile}" | claude -p --output-format text`;
+            console.log(`[Insights] Executing command...`);
+            exec(command, {
+                cwd: process.cwd(),
+                env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                timeout: timeout,
+            }, (error, stdout, stderr) => {
+                clearTimeout(timer);
+                fs.unlink(tempFile).catch(() => { }); // Clean up temp file
+                if (stderr) {
+                    console.log(`[Insights] stderr: ${stderr.slice(0, 200)}`);
+                }
+                if (error) {
+                    console.log(`[Insights] Error: ${error.message}`);
+                    reject(new Error(`Failed to run claude: ${error.message}`));
+                    return;
+                }
+                console.log(`[Insights] Response received, length: ${stdout.length} chars`);
+                resolve(stdout);
+            });
+        });
+    }
+    parseRichResponse(response, session, analytics) {
+        const cleanedResponse = response
+            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+            .replace(/[\r\n]+/g, '\n')
+            .trim();
+        const jsonMatch = cleanedResponse.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return this.generateFallbackInsight(session, analytics);
+        }
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                title: parsed.title || 'Session Analysis',
+                summary: parsed.summary || '',
+                keyAccomplishments: this.ensureArray(parsed.keyAccomplishments),
+                sentiment: this.parseSentiment(parsed.sentiment),
+                topics: this.parseTopics(parsed.topics),
+                quality: this.parseQuality(parsed.quality),
+                metadata: this.parseMetadata(parsed.metadata, session, analytics),
+                actionableSummary: this.parseActionableSummary(parsed.actionableSummary),
+                costOptimization: parsed.costOptimization ? {
+                    totalCost: analytics?.cost?.totalCost ?? 0,
+                    suggestions: this.ensureArray(parsed.costOptimization.suggestions).map((s) => ({
+                        type: s.type || 'context',
+                        title: s.title || '',
+                        description: s.description || '',
+                        impact: s.impact || 'low',
+                    })),
+                    potentialSavings: parsed.costOptimization.potentialSavings,
+                } : undefined,
+                followUps: this.ensureArray(parsed.followUps).map((f) => ({
+                    type: f.type || 'incomplete',
+                    title: f.title || '',
+                    description: f.description || '',
+                    priority: f.priority || 'low',
+                })),
+            };
+        }
+        catch {
+            return this.generateFallbackInsight(session, analytics);
+        }
+    }
+    ensureArray(val) {
+        return Array.isArray(val) ? val : [];
+    }
+    parseSentiment(data) {
+        if (!data || typeof data !== 'object')
+            return undefined;
+        const d = data;
+        return {
+            overall: d.overall || 'neutral',
+            averageScore: typeof d.averageScore === 'number' ? d.averageScore : 0,
+            timeline: this.ensureArray(d.timeline),
+            frustrationSpikes: this.ensureArray(d.frustrationSpikes),
+            moodShifts: this.ensureArray(d.moodShifts),
+        };
+    }
+    parseTopics(data) {
+        if (!Array.isArray(data))
+            return undefined;
+        return data.map((t, i) => ({
+            id: t.id || `topic-${i}`,
+            name: t.name || `Topic ${i + 1}`,
+            description: t.description || '',
+            startIndex: t.startIndex || 0,
+            endIndex: t.endIndex || 0,
+            messageCount: t.messageCount || 0,
+            category: t.category || 'other',
+            keywords: this.ensureArray(t.keywords),
+        }));
+    }
+    parseQuality(data) {
+        if (!data || typeof data !== 'object')
+            return undefined;
+        const d = data;
+        return {
+            averageScore: typeof d.averageScore === 'number' ? d.averageScore : 0,
+            distribution: d.distribution || { excellent: 0, good: 0, fair: 0, poor: 0 },
+            responses: this.ensureArray(d.responses),
+            bestResponses: this.ensureArray(d.bestResponses),
+            improvementAreas: this.ensureArray(d.improvementAreas),
+        };
+    }
+    parseMetadata(data, session, analytics) {
+        const d = (data && typeof data === 'object') ? data : {};
+        const duration = (d.duration && typeof d.duration === 'object') ? d.duration : {};
+        const tokens = (d.tokens && typeof d.tokens === 'object') ? d.tokens : {};
+        const tools = (d.tools && typeof d.tools === 'object') ? d.tools : {};
+        const codeChanges = (d.codeChanges && typeof d.codeChanges === 'object') ? d.codeChanges : {};
+        const errors = (d.errors && typeof d.errors === 'object') ? d.errors : {};
+        // Calculate from session data if not provided
+        const toolCalls = session.messages.filter(m => m.type === 'tool-use');
+        const thinkingMsgs = session.messages.filter(m => m.type === 'thinking');
+        return {
+            duration: {
+                total: duration.total || analytics?.durationMinutes || 0,
+                thinking: duration.thinking || thinkingMsgs.length * 0.5, // estimate
+                toolExecution: duration.toolExecution || toolCalls.length * 0.3,
+                userWaiting: duration.userWaiting || 0,
+            },
+            tokens: {
+                total: analytics?.tokens?.totalTokens || 0,
+                input: analytics?.tokens?.inputTokens || 0,
+                output: analytics?.tokens?.outputTokens || 0,
+                cached: analytics?.tokens?.cacheReadTokens || 0,
+                bySection: this.ensureArray(tokens.bySection),
+            },
+            tools: {
+                total: typeof tools.total === 'number' ? tools.total : toolCalls.length,
+                byName: this.ensureArray(tools.byName).length > 0
+                    ? this.ensureArray(tools.byName)
+                    : (analytics?.toolUsage || []).map(t => ({
+                        name: t.toolName,
+                        count: t.count,
+                        successRate: t.successCount !== undefined && t.count > 0
+                            ? (t.successCount / t.count) * 100
+                            : 100,
+                    })),
+                mostUsed: this.ensureArray(tools.mostUsed),
+            },
+            codeChanges: {
+                filesEdited: typeof codeChanges.filesEdited === 'number' ? codeChanges.filesEdited : 0,
+                filesCreated: typeof codeChanges.filesCreated === 'number' ? codeChanges.filesCreated : 0,
+                linesAdded: typeof codeChanges.linesAdded === 'number' ? codeChanges.linesAdded : 0,
+                linesRemoved: typeof codeChanges.linesRemoved === 'number' ? codeChanges.linesRemoved : 0,
+                files: this.ensureArray(codeChanges.files),
+            },
+            errors: {
+                count: typeof errors.count === 'number' ? errors.count : 0,
+                types: this.ensureArray(errors.types),
+                details: this.ensureArray(errors.details),
+            },
+        };
+    }
+    parseActionableSummary(data) {
+        if (!data || typeof data !== 'object')
+            return undefined;
+        const d = data;
+        return {
+            mainTasks: this.ensureArray(d.mainTasks),
+            errorsEncountered: this.ensureArray(d.errorsEncountered),
+            codeChanges: this.ensureArray(d.codeChanges),
+            keyDecisions: this.ensureArray(d.keyDecisions),
+            learnings: this.ensureArray(d.learnings),
+        };
+    }
+    generateFallbackInsight(session, analytics) {
+        const messages = session.messages;
+        const toolCalls = messages.filter(m => m.type === 'tool-use');
+        return {
+            title: 'Session Analysis',
+            summary: 'Automated analysis of the session. AI-generated insights could not be parsed.',
+            keyAccomplishments: [],
+            metadata: this.parseMetadata({}, session, analytics),
+            sentiment: {
+                overall: 'neutral',
+                averageScore: 0,
+                timeline: [],
+                frustrationSpikes: [],
+                moodShifts: [],
+            },
+            topics: [{
+                    id: 'topic-1',
+                    name: 'Full Session',
+                    description: 'Complete session transcript',
+                    startIndex: 0,
+                    endIndex: messages.length - 1,
+                    messageCount: messages.length,
+                    category: 'other',
+                    keywords: [],
+                }],
+            quality: {
+                averageScore: 0,
+                distribution: { excellent: 0, good: 0, fair: 0, poor: 0 },
+                responses: [],
+                bestResponses: [],
+                improvementAreas: [],
+            },
+            actionableSummary: {
+                mainTasks: [],
+                errorsEncountered: [],
+                codeChanges: [],
+                keyDecisions: [],
+                learnings: [],
+            },
+        };
+    }
+    // --------------------------------------------------------------------------
+    // Project-Level AI Insights
+    // --------------------------------------------------------------------------
+    getProjectInsightPath(projectPath) {
+        const sanitized = projectPath.replace(/\//g, '-').replace(/^-/, '');
+        return path.join(this.claudeDir.insightsDir, `project-${sanitized}.json`);
+    }
+    getGlobalInsightPath() {
+        return path.join(this.claudeDir.insightsDir, 'global-insight.json');
+    }
+    async getProjectAIInsight(projectPath) {
+        const insightPath = this.getProjectInsightPath(projectPath);
+        return this.claudeDir.readJSON(insightPath);
+    }
+    async getGlobalAIInsight() {
+        const insightPath = this.getGlobalInsightPath();
+        return this.claudeDir.readJSON(insightPath);
+    }
+    async generateProjectAIInsight(projectPath, force = false) {
+        if (!force) {
+            const cached = await this.getProjectAIInsight(projectPath);
+            if (cached && cached.status === 'completed') {
+                return cached;
+            }
+        }
+        const projectName = path.basename(projectPath);
+        const pendingInsight = {
+            projectPath,
+            projectName,
+            version: INSIGHT_VERSION,
+            generatedAt: new Date().toISOString(),
+            status: 'generating',
+        };
+        await this.claudeDir.ensureInsightsDir();
+        const insightPath = this.getProjectInsightPath(projectPath);
+        await this.claudeDir.writeJSON(insightPath, pendingInsight);
+        try {
+            const insight = await this.doGenerateProjectInsight(projectPath);
+            return insight;
+        }
+        catch (error) {
+            const errorInsight = {
+                ...pendingInsight,
+                status: 'error',
+                error: error.message,
+            };
+            await this.claudeDir.writeJSON(insightPath, errorInsight);
+            return errorInsight;
+        }
+    }
+    async generateGlobalAIInsight(force = false) {
+        if (!force) {
+            const cached = await this.getGlobalAIInsight();
+            if (cached && cached.status === 'completed') {
+                return cached;
+            }
+        }
+        const pendingInsight = {
+            projectPath: 'global',
+            projectName: 'All Projects',
+            version: INSIGHT_VERSION,
+            generatedAt: new Date().toISOString(),
+            status: 'generating',
+        };
+        await this.claudeDir.ensureInsightsDir();
+        const insightPath = this.getGlobalInsightPath();
+        await this.claudeDir.writeJSON(insightPath, pendingInsight);
+        try {
+            const insight = await this.doGenerateGlobalInsight();
+            return insight;
+        }
+        catch (error) {
+            const errorInsight = {
+                ...pendingInsight,
+                status: 'error',
+                error: error.message,
+            };
+            await this.claudeDir.writeJSON(insightPath, errorInsight);
+            return errorInsight;
+        }
+    }
+    async doGenerateProjectInsight(projectPath) {
+        console.log(`[ProjectInsight] Starting for project: ${projectPath}`);
+        const projectName = path.basename(projectPath);
+        const projectDirs = await this.claudeDir.listProjects();
+        const projectDir = projectDirs.find(d => this.claudeDir.projectDirToPath(d) === projectPath);
+        if (!projectDir) {
+            throw new Error('Project not found');
+        }
+        // Gather all sessions and analytics for this project
+        const sessionFiles = await this.claudeDir.listSessionFiles(projectDir);
+        console.log(`[ProjectInsight] Found ${sessionFiles.length} session files`);
+        const sessionsData = [];
+        for (const filePath of sessionFiles.slice(0, 20)) { // Limit to 20 most recent
+            const sessionId = path.basename(filePath, '.jsonl');
+            const session = await this.sessionService.getSession(sessionId);
+            if (session) {
+                const analytics = await this.analyticsService.getSessionAnalytics(filePath, projectDir);
+                sessionsData.push({
+                    id: sessionId,
+                    messages: session.messages,
+                    analytics,
+                });
+            }
+        }
+        console.log(`[ProjectInsight] Loaded ${sessionsData.length} sessions`);
+        const context = this.buildProjectContext(projectName, sessionsData);
+        console.log(`[ProjectInsight] Context built, length: ${context.length} chars`);
+        console.log(`[ProjectInsight] Calling Claude Code...`);
+        const aiResponse = await this.callClaudeForProjectInsight(context);
+        console.log(`[ProjectInsight] Response received, length: ${aiResponse.length} chars`);
+        const parsed = this.parseProjectInsightResponse(aiResponse);
+        const insight = {
+            projectPath,
+            projectName,
+            version: INSIGHT_VERSION,
+            generatedAt: new Date().toISOString(),
+            status: 'completed',
+            ...parsed,
+        };
+        const insightPath = this.getProjectInsightPath(projectPath);
+        await this.claudeDir.writeJSON(insightPath, insight);
+        return insight;
+    }
+    async doGenerateGlobalInsight() {
+        const projectDirs = await this.claudeDir.listProjects();
+        const allProjectsData = [];
+        for (const projectDir of projectDirs.slice(0, 10)) {
+            const projectPath = this.claudeDir.projectDirToPath(projectDir);
+            const projectName = this.claudeDir.projectDirToName(projectDir);
+            const sessionFiles = await this.claudeDir.listSessionFiles(projectDir);
+            let totalCost = 0;
+            let totalTokens = 0;
+            const toolUsage = {};
+            const filePatterns = new Set();
+            for (const filePath of sessionFiles.slice(0, 10)) {
+                const analytics = await this.analyticsService.getSessionAnalytics(filePath, projectDir);
+                if (analytics) {
+                    totalCost += analytics.cost?.totalCost || 0;
+                    totalTokens += analytics.tokens?.totalTokens || 0;
+                    for (const tool of analytics.toolUsage || []) {
+                        toolUsage[tool.toolName] = (toolUsage[tool.toolName] || 0) + tool.count;
+                    }
+                }
+                const sessionId = path.basename(filePath, '.jsonl');
+                const session = await this.sessionService.getSession(sessionId);
+                if (session) {
+                    for (const msg of session.messages) {
+                        if (msg.type === 'tool-use' && msg.metadata?.toolInput) {
+                            const input = msg.metadata.toolInput;
+                            if (input.file_path && typeof input.file_path === 'string') {
+                                const ext = path.extname(input.file_path);
+                                if (ext)
+                                    filePatterns.add(ext);
+                            }
+                        }
+                    }
+                }
+            }
+            allProjectsData.push({
+                projectName,
+                projectPath,
+                sessionCount: sessionFiles.length,
+                totalCost,
+                totalTokens,
+                toolUsage,
+                filePatterns: Array.from(filePatterns),
+            });
+        }
+        const context = this.buildGlobalContext(allProjectsData);
+        const aiResponse = await this.callClaudeForProjectInsight(context);
+        const parsed = this.parseProjectInsightResponse(aiResponse);
+        const insight = {
+            projectPath: 'global',
+            projectName: 'All Projects',
+            version: INSIGHT_VERSION,
+            generatedAt: new Date().toISOString(),
+            status: 'completed',
+            ...parsed,
+        };
+        const insightPath = this.getGlobalInsightPath();
+        await this.claudeDir.writeJSON(insightPath, insight);
+        return insight;
+    }
+    buildProjectContext(projectName, sessions) {
+        let totalMessages = 0;
+        let totalCost = 0;
+        let totalTokens = 0;
+        const allTools = {};
+        const allFiles = new Set();
+        const allTopics = [];
+        const errorPatterns = [];
+        for (const session of sessions) {
+            totalMessages += session.messages.length;
+            totalCost += session.analytics?.cost?.totalCost || 0;
+            totalTokens += session.analytics?.tokens?.totalTokens || 0;
+            for (const msg of session.messages) {
+                if (msg.type === 'tool-use' && msg.metadata?.toolName) {
+                    allTools[msg.metadata.toolName] = (allTools[msg.metadata.toolName] || 0) + 1;
+                    const input = msg.metadata.toolInput;
+                    if (input?.file_path && typeof input.file_path === 'string') {
+                        allFiles.add(input.file_path);
+                    }
+                }
+                // Collect error patterns
+                if (msg.content.toLowerCase().includes('error') ||
+                    msg.content.toLowerCase().includes('failed') ||
+                    msg.content.toLowerCase().includes('exception')) {
+                    const snippet = msg.content.substring(0, 100);
+                    if (!errorPatterns.includes(snippet)) {
+                        errorPatterns.push(snippet);
+                    }
+                }
+                // Collect topics from user messages
+                if (msg.type === 'user' && msg.content.length > 20) {
+                    allTopics.push(msg.content.substring(0, 200));
+                }
+            }
+        }
+        return `# Project-Level AI Analysis Request
+
+## Project: ${projectName}
+
+## Aggregate Statistics
+- Total sessions analyzed: ${sessions.length}
+- Total messages: ${totalMessages}
+- Total cost: $${totalCost.toFixed(4)}
+- Total tokens: ${totalTokens.toLocaleString()}
+
+## Tool Usage Summary
+${Object.entries(allTools)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 15)
+            .map(([tool, count]) => `- ${tool}: ${count} calls`)
+            .join('\n')}
+
+## Files Touched (sample)
+${Array.from(allFiles).slice(0, 30).map(f => `- ${f}`).join('\n')}
+
+## File Extensions Used
+${Array.from(new Set(Array.from(allFiles).map(f => path.extname(f)).filter(Boolean))).join(', ')}
+
+## Sample User Requests (to understand project focus)
+${allTopics.slice(0, 15).map((t, i) => `${i + 1}. ${t}`).join('\n')}
+
+## Error Patterns Observed
+${errorPatterns.slice(0, 10).map((e, i) => `${i + 1}. ${e}`).join('\n')}
+`;
+    }
+    buildGlobalContext(projects) {
+        const totalCost = projects.reduce((sum, p) => sum + p.totalCost, 0);
+        const totalTokens = projects.reduce((sum, p) => sum + p.totalTokens, 0);
+        const totalSessions = projects.reduce((sum, p) => sum + p.sessionCount, 0);
+        const globalToolUsage = {};
+        const allFilePatterns = new Set();
+        for (const project of projects) {
+            for (const [tool, count] of Object.entries(project.toolUsage)) {
+                globalToolUsage[tool] = (globalToolUsage[tool] || 0) + count;
+            }
+            for (const pattern of project.filePatterns) {
+                allFilePatterns.add(pattern);
+            }
+        }
+        return `# Global AI Analysis Request (All Projects)
+
+## Overview
+- Total projects: ${projects.length}
+- Total sessions: ${totalSessions}
+- Total cost: $${totalCost.toFixed(4)}
+- Total tokens: ${totalTokens.toLocaleString()}
+
+## Projects Summary
+${projects.map(p => `- ${p.projectName}: ${p.sessionCount} sessions, $${p.totalCost.toFixed(4)}`).join('\n')}
+
+## Global Tool Usage
+${Object.entries(globalToolUsage)
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 15)
+            .map(([tool, count]) => `- ${tool}: ${count} calls`)
+            .join('\n')}
+
+## Technology Patterns (file extensions)
+${Array.from(allFilePatterns).join(', ')}
+
+## Cost Distribution by Project
+${projects
+            .sort((a, b) => b.totalCost - a.totalCost)
+            .map(p => `- ${p.projectName}: $${p.totalCost.toFixed(4)} (${((p.totalCost / totalCost) * 100).toFixed(1)}%)`)
+            .join('\n')}
+`;
+    }
+    async callClaudeForProjectInsight(context) {
+        const prompt = `Analyze this Claude Code usage data and return ONLY valid JSON (no markdown, no explanation).
+
+Required JSON structure with these exact keys:
+- summary: string (2-3 paragraph executive summary)
+- highlights: string[] (3-5 positive findings)
+- concerns: string[] (2-3 areas of concern)
+- healthScore: {overall: number 0-100, categories: {codeQuality, testCoverage, documentation, errorRate, velocity: numbers}, trends: [{category, direction: "improving"|"declining"|"stable", change: number}]}
+- techStack: [{name, type: "language"|"framework"|"library"|"tool", usage: number, proficiency: "beginner"|"intermediate"|"advanced"|"expert", relatedFiles: string[]}]
+- techStackRecommendations: string[]
+- codingPatterns: [{name, description, frequency: number, category: "architecture"|"design"|"testing"|"other", examples: string[], recommendation}]
+- antiPatterns: same structure as codingPatterns
+- developmentPatterns: [{pattern, description, frequency: number, impact: "positive"|"neutral"|"negative", suggestion}]
+- workflowInsights: [{name, description, efficiency: number 0-100, bottlenecks: string[], suggestions: string[]}]
+- productivityMetrics: [{name, value: number, unit, trend: "up"|"down"|"stable", percentChange?: number}]
+- learningInsights: [{topic, proficiencyGain: number, timeInvested: number, resourcesUsed: string[], nextSteps: string[]}]
+- skillGrowth: [{skill, level: number 0-100, growth: number}]
+- costAnalysis: {totalCost, costPerSession, projectedMonthlyCost: numbers, optimizationOpportunities: [{type, title, description, impact: "low"|"medium"|"high"}]}
+- recommendations: [{category: "performance"|"quality"|"cost"|"learning"|"workflow", priority: "low"|"medium"|"high", title, description, expectedImpact}]
+
+Data to analyze:
+${context}`;
+        // Write prompt to temp file to avoid shell argument limits
+        const tempFile = path.join(os.tmpdir(), `claude-prompt-${Date.now()}.txt`);
+        await fs.writeFile(tempFile, prompt, 'utf-8');
+        console.log(`[ProjectInsight] Prompt written to temp file: ${tempFile}`);
+        return new Promise((resolve, reject) => {
+            const timeout = 300000; // 5 minutes
+            const timer = setTimeout(() => {
+                console.log(`[ProjectInsight] TIMEOUT after 5 minutes`);
+                fs.unlink(tempFile).catch(() => { });
+                reject(new Error('Project insight generation timed out after 5 minutes'));
+            }, timeout);
+            // Use shell with cat to pipe content to claude
+            const command = `cat "${tempFile}" | claude -p --output-format text`;
+            console.log(`[ProjectInsight] Executing: ${command.slice(0, 100)}...`);
+            exec(command, {
+                cwd: process.cwd(),
+                env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+                maxBuffer: 10 * 1024 * 1024, // 10MB buffer
+                timeout: timeout,
+            }, (error, stdout, stderr) => {
+                clearTimeout(timer);
+                fs.unlink(tempFile).catch(() => { }); // Clean up temp file
+                if (stderr) {
+                    console.log(`[ProjectInsight] stderr: ${stderr.slice(0, 200)}`);
+                }
+                if (error) {
+                    console.log(`[ProjectInsight] Error: ${error.message}`);
+                    reject(error);
+                    return;
+                }
+                console.log(`[ProjectInsight] Response received, length: ${stdout.length} chars`);
+                resolve(stdout);
+            });
+        });
+    }
+    parseProjectInsightResponse(response) {
+        const cleanedResponse = response
+            .replace(/\x1b\[[0-9;]*[a-zA-Z]/g, '')
+            .replace(/[\r\n]+/g, '\n')
+            .trim();
+        const jsonMatch = cleanedResponse.match(/\{[\s\S]*\}/);
+        if (!jsonMatch) {
+            return {
+                summary: 'Unable to parse AI response.',
+                highlights: [],
+                concerns: [],
+                recommendations: [],
+            };
+        }
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                summary: parsed.summary || '',
+                highlights: this.ensureArray(parsed.highlights),
+                concerns: this.ensureArray(parsed.concerns),
+                healthScore: parsed.healthScore,
+                techStack: this.ensureArray(parsed.techStack),
+                techStackRecommendations: this.ensureArray(parsed.techStackRecommendations),
+                codingPatterns: this.ensureArray(parsed.codingPatterns),
+                antiPatterns: this.ensureArray(parsed.antiPatterns),
+                developmentPatterns: this.ensureArray(parsed.developmentPatterns),
+                workflowInsights: this.ensureArray(parsed.workflowInsights),
+                productivityMetrics: this.ensureArray(parsed.productivityMetrics),
+                velocityTrend: this.ensureArray(parsed.velocityTrend),
+                learningInsights: this.ensureArray(parsed.learningInsights),
+                skillGrowth: this.ensureArray(parsed.skillGrowth),
+                costAnalysis: parsed.costAnalysis,
+                collaborationPatterns: parsed.collaborationPatterns,
+                recommendations: this.ensureArray(parsed.recommendations),
+            };
+        }
+        catch {
+            return {
+                summary: 'Unable to parse AI response as JSON.',
+                highlights: [],
+                concerns: [],
+                recommendations: [],
+            };
+        }
+    }
+    // --------------------------------------------------------------------------
+    // Status Check
+    // --------------------------------------------------------------------------
+    async isClaudeCodeAvailable() {
+        try {
+            const { execSync } = await import('node:child_process');
+            execSync('which claude', { stdio: 'ignore' });
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+}
+//# sourceMappingURL=insights.js.map