claudecto 0.1.0

package/dist/services/project-intelligence.js

@@ -0,0 +1,731 @@
+/**
+ * Project Intelligence Service
+ *
+ * Generates cross-session, project-level insights including:
+ * - Project story and narrative
+ * - Code hotspots and evolution
+ * - Development milestones
+ * - Workflow patterns
+ * - Recurring challenges
+ * - Claude effectiveness analysis
+ * - Smart recommendations
+ *
+ * This is DIFFERENT from session insights (single conversation) and
+ * analytics (cost/token tracking). Project Intelligence looks at
+ * patterns and evolution across ALL sessions in a project.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import { exec } from 'node:child_process';
+import { promisify } from 'node:util';
+const execAsync = promisify(exec);
+const INTELLIGENCE_CACHE_DIR = 'intelligence';
+const CACHE_VERSION = 1;
+export class ProjectIntelligenceService {
+    claudeDir;
+    sessionService;
+    constructor(claudeDir, sessionService) {
+        this.claudeDir = claudeDir;
+        this.sessionService = sessionService;
+    }
+    /**
+     * Get intelligence cache directory
+     */
+    async getIntelligenceDir() {
+        const dir = path.join(this.claudeDir.root, INTELLIGENCE_CACHE_DIR);
+        await fs.mkdir(dir, { recursive: true });
+        return dir;
+    }
+    /**
+     * Get cache file path for a project
+     */
+    getProjectCachePath(projectPath) {
+        const sanitized = projectPath.replace(/[\/\\:]/g, '-').replace(/^-/, '');
+        return path.join(this.claudeDir.root, INTELLIGENCE_CACHE_DIR, `project-${sanitized}.json`);
+    }
+    /**
+     * Get cached intelligence for a project
+     */
+    async getProjectIntelligence(projectPath) {
+        try {
+            const cachePath = this.getProjectCachePath(projectPath);
+            const content = await fs.readFile(cachePath, 'utf-8');
+            return JSON.parse(content);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * List all projects with their intelligence summaries
+     */
+    async listProjectIntelligence() {
+        const projects = await this.sessionService.listProjects();
+        const summaries = [];
+        for (const project of projects) {
+            const cached = await this.getProjectIntelligence(project.path);
+            if (cached && cached.status === 'completed') {
+                summaries.push({
+                    projectPath: project.path,
+                    projectName: project.name,
+                    health: cached.health?.overall ?? 50,
+                    healthTrend: cached.health?.trend ?? 'stable',
+                    sessionCount: cached.sessionCount,
+                    lastActive: cached.dateRange?.last ?? project.lastActivity,
+                    currentFocus: cached.currentFocus,
+                    topChallenges: cached.challenges?.slice(0, 2).map(c => c.title) ?? [],
+                    topRecommendations: cached.recommendations?.slice(0, 2).map(r => r.title) ?? [],
+                    hasFullIntelligence: true,
+                });
+            }
+            else {
+                // Return basic info without full intelligence
+                summaries.push({
+                    projectPath: project.path,
+                    projectName: project.name,
+                    health: 50,
+                    healthTrend: 'stable',
+                    sessionCount: project.sessionCount,
+                    lastActive: project.lastActivity,
+                    topChallenges: [],
+                    topRecommendations: [],
+                    hasFullIntelligence: false,
+                });
+            }
+        }
+        // Sort by last activity
+        summaries.sort((a, b) => new Date(b.lastActive).getTime() - new Date(a.lastActive).getTime());
+        return summaries;
+    }
+    /**
+     * Generate intelligence for a specific project
+     */
+    async generateProjectIntelligence(projectPath, force = false) {
+        // Check cache first
+        if (!force) {
+            const cached = await this.getProjectIntelligence(projectPath);
+            if (cached && cached.status === 'completed') {
+                // Cache valid for 12 hours
+                const age = Date.now() - new Date(cached.generatedAt).getTime();
+                if (age < 12 * 60 * 60 * 1000) {
+                    return cached;
+                }
+            }
+        }
+        const cachePath = this.getProjectCachePath(projectPath);
+        const projectName = path.basename(projectPath);
+        // Create pending entry
+        const pending = {
+            projectPath,
+            projectName,
+            generatedAt: new Date().toISOString(),
+            status: 'generating',
+            sessionCount: 0,
+            totalTokens: 0,
+            totalCost: 0,
+            dateRange: { first: '', last: '' },
+            filesCreated: 0,
+            filesEdited: 0,
+        };
+        await fs.writeFile(cachePath, JSON.stringify(pending, null, 2));
+        try {
+            // Gather session data for this project
+            const { sessions } = await this.sessionService.listSessions({ project: projectPath, limit: 500 });
+            if (sessions.length === 0) {
+                const empty = {
+                    ...pending,
+                    status: 'completed',
+                    sessionCount: 0,
+                };
+                await fs.writeFile(cachePath, JSON.stringify(empty, null, 2));
+                return empty;
+            }
+            // Load session details (limit to recent 50 for performance)
+            const sessionDetails = await Promise.all(sessions.slice(0, 50).map(s => this.sessionService.getSession(s.id)));
+            const validSessions = sessionDetails.filter(s => s !== null);
+            // Analyze sessions
+            const analysis = this.analyzeProjectSessions(validSessions, projectPath);
+            // Generate AI narrative if Claude is available
+            let aiNarrative = null;
+            if (await this.isClaudeAvailable()) {
+                aiNarrative = await this.generateAINarrative(analysis, projectName);
+            }
+            // Build complete intelligence
+            const intelligence = {
+                projectPath,
+                projectName,
+                generatedAt: new Date().toISOString(),
+                status: 'completed',
+                // Summary
+                storyNarrative: aiNarrative?.story ?? this.generateBasicNarrative(analysis),
+                currentFocus: aiNarrative?.focus ?? analysis.recentTopics[0],
+                // Health & Metrics
+                health: analysis.health,
+                sessionCount: sessions.length,
+                totalTokens: analysis.totalTokens,
+                totalCost: analysis.totalCost,
+                dateRange: analysis.dateRange,
+                // Code Analysis
+                codeHotspots: analysis.hotspots,
+                primaryLanguages: analysis.languages,
+                filesCreated: analysis.filesCreated,
+                filesEdited: analysis.filesEdited,
+                // Timeline & Milestones
+                milestones: analysis.milestones,
+                recentActivity: analysis.recentActivity,
+                // Patterns & Workflows
+                workflowPatterns: analysis.workflowPatterns,
+                activityPattern: analysis.activityPattern,
+                // Challenges
+                challenges: analysis.challenges,
+                errorPatterns: analysis.errorPatterns,
+                // Claude Usage
+                claudeEffectiveness: analysis.claudeEffectiveness,
+                topTools: analysis.topTools,
+                // Recommendations
+                recommendations: aiNarrative?.recommendations ?? analysis.basicRecommendations,
+                // Quick Stats
+                quickStats: analysis.quickStats,
+            };
+            await fs.writeFile(cachePath, JSON.stringify(intelligence, null, 2));
+            return intelligence;
+        }
+        catch (error) {
+            const failed = {
+                ...pending,
+                status: 'error',
+                error: {
+                    code: 'UNKNOWN',
+                    message: error.message,
+                    recoverable: true,
+                    suggestion: 'Try regenerating the intelligence',
+                },
+            };
+            await fs.writeFile(cachePath, JSON.stringify(failed, null, 2));
+            return failed;
+        }
+    }
+    /**
+     * Analyze sessions to extract project intelligence
+     */
+    analyzeProjectSessions(sessions, _projectPath) {
+        // Initialize accumulators
+        const fileEdits = new Map();
+        const toolCalls = new Map();
+        const errorMessages = new Map();
+        const dailyActivity = new Map();
+        const hourlyActivity = new Map();
+        const weeklyActivity = new Map();
+        const languageUsage = new Map();
+        let totalTokens = 0;
+        let totalCost = 0;
+        let firstDate = '';
+        let lastDate = '';
+        let filesCreated = 0;
+        let filesEdited = 0;
+        let totalSuccess = 0;
+        let totalErrors = 0;
+        const now = new Date();
+        const oneWeekAgo = new Date(now.getTime() - 7 * 24 * 60 * 60 * 1000);
+        let sessionsThisWeek = 0;
+        let tokensThisWeek = 0;
+        let filesChangedThisWeek = 0;
+        // Process each session
+        for (const session of sessions) {
+            if (!session)
+                continue;
+            const sessionDate = session.startedAt || session.lastMessageAt;
+            if (!firstDate || sessionDate < firstDate)
+                firstDate = sessionDate;
+            if (!lastDate || sessionDate > lastDate)
+                lastDate = sessionDate;
+            const date = new Date(sessionDate);
+            const dateKey = date.toISOString().split('T')[0];
+            const hour = date.getHours();
+            const dayOfWeek = ['Sun', 'Mon', 'Tue', 'Wed', 'Thu', 'Fri', 'Sat'][date.getDay()];
+            // Track activity patterns
+            dailyActivity.set(dateKey, (dailyActivity.get(dateKey) || 0) + 1);
+            hourlyActivity.set(hour, (hourlyActivity.get(hour) || 0) + 1);
+            weeklyActivity.set(dayOfWeek, (weeklyActivity.get(dayOfWeek) || 0) + 1);
+            // Check if this week
+            if (date >= oneWeekAgo) {
+                sessionsThisWeek++;
+            }
+            // Process messages
+            for (const msg of session.messages || []) {
+                // Track tokens
+                if (msg.metadata?.tokens) {
+                    const tokens = (msg.metadata.tokens.input || 0) + (msg.metadata.tokens.output || 0);
+                    totalTokens += tokens;
+                    if (date >= oneWeekAgo)
+                        tokensThisWeek += tokens;
+                    // Estimate cost (rough estimate)
+                    totalCost += tokens * 0.00001;
+                }
+                // Track tool usage
+                if (msg.type === 'tool-use' && msg.metadata?.toolName) {
+                    const toolName = msg.metadata.toolName;
+                    const existing = toolCalls.get(toolName) || { total: 0, errors: 0 };
+                    existing.total++;
+                    toolCalls.set(toolName, existing);
+                    // Track file edits
+                    const input = msg.metadata.toolInput;
+                    const filePath = (input?.file_path || input?.path || input?.target_file);
+                    if (filePath && ['Edit', 'Write', 'MultiEdit'].includes(toolName)) {
+                        const existing = fileEdits.get(filePath) || {
+                            count: 0,
+                            lastEdited: sessionDate,
+                            sessions: new Set(),
+                        };
+                        existing.count++;
+                        existing.sessions.add(session.id);
+                        if (sessionDate > existing.lastEdited)
+                            existing.lastEdited = sessionDate;
+                        fileEdits.set(filePath, existing);
+                        if (toolName === 'Write')
+                            filesCreated++;
+                        else
+                            filesEdited++;
+                        if (date >= oneWeekAgo)
+                            filesChangedThisWeek++;
+                        // Track language
+                        const ext = path.extname(filePath).toLowerCase();
+                        if (ext) {
+                            languageUsage.set(ext, (languageUsage.get(ext) || 0) + 1);
+                        }
+                    }
+                }
+                // Track errors
+                if (msg.type === 'tool-result' && msg.content?.includes('Error')) {
+                    totalErrors++;
+                    const errorType = this.categorizeError(msg.content);
+                    const existing = errorMessages.get(errorType) || { count: 0, lastOccurred: sessionDate };
+                    existing.count++;
+                    if (sessionDate > existing.lastOccurred)
+                        existing.lastOccurred = sessionDate;
+                    errorMessages.set(errorType, existing);
+                    // Mark tool as having an error
+                    const prevMsg = session.messages[session.messages.indexOf(msg) - 1];
+                    if (prevMsg?.metadata?.toolName) {
+                        const toolData = toolCalls.get(prevMsg.metadata.toolName);
+                        if (toolData)
+                            toolData.errors++;
+                    }
+                }
+                else if (msg.type === 'tool-result') {
+                    totalSuccess++;
+                }
+            }
+        }
+        // Calculate health score
+        const errorRate = totalErrors / Math.max(1, totalSuccess + totalErrors);
+        const velocity = sessions.length / Math.max(1, this.daysBetween(firstDate, lastDate));
+        const churnScore = this.calculateChurnScore(fileEdits);
+        const health = {
+            overall: Math.round((1 - errorRate) * 30 + // Stability
+                Math.min(velocity * 10, 25) + // Velocity
+                (1 - Math.min(churnScore / 100, 1)) * 25 + // Maintainability
+                20 // Base score
+            ),
+            velocity: Math.min(velocity * 20, 100),
+            stability: Math.round((1 - errorRate) * 100),
+            maintainability: Math.round((1 - Math.min(churnScore / 100, 1)) * 100),
+            completion: Math.round((totalSuccess / Math.max(1, totalSuccess + totalErrors)) * 100),
+            trend: this.determineTrend(sessions),
+            trendChange: 0,
+        };
+        // Build hotspots
+        const hotspots = Array.from(fileEdits.entries())
+            .map(([filePath, data]) => ({
+            filePath,
+            fileName: path.basename(filePath),
+            editCount: data.count,
+            lastEdited: data.lastEdited,
+            churnScore: data.count * data.sessions.size,
+            sessions: data.sessions.size,
+            contributionType: 'unknown',
+        }))
+            .sort((a, b) => b.editCount - a.editCount)
+            .slice(0, 10);
+        // Build top tools
+        const topTools = Array.from(toolCalls.entries())
+            .map(([name, data]) => ({ name, count: data.total }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 10);
+        // Build languages
+        const languages = Array.from(languageUsage.entries())
+            .sort((a, b) => b[1] - a[1])
+            .slice(0, 5)
+            .map(([ext]) => this.extToLanguage(ext));
+        // Build error patterns
+        const errorPatterns = Array.from(errorMessages.entries())
+            .map(([type, data]) => ({ type, count: data.count, lastOccurred: data.lastOccurred }))
+            .sort((a, b) => b.count - a.count)
+            .slice(0, 5);
+        // Build activity pattern
+        const activityPattern = {
+            peakDays: Array.from(weeklyActivity.entries())
+                .map(([day, sessions]) => ({ day, sessions }))
+                .sort((a, b) => b.sessions - a.sessions),
+            peakHours: Array.from(hourlyActivity.entries())
+                .map(([hour, sessions]) => ({ hour, sessions }))
+                .sort((a, b) => b.sessions - a.sessions)
+                .slice(0, 5),
+            averageSessionsPerWeek: sessions.length / Math.max(1, this.daysBetween(firstDate, lastDate) / 7),
+            longestStreak: this.calculateStreak(dailyActivity),
+            lastActiveStreak: this.calculateCurrentStreak(dailyActivity),
+        };
+        // Build Claude effectiveness
+        const claudeEffectiveness = {
+            overallScore: health.completion,
+            strengths: this.identifyStrengths(toolCalls),
+            weaknesses: this.identifyWeaknesses(toolCalls),
+            bestToolUsage: Array.from(toolCalls.entries())
+                .filter(([_, d]) => d.errors === 0 && d.total > 3)
+                .map(([tool, d]) => ({ tool, successRate: 100 }))
+                .slice(0, 3),
+            worstToolUsage: Array.from(toolCalls.entries())
+                .filter(([_, d]) => d.errors > 0)
+                .map(([tool, d]) => ({ tool, errorRate: (d.errors / d.total) * 100 }))
+                .sort((a, b) => b.errorRate - a.errorRate)
+                .slice(0, 3),
+            averageTaskCompletion: health.completion,
+            iterationEfficiency: Math.round(100 - errorRate * 50),
+        };
+        // Build recent activity
+        const recentActivity = Array.from(dailyActivity.entries())
+            .sort((a, b) => b[0].localeCompare(a[0]))
+            .slice(0, 7)
+            .map(([date, count]) => ({
+            date,
+            summary: `${count} session${count > 1 ? 's' : ''}`,
+        }));
+        // Build basic recommendations
+        const basicRecommendations = [];
+        if (errorRate > 0.3) {
+            basicRecommendations.push({
+                id: 'reduce-errors',
+                type: 'process',
+                priority: 'high',
+                title: 'Reduce Error Rate',
+                description: 'Your sessions have a high error rate. Consider adding better validation.',
+                rationale: `Current error rate is ${(errorRate * 100).toFixed(0)}%`,
+                actionItems: ['Review common error patterns', 'Add pre-commit hooks'],
+                estimatedImpact: 'Reduce debugging time by 30%',
+            });
+        }
+        if (hotspots.length > 0 && hotspots[0].editCount > 20) {
+            basicRecommendations.push({
+                id: 'refactor-hotspot',
+                type: 'refactor',
+                priority: 'medium',
+                title: `Consider Refactoring ${hotspots[0].fileName}`,
+                description: 'This file has high churn and may benefit from refactoring.',
+                rationale: `Edited ${hotspots[0].editCount} times across ${hotspots[0].sessions} sessions`,
+                actionItems: ['Review file complexity', 'Consider splitting into smaller modules'],
+                estimatedImpact: 'Reduce maintenance overhead',
+            });
+        }
+        return {
+            health,
+            totalTokens,
+            totalCost,
+            dateRange: { first: firstDate, last: lastDate },
+            hotspots,
+            languages,
+            filesCreated,
+            filesEdited,
+            milestones: [], // Would need more sophisticated analysis
+            recentActivity,
+            recentTopics: languages,
+            workflowPatterns: [], // Would need more sophisticated analysis
+            activityPattern,
+            challenges: errorPatterns.map((e, i) => ({
+                id: `challenge-${i}`,
+                title: e.type,
+                description: `Encountered ${e.count} times`,
+                occurrences: e.count,
+                firstSeen: e.lastOccurred,
+                lastSeen: e.lastOccurred,
+                category: 'error',
+                relatedFiles: [],
+                resolved: false,
+            })),
+            errorPatterns,
+            claudeEffectiveness,
+            topTools,
+            basicRecommendations,
+            quickStats: {
+                sessionsThisWeek,
+                tokensThisWeek,
+                filesChangedThisWeek,
+                milestonesThisMonth: 0,
+            },
+        };
+    }
+    /**
+     * Generate AI-powered narrative for the project
+     */
+    async generateAINarrative(analysis, projectName) {
+        try {
+            const context = this.buildAIContext(analysis, projectName);
+            const prompt = `You are analyzing a software project's development history. Based on the data, provide a concise analysis.
+
+PROJECT: ${projectName}
+
+DATA:
+${context}
+
+Respond with ONLY a JSON object (no markdown):
+{
+  "story": "A 2-3 sentence narrative describing what this project is and its development journey",
+  "focus": "One sentence about the current focus or recent work",
+  "recommendations": [
+    {
+      "id": "rec-1",
+      "type": "skill|refactor|process|learning|automation",
+      "priority": "high|medium|low",
+      "title": "Short recommendation title",
+      "description": "What to do",
+      "rationale": "Why this matters",
+      "actionItems": ["Step 1", "Step 2"],
+      "estimatedImpact": "Expected benefit"
+    }
+  ]
+}
+
+Keep recommendations to 2-3 most impactful ones.`;
+            const tempFile = path.join(this.claudeDir.root, `intelligence-temp-${Date.now()}.txt`);
+            await fs.writeFile(tempFile, prompt, 'utf-8');
+            const { stdout } = await execAsync(`cat "${tempFile}" | claude --print`, {
+                timeout: 120000,
+                maxBuffer: 5 * 1024 * 1024,
+            });
+            await fs.unlink(tempFile).catch(() => { });
+            // Parse response
+            const jsonMatch = stdout.match(/\{[\s\S]*\}/);
+            if (!jsonMatch)
+                return null;
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                story: parsed.story || '',
+                focus: parsed.focus || '',
+                recommendations: parsed.recommendations || [],
+            };
+        }
+        catch (error) {
+            console.error('[ProjectIntelligence] AI narrative failed:', error);
+            return null;
+        }
+    }
+    /**
+     * Build context for AI analysis
+     */
+    buildAIContext(analysis, projectName) {
+        return `
+Sessions: ${analysis.health.velocity > 0 ? Math.round(1 / analysis.health.velocity) : 0} total
+Health Score: ${analysis.health.overall}/100
+Languages: ${analysis.languages.join(', ') || 'Unknown'}
+Top Files Changed: ${analysis.hotspots.slice(0, 3).map((h) => h.fileName).join(', ')}
+Error Rate: ${(100 - analysis.health.stability)}%
+Top Tools: ${analysis.topTools.slice(0, 3).map((t) => `${t.name}(${t.count})`).join(', ')}
+Recent Activity: ${analysis.recentActivity.slice(0, 3).map((a) => `${a.date}: ${a.summary}`).join('; ')}
+Peak Activity: ${analysis.activityPattern.peakDays[0]?.day || 'Unknown'} at ${analysis.activityPattern.peakHours[0]?.hour || 0}:00
+`;
+    }
+    /**
+     * Generate basic narrative without AI
+     */
+    generateBasicNarrative(analysis) {
+        const languages = analysis.languages.slice(0, 2).join(' and ') || 'various technologies';
+        const files = analysis.hotspots.slice(0, 2).map((h) => h.fileName).join(', ');
+        return `A project using ${languages}. Most activity focuses on ${files || 'core functionality'}. ` +
+            `Health score: ${analysis.health.overall}/100 with ${analysis.health.trend} trend.`;
+    }
+    /**
+     * Get global intelligence across all projects
+     */
+    async getGlobalIntelligence(force = false) {
+        const cachePath = path.join(this.claudeDir.root, INTELLIGENCE_CACHE_DIR, 'global.json');
+        // Check cache
+        if (!force) {
+            try {
+                const content = await fs.readFile(cachePath, 'utf-8');
+                const cached = JSON.parse(content);
+                const age = Date.now() - new Date(cached.generatedAt).getTime();
+                if (age < 24 * 60 * 60 * 1000 && cached.status === 'completed') {
+                    return cached;
+                }
+            }
+            catch {
+                // No cache
+            }
+        }
+        // Generate fresh
+        const summaries = await this.listProjectIntelligence();
+        const projects = await this.sessionService.listProjects();
+        const mostActiveProjects = summaries
+            .sort((a, b) => b.sessionCount - a.sessionCount)
+            .slice(0, 5)
+            .map(s => ({ path: s.projectPath, name: s.projectName, sessions: s.sessionCount }));
+        const healthiest = summaries.reduce((best, curr) => curr.health > (best?.health ?? 0) ? curr : best, summaries[0]);
+        const needsAttention = summaries.reduce((worst, curr) => curr.health < (worst?.health ?? 100) ? curr : worst, summaries[0]);
+        const global = {
+            generatedAt: new Date().toISOString(),
+            status: 'completed',
+            developerProfile: `Active across ${projects.length} projects with focus on ${summaries[0]?.projectName || 'development'}`,
+            overallNarrative: `Working on ${projects.length} projects. Most active: ${mostActiveProjects[0]?.name || 'N/A'}.`,
+            mostActiveProjects,
+            projectComparison: {
+                healthiest: healthiest?.projectName || 'N/A',
+                mostActive: mostActiveProjects[0]?.name || 'N/A',
+                needsAttention: needsAttention?.projectName || 'N/A',
+            },
+            workingPatterns: {
+                mostProductiveDay: 'Tuesday', // Would need actual calculation
+                mostProductiveHour: 14,
+                averageSessionDuration: 30,
+            },
+            recommendations: [],
+        };
+        await fs.mkdir(path.dirname(cachePath), { recursive: true });
+        await fs.writeFile(cachePath, JSON.stringify(global, null, 2));
+        return global;
+    }
+    // ============================================================================
+    // Helper Methods
+    // ============================================================================
+    async isClaudeAvailable() {
+        try {
+            await execAsync('which claude');
+            return true;
+        }
+        catch {
+            return false;
+        }
+    }
+    daysBetween(date1, date2) {
+        if (!date1 || !date2)
+            return 1;
+        const d1 = new Date(date1);
+        const d2 = new Date(date2);
+        return Math.max(1, Math.ceil((d2.getTime() - d1.getTime()) / (1000 * 60 * 60 * 24)));
+    }
+    calculateChurnScore(fileEdits) {
+        let score = 0;
+        for (const [_, data] of fileEdits) {
+            score += data.count * data.sessions.size;
+        }
+        return score / Math.max(1, fileEdits.size);
+    }
+    determineTrend(sessions) {
+        if (sessions.length < 5)
+            return 'stable';
+        // Simple trend based on recent activity
+        const sorted = sessions.sort((a, b) => new Date(b.startedAt || b.lastMessageAt).getTime() -
+            new Date(a.startedAt || a.lastMessageAt).getTime());
+        const recentCount = sorted.slice(0, 5).length;
+        const olderCount = sorted.slice(5, 10).length;
+        if (recentCount > olderCount * 1.2)
+            return 'improving';
+        if (recentCount < olderCount * 0.8)
+            return 'declining';
+        return 'stable';
+    }
+    calculateStreak(dailyActivity) {
+        const dates = Array.from(dailyActivity.keys()).sort();
+        let maxStreak = 0;
+        let currentStreak = 1;
+        for (let i = 1; i < dates.length; i++) {
+            const prev = new Date(dates[i - 1]);
+            const curr = new Date(dates[i]);
+            const diff = (curr.getTime() - prev.getTime()) / (1000 * 60 * 60 * 24);
+            if (diff === 1) {
+                currentStreak++;
+                maxStreak = Math.max(maxStreak, currentStreak);
+            }
+            else {
+                currentStreak = 1;
+            }
+        }
+        return maxStreak;
+    }
+    calculateCurrentStreak(dailyActivity) {
+        const dates = Array.from(dailyActivity.keys()).sort().reverse();
+        if (dates.length === 0)
+            return 0;
+        const today = new Date().toISOString().split('T')[0];
+        if (dates[0] !== today)
+            return 0;
+        let streak = 1;
+        for (let i = 1; i < dates.length; i++) {
+            const prev = new Date(dates[i - 1]);
+            const curr = new Date(dates[i]);
+            const diff = (prev.getTime() - curr.getTime()) / (1000 * 60 * 60 * 24);
+            if (diff === 1) {
+                streak++;
+            }
+            else {
+                break;
+            }
+        }
+        return streak;
+    }
+    categorizeError(content) {
+        if (content.includes('ENOENT') || content.includes('not found'))
+            return 'File Not Found';
+        if (content.includes('permission') || content.includes('EACCES'))
+            return 'Permission Error';
+        if (content.includes('syntax') || content.includes('parse'))
+            return 'Syntax Error';
+        if (content.includes('type') || content.includes('TypeScript'))
+            return 'Type Error';
+        if (content.includes('timeout'))
+            return 'Timeout';
+        if (content.includes('network') || content.includes('ECONNREFUSED'))
+            return 'Network Error';
+        return 'Other Error';
+    }
+    extToLanguage(ext) {
+        const map = {
+            '.ts': 'TypeScript',
+            '.tsx': 'TypeScript',
+            '.js': 'JavaScript',
+            '.jsx': 'JavaScript',
+            '.py': 'Python',
+            '.go': 'Go',
+            '.rs': 'Rust',
+            '.java': 'Java',
+            '.rb': 'Ruby',
+            '.swift': 'Swift',
+            '.kt': 'Kotlin',
+            '.css': 'CSS',
+            '.scss': 'Sass',
+            '.html': 'HTML',
+            '.vue': 'Vue',
+            '.svelte': 'Svelte',
+        };
+        return map[ext] || ext.replace('.', '').toUpperCase();
+    }
+    identifyStrengths(toolCalls) {
+        const strengths = [];
+        const totalCalls = Array.from(toolCalls.values()).reduce((sum, d) => sum + d.total, 0);
+        for (const [tool, data] of toolCalls) {
+            if (data.errors === 0 && data.total > totalCalls * 0.1) {
+                strengths.push(`Strong ${tool} usage`);
+            }
+        }
+        return strengths.slice(0, 3);
+    }
+    identifyWeaknesses(toolCalls) {
+        const weaknesses = [];
+        for (const [tool, data] of toolCalls) {
+            const errorRate = data.errors / data.total;
+            if (errorRate > 0.3 && data.total > 5) {
+                weaknesses.push(`High error rate with ${tool}`);
+            }
+        }
+        return weaknesses.slice(0, 3);
+    }
+}
+//# sourceMappingURL=project-intelligence.js.map