claudecto 0.1.0

package/dist/services/tech-stack.js

@@ -0,0 +1,1088 @@
+/**
+ * Tech Stack Service - Aggregates technology usage across all Claude Code sessions
+ *
+ * This service scans session files to detect:
+ * - Programming languages used (via file extensions)
+ * - Frameworks and libraries (via file patterns and imports)
+ * - Cloud providers and DevOps tools
+ * - Databases and infrastructure
+ *
+ * It tracks Claude's contributions by analyzing Edit/Write tool calls.
+ * Also provides AI-powered insights via Claude CLI.
+ */
+import path from 'node:path';
+import fs from 'node:fs/promises';
+import os from 'node:os';
+import { exec } from 'node:child_process';
+const EXTENSION_MAPPINGS = {
+    // Languages
+    '.ts': { name: 'TypeScript', type: 'language' },
+    '.tsx': { name: 'TypeScript', type: 'language' },
+    '.js': { name: 'JavaScript', type: 'language' },
+    '.jsx': { name: 'JavaScript', type: 'language' },
+    '.mjs': { name: 'JavaScript', type: 'language' },
+    '.cjs': { name: 'JavaScript', type: 'language' },
+    '.py': { name: 'Python', type: 'language' },
+    '.go': { name: 'Go', type: 'language' },
+    '.rs': { name: 'Rust', type: 'language' },
+    '.rb': { name: 'Ruby', type: 'language' },
+    '.java': { name: 'Java', type: 'language' },
+    '.kt': { name: 'Kotlin', type: 'language' },
+    '.swift': { name: 'Swift', type: 'language' },
+    '.c': { name: 'C', type: 'language' },
+    '.cpp': { name: 'C++', type: 'language' },
+    '.cc': { name: 'C++', type: 'language' },
+    '.h': { name: 'C/C++', type: 'language' },
+    '.hpp': { name: 'C++', type: 'language' },
+    '.cs': { name: 'C#', type: 'language' },
+    '.php': { name: 'PHP', type: 'language' },
+    '.scala': { name: 'Scala', type: 'language' },
+    '.clj': { name: 'Clojure', type: 'language' },
+    '.ex': { name: 'Elixir', type: 'language' },
+    '.exs': { name: 'Elixir', type: 'language' },
+    '.erl': { name: 'Erlang', type: 'language' },
+    '.hs': { name: 'Haskell', type: 'language' },
+    '.lua': { name: 'Lua', type: 'language' },
+    '.r': { name: 'R', type: 'language' },
+    '.dart': { name: 'Dart', type: 'language' },
+    '.vue': { name: 'Vue.js', type: 'framework' },
+    '.svelte': { name: 'Svelte', type: 'framework' },
+    // Config/Data
+    '.json': { name: 'JSON', type: 'tool' },
+    '.yaml': { name: 'YAML', type: 'tool' },
+    '.yml': { name: 'YAML', type: 'tool' },
+    '.toml': { name: 'TOML', type: 'tool' },
+    '.xml': { name: 'XML', type: 'tool' },
+    '.ini': { name: 'INI', type: 'tool' },
+    '.env': { name: 'Environment', type: 'tool' },
+    // Web
+    '.html': { name: 'HTML', type: 'language' },
+    '.htm': { name: 'HTML', type: 'language' },
+    '.css': { name: 'CSS', type: 'language' },
+    '.scss': { name: 'Sass', type: 'tool' },
+    '.sass': { name: 'Sass', type: 'tool' },
+    '.less': { name: 'Less', type: 'tool' },
+    // DevOps/Cloud
+    '.tf': { name: 'Terraform', type: 'devops' },
+    '.tfvars': { name: 'Terraform', type: 'devops' },
+    '.hcl': { name: 'HashiCorp', type: 'devops' },
+    // Documentation
+    '.md': { name: 'Markdown', type: 'tool' },
+    '.mdx': { name: 'MDX', type: 'tool' },
+    '.rst': { name: 'reStructuredText', type: 'tool' },
+    // Shell
+    '.sh': { name: 'Shell', type: 'tool' },
+    '.bash': { name: 'Bash', type: 'tool' },
+    '.zsh': { name: 'Zsh', type: 'tool' },
+    '.fish': { name: 'Fish', type: 'tool' },
+    '.ps1': { name: 'PowerShell', type: 'tool' },
+    // Database
+    '.sql': { name: 'SQL', type: 'database' },
+    '.prisma': { name: 'Prisma', type: 'database' },
+    // Testing
+    '.test.ts': { name: 'Jest', type: 'testing' },
+    '.spec.ts': { name: 'Jest', type: 'testing' },
+    '.test.js': { name: 'Jest', type: 'testing' },
+    '.spec.js': { name: 'Jest', type: 'testing' },
+};
+// File path pattern detection
+const PATH_PATTERNS = [
+    // Frameworks
+    { pattern: /next\.config\.(js|ts|mjs)$/, tech: { name: 'Next.js', type: 'framework' } },
+    { pattern: /vite\.config\.(js|ts|mjs)$/, tech: { name: 'Vite', type: 'tool' } },
+    { pattern: /webpack\.config\.(js|ts)$/, tech: { name: 'Webpack', type: 'tool' } },
+    { pattern: /tailwind\.config\.(js|ts)$/, tech: { name: 'Tailwind CSS', type: 'framework' } },
+    { pattern: /postcss\.config\.(js|ts)$/, tech: { name: 'PostCSS', type: 'tool' } },
+    { pattern: /tsconfig\.json$/, tech: { name: 'TypeScript', type: 'language' } },
+    { pattern: /package\.json$/, tech: { name: 'Node.js', type: 'tool' } },
+    { pattern: /cargo\.toml$/i, tech: { name: 'Rust', type: 'language' } },
+    { pattern: /go\.mod$/, tech: { name: 'Go', type: 'language' } },
+    { pattern: /requirements\.txt$/, tech: { name: 'Python', type: 'language' } },
+    { pattern: /pyproject\.toml$/, tech: { name: 'Python', type: 'language' } },
+    { pattern: /gemfile$/i, tech: { name: 'Ruby', type: 'language' } },
+    { pattern: /pom\.xml$/, tech: { name: 'Maven', type: 'tool' } },
+    { pattern: /build\.gradle(\.kts)?$/, tech: { name: 'Gradle', type: 'tool' } },
+    // DevOps
+    { pattern: /dockerfile$/i, tech: { name: 'Docker', type: 'devops' } },
+    { pattern: /docker-compose\.(yml|yaml)$/i, tech: { name: 'Docker Compose', type: 'devops' } },
+    { pattern: /\.github\/workflows\//, tech: { name: 'GitHub Actions', type: 'devops' } },
+    { pattern: /\.gitlab-ci\.yml$/, tech: { name: 'GitLab CI', type: 'devops' } },
+    { pattern: /jenkinsfile$/i, tech: { name: 'Jenkins', type: 'devops' } },
+    { pattern: /kubernetes|k8s/i, tech: { name: 'Kubernetes', type: 'devops' } },
+    { pattern: /helm/i, tech: { name: 'Helm', type: 'devops' } },
+    // Cloud
+    { pattern: /\.aws\//, tech: { name: 'AWS', type: 'cloud' } },
+    { pattern: /serverless\.(yml|yaml|json)$/i, tech: { name: 'Serverless', type: 'cloud' } },
+    { pattern: /cloudformation/i, tech: { name: 'AWS CloudFormation', type: 'cloud' } },
+    { pattern: /\.gcloud\//, tech: { name: 'Google Cloud', type: 'cloud' } },
+    { pattern: /firebase\.(json|rc)$/i, tech: { name: 'Firebase', type: 'cloud' } },
+    { pattern: /vercel\.json$/i, tech: { name: 'Vercel', type: 'cloud' } },
+    { pattern: /netlify\.toml$/i, tech: { name: 'Netlify', type: 'cloud' } },
+    // Testing
+    { pattern: /jest\.config\.(js|ts|json)$/, tech: { name: 'Jest', type: 'testing' } },
+    { pattern: /vitest\.config\.(js|ts)$/, tech: { name: 'Vitest', type: 'testing' } },
+    { pattern: /playwright\.config\.(js|ts)$/, tech: { name: 'Playwright', type: 'testing' } },
+    { pattern: /cypress\.config\.(js|ts)$/, tech: { name: 'Cypress', type: 'testing' } },
+    { pattern: /pytest\.ini$/, tech: { name: 'Pytest', type: 'testing' } },
+    // Databases
+    { pattern: /prisma\/schema\.prisma$/, tech: { name: 'Prisma', type: 'database' } },
+    { pattern: /drizzle\.config\.(js|ts)$/, tech: { name: 'Drizzle', type: 'database' } },
+    { pattern: /migrations\//, tech: { name: 'Database Migrations', type: 'database' } },
+];
+const CACHE_VERSION = 1;
+export class TechStackService {
+    claudeDir;
+    cacheFile;
+    cache = null;
+    constructor(claudeDir) {
+        this.claudeDir = claudeDir;
+        this.cacheFile = path.join(claudeDir.root, 'tech-stack-cache.json');
+    }
+    /**
+     * Get the global tech stack summary (uses cache if available)
+     */
+    async getSummary(forceRefresh = false) {
+        if (!forceRefresh && this.cache) {
+            return this.cache;
+        }
+        // Try loading from disk cache
+        if (!forceRefresh) {
+            const cached = await this.loadCache();
+            if (cached) {
+                this.cache = cached;
+                return cached;
+            }
+        }
+        // Generate fresh
+        return this.refresh();
+    }
+    /**
+     * Force refresh the tech stack data by scanning all sessions
+     */
+    async refresh() {
+        console.log('[TechStack] Starting full scan...');
+        const techMap = new Map();
+        const projectDirs = await this.claudeDir.listProjects();
+        let totalSessions = 0;
+        let totalFiles = 0;
+        for (const projectDir of projectDirs) {
+            const projectPath = this.claudeDir.projectDirToPath(projectDir);
+            const sessionFiles = await this.claudeDir.listSessionFiles(projectDir);
+            for (const sessionFile of sessionFiles) {
+                totalSessions++;
+                const messages = await this.parseSessionFile(sessionFile);
+                for (const msg of messages) {
+                    this.processMessage(msg, projectPath, techMap);
+                }
+            }
+        }
+        // Convert accumulator to entries
+        const technologies = [];
+        for (const [name, acc] of techMap) {
+            totalFiles += acc.files.size;
+            technologies.push({
+                name,
+                type: acc.type,
+                fileExtensions: Array.from(acc.extensions),
+                usageCount: acc.usageCount,
+                filesModified: acc.files.size,
+                projectsUsed: Array.from(acc.projects),
+                firstSeen: acc.firstSeen,
+                lastUsed: acc.lastUsed,
+                proficiency: this.calculateProficiency(acc),
+                claudeContributions: acc.claudeContributions,
+                patterns: [],
+            });
+        }
+        // Sort by usage
+        technologies.sort((a, b) => b.usageCount - a.usageCount);
+        // Extract top items by type
+        const languages = technologies.filter(t => t.type === 'language');
+        const frameworks = technologies.filter(t => t.type === 'framework');
+        const cloudProviders = technologies.filter(t => t.type === 'cloud');
+        const devOpsTools = technologies.filter(t => t.type === 'devops');
+        const databases = technologies.filter(t => t.type === 'database');
+        const summary = {
+            generatedAt: new Date().toISOString(),
+            version: CACHE_VERSION,
+            totalProjects: projectDirs.length,
+            totalSessions,
+            totalFiles,
+            technologies,
+            primaryLanguages: languages.slice(0, 3).map(t => t.name),
+            topFrameworks: frameworks.slice(0, 3).map(t => t.name),
+            cloudProviders: cloudProviders.map(t => t.name),
+            devOpsTools: devOpsTools.map(t => t.name),
+            databases: databases.map(t => t.name),
+            recommendations: this.generateRecommendations(technologies),
+            insights: {
+                mostActiveProject: this.findMostActiveProject(technologies),
+                mostUsedTech: technologies[0]?.name || 'None',
+                growthAreas: this.findGrowthAreas(technologies),
+                expertise: technologies.filter(t => t.proficiency === 'expert').map(t => t.name),
+            },
+        };
+        // Save cache
+        await this.saveCache(summary);
+        this.cache = summary;
+        console.log(`[TechStack] Scan complete. Found ${technologies.length} technologies across ${totalSessions} sessions.`);
+        return summary;
+    }
+    /**
+     * Get tech stack breakdown for a specific project
+     */
+    async getProjectBreakdown(projectPath) {
+        const projectDirs = await this.claudeDir.listProjects();
+        const projectDir = projectDirs.find(d => this.claudeDir.projectDirToPath(d) === projectPath);
+        if (!projectDir) {
+            return null;
+        }
+        const techMap = new Map();
+        const extensionCounts = new Map();
+        let totalEdits = 0;
+        let totalReads = 0;
+        let totalWrites = 0;
+        const sessionFiles = await this.claudeDir.listSessionFiles(projectDir);
+        for (const sessionFile of sessionFiles) {
+            const messages = await this.parseSessionFile(sessionFile);
+            for (const msg of messages) {
+                const result = this.processMessage(msg, projectPath, techMap);
+                if (result) {
+                    // Track extension counts
+                    const ext = path.extname(result.filePath).toLowerCase();
+                    if (ext) {
+                        extensionCounts.set(ext, (extensionCounts.get(ext) || 0) + 1);
+                    }
+                    // Track activity types
+                    if (result.toolName === 'Edit' || result.toolName === 'MultiEdit') {
+                        totalEdits++;
+                    }
+                    else if (result.toolName === 'Read' || result.toolName === 'View') {
+                        totalReads++;
+                    }
+                    else if (result.toolName === 'Write') {
+                        totalWrites++;
+                    }
+                }
+            }
+        }
+        // Convert to entries
+        const technologies = [];
+        for (const [name, acc] of techMap) {
+            technologies.push({
+                name,
+                type: acc.type,
+                fileExtensions: Array.from(acc.extensions),
+                usageCount: acc.usageCount,
+                filesModified: acc.files.size,
+                projectsUsed: [projectPath],
+                firstSeen: acc.firstSeen,
+                lastUsed: acc.lastUsed,
+                proficiency: this.calculateProficiency(acc),
+                claudeContributions: acc.claudeContributions,
+                patterns: [],
+            });
+        }
+        technologies.sort((a, b) => b.usageCount - a.usageCount);
+        // Calculate file breakdown percentages
+        const totalExtensionCount = Array.from(extensionCounts.values()).reduce((a, b) => a + b, 0);
+        const fileBreakdown = Array.from(extensionCounts.entries())
+            .map(([extension, count]) => ({
+            extension,
+            count,
+            percentage: totalExtensionCount > 0 ? (count / totalExtensionCount) * 100 : 0,
+        }))
+            .sort((a, b) => b.count - a.count);
+        return {
+            projectPath,
+            projectName: this.claudeDir.projectDirToName(projectDir),
+            generatedAt: new Date().toISOString(),
+            technologies,
+            fileBreakdown,
+            claudeActivity: {
+                totalEdits,
+                totalReads,
+                totalWrites,
+            },
+        };
+    }
+    /**
+     * Get deep insights including patterns, correlations, evolution, and similarity
+     */
+    async getDeepInsights(forceRefresh = false) {
+        // First get the base summary
+        const summary = await this.getSummary(forceRefresh);
+        // Build project -> technologies mapping for analysis
+        const projectTechMap = this.buildProjectTechMap(summary.technologies);
+        // Generate deep insights
+        const stackPatterns = this.detectStackPatterns(summary.technologies, projectTechMap);
+        const correlations = this.calculateCorrelations(summary.technologies, projectTechMap);
+        const evolution = this.analyzeEvolution(summary.technologies);
+        const projectSimilarity = this.computeProjectSimilarity(projectTechMap);
+        // Generate highlights
+        const highlights = this.generateHighlights(summary, stackPatterns, correlations, evolution);
+        return {
+            summary,
+            stackPatterns,
+            correlations,
+            evolution,
+            projectSimilarity,
+            highlights,
+        };
+    }
+    /**
+     * Generate AI-powered tech stack insight using Claude CLI
+     */
+    async generateAIInsight(force = false) {
+        const cacheFile = path.join(this.claudeDir.root, 'tech-stack-ai-insight.json');
+        // Check for cached insight
+        if (!force) {
+            try {
+                const cached = await fs.readFile(cacheFile, 'utf-8');
+                const insight = JSON.parse(cached);
+                // Cache valid for 24 hours
+                const age = Date.now() - new Date(insight.generatedAt).getTime();
+                if (age < 24 * 60 * 60 * 1000 && insight.status === 'completed') {
+                    return insight;
+                }
+            }
+            catch {
+                // No cache or invalid
+            }
+        }
+        // Create pending insight
+        const pendingInsight = {
+            id: `tech-ai-${Date.now()}`,
+            generatedAt: new Date().toISOString(),
+            status: 'generating',
+        };
+        await fs.writeFile(cacheFile, JSON.stringify(pendingInsight, null, 2));
+        try {
+            // Check if Claude is available
+            const claudeAvailable = await this.isClaudeCodeAvailable();
+            if (!claudeAvailable) {
+                const errorInsight = {
+                    ...pendingInsight,
+                    status: 'error',
+                    error: {
+                        code: 'CLAUDE_NOT_FOUND',
+                        message: 'Claude Code CLI is not installed',
+                        recoverable: false,
+                        suggestion: 'Install Claude Code: npm install -g @anthropic-ai/claude-code',
+                    },
+                };
+                await fs.writeFile(cacheFile, JSON.stringify(errorInsight, null, 2));
+                return errorInsight;
+            }
+            // Get the deep insights data
+            const deepInsights = await this.getDeepInsights();
+            // Build context for Claude
+            const context = this.buildAIContext(deepInsights);
+            // Call Claude
+            console.log('[TechStack] Calling Claude for AI insight...');
+            const response = await this.callClaudeCode(context);
+            // Parse response
+            const parsed = this.parseAIResponse(response);
+            const completedInsight = {
+                id: pendingInsight.id,
+                generatedAt: pendingInsight.generatedAt,
+                status: 'completed',
+                ...parsed,
+            };
+            await fs.writeFile(cacheFile, JSON.stringify(completedInsight, null, 2));
+            console.log('[TechStack] AI insight generated successfully');
+            return completedInsight;
+        }
+        catch (error) {
+            const errorInsight = {
+                ...pendingInsight,
+                status: 'error',
+                error: {
+                    code: 'UNKNOWN',
+                    message: error.message,
+                    recoverable: true,
+                    suggestion: 'Try generating the insight again',
+                },
+            };
+            await fs.writeFile(cacheFile, JSON.stringify(errorInsight, null, 2));
+            return errorInsight;
+        }
+    }
+    /**
+     * Get cached AI insight without regenerating
+     */
+    async getAIInsight() {
+        const cacheFile = path.join(this.claudeDir.root, 'tech-stack-ai-insight.json');
+        try {
+            const cached = await fs.readFile(cacheFile, 'utf-8');
+            return JSON.parse(cached);
+        }
+        catch {
+            return null;
+        }
+    }
+    /**
+     * Check if Claude Code CLI is available
+     */
+    async isClaudeCodeAvailable() {
+        return new Promise((resolve) => {
+            exec('which claude', (error) => {
+                resolve(!error);
+            });
+        });
+    }
+    /**
+     * Build context string for Claude AI analysis
+     */
+    buildAIContext(insights) {
+        const { summary, stackPatterns, correlations, evolution, projectSimilarity, highlights } = insights;
+        let context = `# Tech Stack Analysis Request
+
+## Overview
+- Total Technologies: ${summary.technologies.length}
+- Total Projects: ${summary.totalProjects}
+- Total Sessions: ${summary.totalSessions}
+- Files Touched: ${summary.totalFiles}
+
+## Primary Languages
+${summary.primaryLanguages.join(', ') || 'None detected'}
+
+## Top Frameworks
+${summary.topFrameworks.join(', ') || 'None detected'}
+
+## All Technologies (by usage)
+${summary.technologies.slice(0, 20).map(t => `- ${t.name} (${t.type}): ${t.usageCount} uses, ${t.filesModified} files, proficiency: ${t.proficiency}`).join('\n')}
+
+## Detected Stack Patterns
+${stackPatterns.map(p => `- ${p.name}: ${p.technologies.join(', ')} (${p.projectCount} projects)`).join('\n') || 'No patterns detected'}
+
+## Technology Correlations (tech pairs that appear together)
+${correlations.slice(0, 10).map(c => `- ${c.tech1} + ${c.tech2}: ${c.correlation}% correlation (${c.strength})`).join('\n') || 'Insufficient data'}
+
+## Usage Trends
+${evolution.slice(0, 10).map(e => `- ${e.tech}: ${e.trend} (${e.changePercent > 0 ? '+' : ''}${e.changePercent}%)`).join('\n') || 'No trends detected'}
+
+## Similar Projects
+${projectSimilarity.slice(0, 5).map(s => `- ${s.project1Name} ↔ ${s.project2Name}: ${s.similarity}% similar (${s.sharedTechnologies.join(', ')})`).join('\n') || 'No similar projects found'}
+
+## Current Highlights
+- Shared Foundations: ${highlights.sharedFoundations}
+- Dominant Pattern: ${highlights.dominantPattern}
+- Rising Tech: ${highlights.risingTech}
+- Tech Diversity Score: ${highlights.techDiversity}%
+`;
+        return context;
+    }
+    /**
+     * Call Claude Code CLI with context
+     */
+    async callClaudeCode(context) {
+        const prompt = `You are an expert developer coach and technology advisor. Analyze this developer's tech stack data and provide personalized 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:
+{
+  "overview": "A 2-3 sentence narrative overview of this developer's tech profile",
+  "developerProfile": "A single sentence describing what type of developer they are (e.g., 'Full-stack TypeScript specialist with strong React ecosystem expertise')",
+  "stackHealth": 75,
+  
+  "stackPatterns": [
+    {
+      "id": "unique-pattern-id",
+      "name": "Pattern Name (e.g., 'Modern Full-Stack TypeScript')",
+      "description": "Brief description of what this pattern represents",
+      "technologies": ["Tech1", "Tech2", "Tech3"],
+      "icon": "layers|code|database|cloud|cpu|globe"
+    }
+  ],
+  
+  "strengths": [
+    {
+      "title": "Strong in X",
+      "description": "Explanation of why this is a strength",
+      "technologies": ["Tech1", "Tech2"]
+    }
+  ],
+  
+  "blindSpots": [
+    {
+      "title": "Area to improve",
+      "description": "Why this matters",
+      "suggestion": "Concrete action to take"
+    }
+  ],
+  
+  "learningPath": [
+    {
+      "skill": "Technology or skill to learn",
+      "reason": "Why this would benefit them",
+      "priority": "high|medium|low"
+    }
+  ],
+  
+  "technicalDebt": [
+    {
+      "issue": "Potential issue",
+      "impact": "How it affects them",
+      "fix": "How to address it"
+    }
+  ],
+  
+  "architectureInsights": [
+    {
+      "title": "Pattern observed",
+      "observation": "What you noticed",
+      "recommendation": "Suggestion if applicable"
+    }
+  ],
+  
+  "quickHighlights": [
+    {
+      "title": "Short highlight",
+      "description": "Brief explanation",
+      "type": "positive|warning|info|suggestion"
+    }
+  ]
+}
+
+CRITICAL INSTRUCTIONS:
+1. For stackPatterns: Identify 2-4 meaningful technology patterns/archetypes from their ACTUAL technologies. Examples:
+   - "Modern React Ecosystem" if you see React + TypeScript + Vite/Next.js
+   - "Python Data Science" if you see Python + pandas + numpy
+   - "Cloud-Native DevOps" if you see Docker + Kubernetes + AWS/GCP
+   - Create patterns that reflect their REAL usage, not generic templates
+   - Each pattern should group 3-6 related technologies
+   
+2. Base stackHealth score on:
+   - Technology diversity (more types = better)
+   - Modern technologies (up-to-date = better)  
+   - Testing presence (having testing = better)
+   - DevOps/CI presence (automation = better)
+
+3. Provide 2-4 items for each array. Be specific and actionable. Reference their actual technologies.
+
+Here is their tech stack data:
+
+${context}`;
+        const tempFile = path.join(os.tmpdir(), `tech-stack-ai-${Date.now()}.txt`);
+        await fs.writeFile(tempFile, prompt, 'utf-8');
+        const timeout = 180000; // 3 minutes
+        return new Promise((resolve, reject) => {
+            const command = `cat "${tempFile}" | claude --print`;
+            const timer = setTimeout(() => {
+                reject(new Error('Claude Code execution timed out after 3 minutes'));
+            }, timeout + 5000);
+            exec(command, {
+                cwd: process.cwd(),
+                env: { ...process.env, NO_COLOR: '1', FORCE_COLOR: '0' },
+                maxBuffer: 10 * 1024 * 1024,
+                timeout: timeout,
+            }, (error, stdout, stderr) => {
+                clearTimeout(timer);
+                fs.unlink(tempFile).catch(() => { });
+                if (stderr) {
+                    console.log(`[TechStack] stderr: ${stderr.slice(0, 200)}`);
+                }
+                if (error) {
+                    console.log(`[TechStack] Error: ${error.message}`);
+                    reject(new Error(`Failed to run claude: ${error.message}`));
+                    return;
+                }
+                console.log(`[TechStack] Response received, length: ${stdout.length} chars`);
+                resolve(stdout);
+            });
+        });
+    }
+    /**
+     * Parse Claude's JSON response into TechStackAIInsight fields
+     */
+    parseAIResponse(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) {
+            console.log('[TechStack] No JSON found in response, using fallback');
+            return this.generateFallbackAIInsight();
+        }
+        try {
+            const parsed = JSON.parse(jsonMatch[0]);
+            return {
+                overview: parsed.overview || '',
+                developerProfile: parsed.developerProfile || '',
+                stackHealth: typeof parsed.stackHealth === 'number' ? parsed.stackHealth : 50,
+                stackPatterns: Array.isArray(parsed.stackPatterns) ? parsed.stackPatterns : [],
+                strengths: Array.isArray(parsed.strengths) ? parsed.strengths : [],
+                blindSpots: Array.isArray(parsed.blindSpots) ? parsed.blindSpots : [],
+                learningPath: Array.isArray(parsed.learningPath) ? parsed.learningPath : [],
+                technicalDebt: Array.isArray(parsed.technicalDebt) ? parsed.technicalDebt : [],
+                architectureInsights: Array.isArray(parsed.architectureInsights) ? parsed.architectureInsights : [],
+                quickHighlights: Array.isArray(parsed.quickHighlights) ? parsed.quickHighlights : [],
+            };
+        }
+        catch (e) {
+            console.log('[TechStack] Failed to parse JSON:', e);
+            return this.generateFallbackAIInsight();
+        }
+    }
+    /**
+     * Generate fallback insight when AI fails
+     */
+    generateFallbackAIInsight() {
+        return {
+            overview: 'Unable to generate AI insight. The analysis is based on detected technologies.',
+            developerProfile: 'Developer profile unavailable',
+            stackHealth: 50,
+            strengths: [],
+            blindSpots: [],
+            learningPath: [],
+            technicalDebt: [],
+            architectureInsights: [],
+            quickHighlights: [
+                {
+                    title: 'AI Analysis Unavailable',
+                    description: 'Try regenerating the insight',
+                    type: 'info',
+                },
+            ],
+        };
+    }
+    /**
+     * Build a map of project -> technologies for cross-project analysis
+     */
+    buildProjectTechMap(technologies) {
+        const projectTechMap = new Map();
+        for (const tech of technologies) {
+            for (const project of tech.projectsUsed) {
+                if (!projectTechMap.has(project)) {
+                    projectTechMap.set(project, new Set());
+                }
+                projectTechMap.get(project).add(tech.name);
+            }
+        }
+        return projectTechMap;
+    }
+    /**
+     * Detect common stack patterns across projects
+     */
+    detectStackPatterns(technologies, projectTechMap) {
+        const patterns = [];
+        // Define known stack archetypes to look for
+        const archetypes = [
+            {
+                id: 'fullstack-ts',
+                name: 'Full-stack TypeScript',
+                required: ['TypeScript', 'React'],
+                optional: ['Next.js', 'Tailwind CSS', 'Node.js', 'Prisma'],
+                description: 'Modern TypeScript-first web development stack',
+                icon: 'layers',
+            },
+            {
+                id: 'python-ml',
+                name: 'Python ML/Data',
+                required: ['Python'],
+                optional: ['FastAPI', 'Jupyter', 'Pandas', 'TensorFlow', 'PyTorch'],
+                description: 'Python-based machine learning and data science',
+                icon: 'brain',
+            },
+            {
+                id: 'go-backend',
+                name: 'Go Backend',
+                required: ['Go'],
+                optional: ['Docker', 'PostgreSQL', 'Redis', 'gRPC'],
+                description: 'High-performance Go backend services',
+                icon: 'server',
+            },
+            {
+                id: 'mobile-rn',
+                name: 'React Native Mobile',
+                required: ['TypeScript', 'React'],
+                optional: ['Expo', 'React Native'],
+                description: 'Cross-platform mobile development',
+                icon: 'smartphone',
+            },
+            {
+                id: 'devops',
+                name: 'DevOps/Platform',
+                required: ['Docker'],
+                optional: ['Kubernetes', 'Terraform', 'GitHub Actions', 'AWS'],
+                description: 'Infrastructure and deployment automation',
+                icon: 'cloud',
+            },
+        ];
+        const techNames = new Set(technologies.map(t => t.name));
+        for (const archetype of archetypes) {
+            // Check if all required technologies are present
+            const hasRequired = archetype.required.every(r => techNames.has(r));
+            if (!hasRequired)
+                continue;
+            // Find projects using this pattern
+            const matchingProjects = [];
+            for (const [project, projectTechs] of projectTechMap) {
+                const hasAllRequired = archetype.required.every(r => projectTechs.has(r));
+                if (hasAllRequired) {
+                    matchingProjects.push(project);
+                }
+            }
+            if (matchingProjects.length > 0) {
+                // Build list of matched technologies
+                const matchedTechs = [
+                    ...archetype.required,
+                    ...archetype.optional.filter(o => techNames.has(o)),
+                ];
+                patterns.push({
+                    id: archetype.id,
+                    name: archetype.name,
+                    description: archetype.description,
+                    technologies: matchedTechs,
+                    projectCount: matchingProjects.length,
+                    projects: matchingProjects,
+                    icon: archetype.icon,
+                });
+            }
+        }
+        // Sort by project count
+        patterns.sort((a, b) => b.projectCount - a.projectCount);
+        return patterns;
+    }
+    /**
+     * Calculate technology co-occurrence correlations
+     */
+    calculateCorrelations(technologies, projectTechMap) {
+        const correlations = [];
+        const significantTechs = technologies.filter(t => t.type !== 'tool' && t.usageCount >= 5).slice(0, 20); // Top 20 non-tool technologies
+        for (let i = 0; i < significantTechs.length; i++) {
+            for (let j = i + 1; j < significantTechs.length; j++) {
+                const tech1 = significantTechs[i];
+                const tech2 = significantTechs[j];
+                // Count projects with both technologies
+                let sharedProjects = 0;
+                let tech1Projects = 0;
+                let tech2Projects = 0;
+                for (const [, projectTechs] of projectTechMap) {
+                    const hasTech1 = projectTechs.has(tech1.name);
+                    const hasTech2 = projectTechs.has(tech2.name);
+                    if (hasTech1)
+                        tech1Projects++;
+                    if (hasTech2)
+                        tech2Projects++;
+                    if (hasTech1 && hasTech2)
+                        sharedProjects++;
+                }
+                // Calculate Jaccard-like correlation
+                const unionProjects = tech1Projects + tech2Projects - sharedProjects;
+                const correlation = unionProjects > 0
+                    ? Math.round((sharedProjects / unionProjects) * 100)
+                    : 0;
+                if (sharedProjects >= 2 && correlation >= 30) {
+                    correlations.push({
+                        tech1: tech1.name,
+                        tech2: tech2.name,
+                        correlation,
+                        projectsShared: sharedProjects,
+                        strength: correlation >= 70 ? 'strong' : correlation >= 50 ? 'moderate' : 'weak',
+                    });
+                }
+            }
+        }
+        // Sort by correlation strength
+        correlations.sort((a, b) => b.correlation - a.correlation);
+        return correlations.slice(0, 15); // Top 15 correlations
+    }
+    /**
+     * Analyze technology evolution trends
+     */
+    analyzeEvolution(technologies) {
+        const evolution = [];
+        const now = new Date();
+        const thirtyDaysAgo = new Date(now.getTime() - 30 * 24 * 60 * 60 * 1000);
+        const sixtyDaysAgo = new Date(now.getTime() - 60 * 24 * 60 * 60 * 1000);
+        for (const tech of technologies.slice(0, 20)) {
+            const firstSeenDate = new Date(tech.firstSeen);
+            const lastUsedDate = new Date(tech.lastUsed);
+            // Estimate recent vs older usage (simplified heuristic)
+            const daysSinceLastUse = Math.max(0, (now.getTime() - lastUsedDate.getTime()) / (24 * 60 * 60 * 1000));
+            const totalDays = Math.max(1, (lastUsedDate.getTime() - firstSeenDate.getTime()) / (24 * 60 * 60 * 1000));
+            // Calculate trend based on recency
+            let trend;
+            let changePercent;
+            if (daysSinceLastUse <= 7) {
+                // Used recently - likely rising or stable
+                const usageRate = tech.usageCount / Math.max(1, totalDays);
+                if (usageRate > 2) {
+                    trend = 'rising';
+                    changePercent = Math.min(50, Math.round(usageRate * 10));
+                }
+                else {
+                    trend = 'stable';
+                    changePercent = 0;
+                }
+            }
+            else if (daysSinceLastUse <= 30) {
+                trend = 'stable';
+                changePercent = 0;
+            }
+            else {
+                trend = 'declining';
+                changePercent = -Math.min(30, Math.round(daysSinceLastUse / 2));
+            }
+            evolution.push({
+                tech: tech.name,
+                trend,
+                changePercent,
+                recentUsage: daysSinceLastUse <= 30 ? tech.usageCount : Math.round(tech.usageCount * 0.3),
+                totalUsage: tech.usageCount,
+                firstSeen: tech.firstSeen,
+                monthlyTrend: [], // Would need more granular data
+            });
+        }
+        // Sort: rising first, then stable, then declining
+        const trendOrder = { rising: 0, stable: 1, declining: 2 };
+        evolution.sort((a, b) => trendOrder[a.trend] - trendOrder[b.trend]);
+        return evolution;
+    }
+    /**
+     * Compute project similarity based on shared technologies
+     */
+    computeProjectSimilarity(projectTechMap) {
+        const similarities = [];
+        const projects = Array.from(projectTechMap.keys());
+        for (let i = 0; i < projects.length; i++) {
+            for (let j = i + 1; j < projects.length; j++) {
+                const project1 = projects[i];
+                const project2 = projects[j];
+                const techs1 = projectTechMap.get(project1);
+                const techs2 = projectTechMap.get(project2);
+                // Calculate Jaccard similarity
+                const intersection = new Set([...techs1].filter(t => techs2.has(t)));
+                const union = new Set([...techs1, ...techs2]);
+                const similarity = Math.round((intersection.size / union.size) * 100);
+                if (similarity >= 40 && intersection.size >= 3) {
+                    similarities.push({
+                        project1,
+                        project2,
+                        project1Name: path.basename(project1),
+                        project2Name: path.basename(project2),
+                        similarity,
+                        sharedTechnologies: Array.from(intersection),
+                    });
+                }
+            }
+        }
+        // Sort by similarity descending
+        similarities.sort((a, b) => b.similarity - a.similarity);
+        return similarities.slice(0, 10); // Top 10 similar project pairs
+    }
+    /**
+     * Generate human-readable highlights from insights
+     */
+    generateHighlights(summary, patterns, correlations, evolution) {
+        // Shared foundations
+        const topPattern = patterns[0];
+        const sharedFoundations = topPattern
+            ? `${topPattern.projectCount} projects share ${topPattern.technologies.slice(0, 3).join(' + ')}`
+            : 'No common patterns detected yet';
+        // Dominant pattern
+        const dominantPattern = topPattern
+            ? `${topPattern.name} is your go-to stack`
+            : 'No dominant stack pattern';
+        // Rising tech
+        const risingTechs = evolution.filter(e => e.trend === 'rising');
+        const risingTech = risingTechs.length > 0
+            ? `${risingTechs[0].tech} usage trending up`
+            : 'No significant trends';
+        // Tech diversity score
+        const typeSet = new Set(summary.technologies.map(t => t.type));
+        const techDiversity = Math.round((typeSet.size / 8) * 100); // 8 possible types
+        return {
+            sharedFoundations,
+            dominantPattern,
+            risingTech,
+            techDiversity,
+        };
+    }
+    // ============================================================================
+    // Private Methods
+    // ============================================================================
+    async parseSessionFile(filePath) {
+        const messages = [];
+        try {
+            const fs = await import('node:fs/promises');
+            const content = await fs.readFile(filePath, 'utf-8');
+            const lines = content.split('\n').filter(l => l.trim());
+            for (const line of lines) {
+                try {
+                    const parsed = JSON.parse(line);
+                    messages.push(parsed);
+                }
+                catch {
+                    // Skip malformed lines
+                }
+            }
+        }
+        catch {
+            // File read error
+        }
+        return messages;
+    }
+    processMessage(msg, projectPath, techMap) {
+        if (msg.type !== 'assistant')
+            return null;
+        const content = msg.message?.content;
+        if (!Array.isArray(content))
+            return null;
+        for (const block of content) {
+            if (block.type !== 'tool_use')
+                continue;
+            const toolName = block.name;
+            const input = block.input;
+            if (!input)
+                continue;
+            // Extract file path from various tool inputs
+            const filePath = (input.file_path ||
+                input.path ||
+                input.target_file ||
+                input.file);
+            if (!filePath || typeof filePath !== 'string')
+                continue;
+            const timestamp = msg.timestamp;
+            const isModification = ['Edit', 'Write', 'MultiEdit', 'CreateFile'].includes(toolName || '');
+            // Detect technology from file path
+            const techs = this.detectTechnology(filePath);
+            for (const tech of techs) {
+                let acc = techMap.get(tech.name);
+                if (!acc) {
+                    acc = {
+                        name: tech.name,
+                        type: tech.type,
+                        extensions: new Set(),
+                        files: new Set(),
+                        projects: new Set(),
+                        usageCount: 0,
+                        claudeContributions: 0,
+                        firstSeen: timestamp,
+                        lastUsed: timestamp,
+                    };
+                    techMap.set(tech.name, acc);
+                }
+                const ext = path.extname(filePath).toLowerCase();
+                if (ext)
+                    acc.extensions.add(ext);
+                acc.files.add(filePath);
+                acc.projects.add(projectPath);
+                acc.usageCount++;
+                if (isModification)
+                    acc.claudeContributions++;
+                if (timestamp < acc.firstSeen)
+                    acc.firstSeen = timestamp;
+                if (timestamp > acc.lastUsed)
+                    acc.lastUsed = timestamp;
+            }
+            return { filePath, toolName: toolName || '' };
+        }
+        return null;
+    }
+    detectTechnology(filePath) {
+        const results = [];
+        const seen = new Set();
+        // Check extension mappings
+        const ext = path.extname(filePath).toLowerCase();
+        if (ext && EXTENSION_MAPPINGS[ext]) {
+            const tech = EXTENSION_MAPPINGS[ext];
+            if (!seen.has(tech.name)) {
+                results.push(tech);
+                seen.add(tech.name);
+            }
+        }
+        // Check path patterns
+        for (const { pattern, tech } of PATH_PATTERNS) {
+            if (pattern.test(filePath) && !seen.has(tech.name)) {
+                results.push(tech);
+                seen.add(tech.name);
+            }
+        }
+        return results;
+    }
+    calculateProficiency(acc) {
+        const score = acc.usageCount + (acc.claudeContributions * 2) + (acc.projects.size * 5);
+        if (score >= 100)
+            return 'expert';
+        if (score >= 50)
+            return 'proficient';
+        if (score >= 20)
+            return 'familiar';
+        return 'learning';
+    }
+    generateRecommendations(technologies) {
+        const recommendations = [];
+        // Check for missing testing frameworks
+        const hasTests = technologies.some(t => t.type === 'testing');
+        if (!hasTests && technologies.length > 5) {
+            recommendations.push('Consider adding automated tests to your projects');
+        }
+        // Check for TypeScript adoption
+        const hasJS = technologies.some(t => t.name === 'JavaScript');
+        const hasTS = technologies.some(t => t.name === 'TypeScript');
+        if (hasJS && !hasTS) {
+            recommendations.push('Consider migrating to TypeScript for better type safety');
+        }
+        // Check for DevOps
+        const hasDevOps = technologies.some(t => t.type === 'devops');
+        if (!hasDevOps && technologies.length > 10) {
+            recommendations.push('Consider adding CI/CD pipelines for automated deployments');
+        }
+        return recommendations;
+    }
+    findMostActiveProject(technologies) {
+        const projectCounts = new Map();
+        for (const tech of technologies) {
+            for (const project of tech.projectsUsed) {
+                projectCounts.set(project, (projectCounts.get(project) || 0) + tech.usageCount);
+            }
+        }
+        let maxProject = '';
+        let maxCount = 0;
+        for (const [project, count] of projectCounts) {
+            if (count > maxCount) {
+                maxProject = project;
+                maxCount = count;
+            }
+        }
+        return path.basename(maxProject) || 'Unknown';
+    }
+    findGrowthAreas(technologies) {
+        return technologies
+            .filter(t => t.proficiency === 'learning' || t.proficiency === 'familiar')
+            .slice(0, 3)
+            .map(t => t.name);
+    }
+    async loadCache() {
+        try {
+            const fs = await import('node:fs/promises');
+            const content = await fs.readFile(this.cacheFile, 'utf-8');
+            const cached = JSON.parse(content);
+            // Check if cache is still valid (less than 24 hours old)
+            const cacheAge = Date.now() - new Date(cached.generatedAt).getTime();
+            const maxAge = 24 * 60 * 60 * 1000; // 24 hours
+            if (cacheAge < maxAge && cached.version === CACHE_VERSION) {
+                return cached;
+            }
+        }
+        catch {
+            // No cache or invalid
+        }
+        return null;
+    }
+    async saveCache(summary) {
+        try {
+            const fs = await import('node:fs/promises');
+            await fs.writeFile(this.cacheFile, JSON.stringify(summary, null, 2));
+        }
+        catch (error) {
+            console.error('[TechStack] Failed to save cache:', error);
+        }
+    }
+}
+//# sourceMappingURL=tech-stack.js.map