@oalacea/daemon 0.6.3 → 0.7.0

package/dist/services/optimization/index.js

@@ -0,0 +1,69 @@
+/**
+ * Optimization Service Barrel Export
+ *
+ * Central export point for all optimization-related services and types.
+ */
+import { OptimizationService } from './optimization.service.js';
+// Main service
+export { OptimizationService } from './optimization.service.js';
+// Detectors
+export { BugDetector } from './detectors/bug-detector.js';
+export { PerfDetector } from './detectors/perf-detector.js';
+export { CodeSmellDetector } from './detectors/code-smell-detector.js';
+// Optimizers
+export { CodeOptimizer } from './optimizers/code-optimizer.js';
+export { PerfOptimizer } from './optimizers/perf-optimizer.js';
+export { RefactOptimizer } from './optimizers/refact-optimizer.js';
+// Patterns
+export { ANTI_PATTERNS, getAntiPatternsByCategory, getAntiPatternById, getAntiPatternsBySeverity, findMatchingAntiPatterns, } from './patterns/anti-patterns.js';
+/**
+ * Default optimization service instance
+ */
+export const optimizationService = new OptimizationService();
+/**
+ * Convenience function to detect issues in a project
+ *
+ * @example
+ * ```ts
+ * import { detectOptimizations } from '@pamacea/daemon';
+ *
+ * const report = await detectOptimizations('/path/to/project');
+ * console.log(`Found ${report.bugs.length} bugs`);
+ * ```
+ */
+export async function detectOptimizations(projectPath, options) {
+    return optimizationService.detect(projectPath, options);
+}
+/**
+ * Convenience function to detect and optimize in one operation
+ *
+ * @example
+ * ```ts
+ * import { detectAndOptimize } from '@pamacea/daemon';
+ *
+ * const result = await detectAndOptimize('/path/to/project', {
+ *   autoFix: true,
+ *   maxFixes: 10,
+ * });
+ * console.log(`Applied ${result.appliedOptimizations.length} optimizations`);
+ * ```
+ */
+export async function detectAndOptimize(projectPath, options) {
+    return optimizationService.detectAndOptimize(projectPath, options);
+}
+/**
+ * Convenience function to generate a summary report
+ *
+ * @example
+ * ```ts
+ * import { generateReport } from '@pamacea/daemon';
+ *
+ * const report = await detectOptimizations('/path/to/project');
+ * const summary = generateReport(report);
+ * console.log(summary);
+ * ```
+ */
+export function generateReport(report) {
+    return optimizationService.generateSummary(report);
+}
+//# sourceMappingURL=index.js.map

package/dist/services/optimization/index.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.js","sourceRoot":"","sources":["../../../src/services/optimization/index.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAEH,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAOhE,eAAe;AACf,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAC;AAEhE,YAAY;AACZ,OAAO,EAAE,WAAW,EAAE,MAAM,6BAA6B,CAAC;AAC1D,OAAO,EAAE,YAAY,EAAE,MAAM,8BAA8B,CAAC;AAC5D,OAAO,EAAE,iBAAiB,EAAE,MAAM,oCAAoC,CAAC;AAEvE,aAAa;AACb,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,aAAa,EAAE,MAAM,gCAAgC,CAAC;AAC/D,OAAO,EAAE,eAAe,EAAE,MAAM,kCAAkC,CAAC;AAEnE,WAAW;AACX,OAAO,EACL,aAAa,EACb,yBAAyB,EACzB,kBAAkB,EAClB,yBAAyB,EACzB,wBAAwB,GACzB,MAAM,6BAA6B,CAAC;AA2CrC;;GAEG;AACH,MAAM,CAAC,MAAM,mBAAmB,GAAG,IAAI,mBAAmB,EAAE,CAAC;AAE7D;;;;;;;;;;GAUG;AACH,MAAM,CAAC,KAAK,UAAU,mBAAmB,CACvC,WAAmB,EACnB,OAA0B;IAE1B,OAAO,mBAAmB,CAAC,MAAM,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AAC1D,CAAC;AAED;;;;;;;;;;;;;GAaG;AACH,MAAM,CAAC,KAAK,UAAU,iBAAiB,CACrC,WAAmB,EACnB,OAAkC;IAElC,OAAO,mBAAmB,CAAC,iBAAiB,CAAC,WAAW,EAAE,OAAO,CAAC,CAAC;AACrE,CAAC;AAED;;;;;;;;;;;GAWG;AACH,MAAM,UAAU,cAAc,CAAC,MAA0B;IACvD,OAAO,mBAAmB,CAAC,eAAe,CAAC,MAAM,CAAC,CAAC;AACrD,CAAC"}

package/dist/services/optimization/optimization.service.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Optimization Service
+ *
+ * Main orchestration service for bug detection, performance analysis,
+ * and code optimization. Coordinates all detectors and optimizers.
+ */
+import type { AppliedOptimization, DetectAndOptimizeOptions, DetectionOptions, OptimizationReport, OptimizationResult } from './optimization.types.js';
+/**
+ * Optimization Service - Main orchestration
+ */
+export declare class OptimizationService {
+    private readonly logger;
+    private readonly bugDetector;
+    private readonly perfDetector;
+    private readonly codeSmellDetector;
+    private readonly codeOptimizer;
+    private readonly perfOptimizer;
+    private readonly refactOptimizer;
+    constructor();
+    /**
+     * Detect all issues in a project
+     */
+    detect(projectPath: string, options?: DetectionOptions): Promise<OptimizationReport>;
+    /**
+     * Apply optimizations to a project
+     */
+    optimize(projectPath: string, optimizations: AppliedOptimization[], options?: DetectAndOptimizeOptions): Promise<OptimizationResult>;
+    /**
+     * Detect and optimize in one operation
+     */
+    detectAndOptimize(projectPath: string, options?: DetectAndOptimizeOptions): Promise<OptimizationResult>;
+    /**
+     * Generate a human-readable summary report
+     */
+    generateSummary(report: OptimizationReport): string;
+    /**
+     * Calculate potential impact score (0-100)
+     */
+    private calculatePotentialImpact;
+    /**
+     * Estimate time to fix all issues
+     */
+    private estimateFixTime;
+    /**
+     * Calculate estimated improvement from applied optimizations
+     */
+    private calculateEstimatedImprovement;
+    /**
+     * Detect project framework
+     */
+    private detectFramework;
+    /**
+     * Collect file statistics
+     */
+    private collectFileStats;
+    /**
+     * Check if working directory has uncommitted changes
+     */
+    private hasUncommittedChanges;
+    /**
+     * Check if severity matches minimum requirement
+     */
+    private isSeverityMatch;
+}
+//# sourceMappingURL=optimization.service.d.ts.map

package/dist/services/optimization/optimization.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimization.service.d.ts","sourceRoot":"","sources":["../../../src/services/optimization/optimization.service.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAKH,OAAO,KAAK,EACV,mBAAmB,EACnB,wBAAwB,EACxB,gBAAgB,EAChB,kBAAkB,EAClB,kBAAkB,EAEnB,MAAM,yBAAyB,CAAC;AASjC;;GAEG;AACH,qBAAa,mBAAmB;IAC9B,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAS;IAChC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAe;IAC5C,OAAO,CAAC,QAAQ,CAAC,iBAAiB,CAAoB;IACtD,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,aAAa,CAAgB;IAC9C,OAAO,CAAC,QAAQ,CAAC,eAAe,CAAkB;;IAYlD;;OAEG;IACG,MAAM,CACV,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,gBAAqB,GAC7B,OAAO,CAAC,kBAAkB,CAAC;IA2D9B;;OAEG;IACG,QAAQ,CACZ,WAAW,EAAE,MAAM,EACnB,aAAa,EAAE,mBAAmB,EAAE,EACpC,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,kBAAkB,CAAC;IAmF9B;;OAEG;IACG,iBAAiB,CACrB,WAAW,EAAE,MAAM,EACnB,OAAO,GAAE,wBAA6B,GACrC,OAAO,CAAC,kBAAkB,CAAC;IAoG9B;;OAEG;IACH,eAAe,CAAC,MAAM,EAAE,kBAAkB,GAAG,MAAM;IAuGnD;;OAEG;IACH,OAAO,CAAC,wBAAwB;IAsBhC;;OAEG;IACH,OAAO,CAAC,eAAe;IAsBvB;;OAEG;IACH,OAAO,CAAC,6BAA6B;IAwBrC;;OAEG;YACW,eAAe;IAgC7B;;OAEG;YACW,gBAAgB;IAiD9B;;OAEG;YACW,qBAAqB;IAiBnC;;OAEG;IACH,OAAO,CAAC,eAAe;CAOxB"}

package/dist/services/optimization/optimization.service.js

@@ -0,0 +1,511 @@
+/**
+ * Optimization Service
+ *
+ * Main orchestration service for bug detection, performance analysis,
+ * and code optimization. Coordinates all detectors and optimizers.
+ */
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+import { BugDetector } from './detectors/bug-detector.js';
+import { CodeSmellDetector } from './detectors/code-smell-detector.js';
+import { PerfDetector } from './detectors/perf-detector.js';
+import { CodeOptimizer } from './optimizers/code-optimizer.js';
+import { PerfOptimizer } from './optimizers/perf-optimizer.js';
+import { RefactOptimizer } from './optimizers/refact-optimizer.js';
+import { createLogger } from '../../shared/utils/logger.js';
+/**
+ * Optimization Service - Main orchestration
+ */
+export class OptimizationService {
+    logger;
+    bugDetector;
+    perfDetector;
+    codeSmellDetector;
+    codeOptimizer;
+    perfOptimizer;
+    refactOptimizer;
+    constructor() {
+        this.logger = createLogger('OptimizationService');
+        this.bugDetector = new BugDetector();
+        this.perfDetector = new PerfDetector();
+        this.codeSmellDetector = new CodeSmellDetector();
+        this.codeOptimizer = new CodeOptimizer();
+        this.perfOptimizer = new PerfOptimizer();
+        this.refactOptimizer = new RefactOptimizer();
+    }
+    /**
+     * Detect all issues in a project
+     */
+    async detect(projectPath, options = {}) {
+        const startTime = performance.now();
+        this.logger.info(`Starting optimization detection for: ${projectPath}`);
+        // Verify project exists
+        try {
+            await fs.access(projectPath);
+        }
+        catch {
+            throw new Error(`Project path does not exist: ${projectPath}`);
+        }
+        // Run all detectors in parallel
+        const [bugs, performanceIssues, codeSmells] = await Promise.all([
+            this.bugDetector.detectInDirectory(projectPath, options).catch(err => {
+                this.logger.error('Bug detection failed:', err);
+                return [];
+            }),
+            this.perfDetector.detectInDirectory(projectPath, options).catch(err => {
+                this.logger.error('Performance detection failed:', err);
+                return [];
+            }),
+            this.codeSmellDetector.detectInDirectory(projectPath, options).catch(err => {
+                this.logger.error('Code smell detection failed:', err);
+                return [];
+            }),
+        ]);
+        // Collect file statistics
+        const stats = await this.collectFileStats(projectPath);
+        const duration = Math.round(performance.now() - startTime);
+        this.logger.info(`Detection complete in ${duration}ms: ${bugs.length} bugs, ` +
+            `${performanceIssues.length} performance issues, ${codeSmells.length} code smells`);
+        // Calculate total potential impact
+        const totalPotentialImpact = this.calculatePotentialImpact(bugs, performanceIssues, codeSmells);
+        return {
+            projectPath,
+            timestamp: new Date(),
+            bugs: this.bugDetector.prioritizeBugs(bugs),
+            performanceIssues: this.perfDetector.prioritizeIssues(performanceIssues),
+            codeSmells: this.codeSmellDetector.prioritizeSmells(codeSmells),
+            totalPotentialImpact,
+            estimatedFixTime: this.estimateFixTime(bugs.length, performanceIssues.length, codeSmells.length),
+            framework: await this.detectFramework(projectPath),
+            filesAnalyzed: stats.fileCount,
+            linesOfCode: stats.linesOfCode,
+        };
+    }
+    /**
+     * Apply optimizations to a project
+     */
+    async optimize(projectPath, optimizations, options = {}) {
+        const startTime = performance.now();
+        this.logger.info(`Starting optimization for: ${projectPath}`);
+        // Check if dry run
+        if (options.dryRun) {
+            this.logger.info('Dry run mode - no files will be modified');
+        }
+        // Check git status if not skipping
+        if (!options.skipGitCheck && !options.dryRun) {
+            const hasUncommittedChanges = await this.hasUncommittedChanges(projectPath);
+            if (hasUncommittedChanges) {
+                throw new Error('Working directory has uncommitted changes. Please commit or stash changes before running optimizations, or use --skip-git-check');
+            }
+        }
+        const appliedOptimizations = [];
+        const errors = [];
+        // Group optimizations by file
+        const optimizationsByFile = new Map();
+        for (const opt of optimizations) {
+            for (const file of opt.modifiedFiles) {
+                const fullPath = path.resolve(projectPath, file);
+                if (!optimizationsByFile.has(fullPath)) {
+                    optimizationsByFile.set(fullPath, []);
+                }
+                optimizationsByFile.get(fullPath).push(opt);
+            }
+        }
+        // Apply optimizations per file
+        for (const [filePath, fileOpts] of optimizationsByFile.entries()) {
+            try {
+                if (options.dryRun) {
+                    appliedOptimizations.push(...fileOpts);
+                    continue;
+                }
+                // Read file content
+                const content = await fs.readFile(filePath, 'utf-8');
+                // Apply appropriate optimizer based on optimization type
+                for (const opt of fileOpts) {
+                    switch (opt.type) {
+                        case 'bug-fix':
+                        case 'refactoring':
+                            // Code optimizer handles basic refactoring
+                            break;
+                        case 'performance':
+                            // Performance optimizer
+                            break;
+                    }
+                }
+                appliedOptimizations.push(...fileOpts);
+            }
+            catch (error) {
+                errors.push({
+                    target: filePath,
+                    message: error instanceof Error ? error.message : String(error),
+                    fatal: false,
+                });
+            }
+        }
+        const duration = Math.round(performance.now() - startTime);
+        // Generate updated report
+        const report = await this.detect(projectPath, options);
+        return {
+            report,
+            appliedOptimizations,
+            remainingSuggestions: [],
+            estimatedImprovement: this.calculateEstimatedImprovement(appliedOptimizations),
+            errors,
+        };
+    }
+    /**
+     * Detect and optimize in one operation
+     */
+    async detectAndOptimize(projectPath, options = {}) {
+        this.logger.info(`Starting detect-and-optimize for: ${projectPath}`);
+        // First, detect all issues
+        const report = await this.detect(projectPath, options);
+        if (options.reportOnly) {
+            return {
+                report,
+                appliedOptimizations: [],
+                remainingSuggestions: [],
+                estimatedImprovement: 'Report only - no optimizations applied',
+                errors: [],
+            };
+        }
+        if (options.detectOnly) {
+            return {
+                report,
+                appliedOptimizations: [],
+                remainingSuggestions: [],
+                estimatedImprovement: 'Detect only - no optimizations applied',
+                errors: [],
+            };
+        }
+        // Determine which optimizations to apply
+        const optimizationsToApply = [];
+        // Auto-fixable bugs
+        const fixableBugs = report.bugs.filter(b => b.fixable);
+        for (const bug of fixableBugs.slice(0, options.maxFixes || 10)) {
+            if (options.minSeverity && !this.isSeverityMatch(bug.severity, options.minSeverity)) {
+                continue;
+            }
+            optimizationsToApply.push({
+                id: bug.id,
+                type: 'bug-fix',
+                description: bug.description,
+                modifiedFiles: [bug.location.filePath],
+                originalCode: bug.codeSnippet || '',
+                fixedCode: bug.suggestedFix,
+                location: bug.location,
+            });
+        }
+        // Generate suggestions for non-auto-fixable issues
+        const remainingSuggestions = [];
+        for (const bug of report.bugs.filter(b => !b.fixable)) {
+            remainingSuggestions.push({
+                id: bug.id,
+                type: 'bug-fix',
+                description: bug.description,
+                reason: 'Requires manual review and intervention',
+                manualFix: bug.suggestedFix,
+                location: bug.location,
+            });
+        }
+        for (const perfIssue of report.performanceIssues) {
+            remainingSuggestions.push({
+                id: perfIssue.id,
+                type: 'performance',
+                description: perfIssue.description,
+                reason: 'Performance optimization requires manual implementation',
+                manualFix: perfIssue.expectedImprovement,
+                location: perfIssue.location,
+            });
+        }
+        for (const smell of report.codeSmells) {
+            remainingSuggestions.push({
+                id: smell.id,
+                type: 'refactoring',
+                description: smell.description,
+                reason: 'Refactoring requires manual implementation',
+                manualFix: smell.suggestion,
+                location: smell.location,
+            });
+        }
+        // Apply optimizations if autoFix is enabled
+        let appliedOptimizations = [];
+        if (options.autoFix && optimizationsToApply.length > 0) {
+            const result = await this.optimize(projectPath, optimizationsToApply, options);
+            appliedOptimizations = result.appliedOptimizations;
+        }
+        return {
+            report,
+            appliedOptimizations,
+            remainingSuggestions,
+            estimatedImprovement: this.calculateEstimatedImprovement(appliedOptimizations),
+            errors: [],
+        };
+    }
+    /**
+     * Generate a human-readable summary report
+     */
+    generateSummary(report) {
+        const lines = [];
+        lines.push('');
+        lines.push('═══════════════════════════════════════════════════════════');
+        lines.push('                    OPTIMIZATION REPORT');
+        lines.push('═══════════════════════════════════════════════════════════');
+        lines.push('');
+        lines.push(`Project: ${report.projectPath}`);
+        lines.push(`Analyzed: ${report.timestamp.toLocaleString()}`);
+        lines.push(`Files: ${report.filesAnalyzed} (${report.linesOfCode.toLocaleString()} LOC)`);
+        lines.push(`Framework: ${report.framework || 'Unknown'}`);
+        lines.push('');
+        // Summary
+        lines.push('───────────────────────────────────────────────────────────');
+        lines.push('SUMMARY');
+        lines.push('───────────────────────────────────────────────────────────');
+        lines.push(`Potential Impact Score: ${report.totalPotentialImpact}/100`);
+        lines.push(`Estimated Fix Time: ${report.estimatedFixTime || 'Unknown'}`);
+        lines.push('');
+        // Bugs
+        lines.push('───────────────────────────────────────────────────────────');
+        lines.push('BUGS');
+        lines.push('───────────────────────────────────────────────────────────');
+        const bugSummary = this.bugDetector.generateSummary(report.bugs);
+        lines.push(`Total: ${bugSummary.total}`);
+        lines.push(`  Critical: ${bugSummary.bySeverity.critical}`);
+        lines.push(`  High: ${bugSummary.bySeverity.high}`);
+        lines.push(`  Medium: ${bugSummary.bySeverity.medium}`);
+        lines.push(`  Low: ${bugSummary.bySeverity.low}`);
+        lines.push(`Fixable: ${bugSummary.fixable}`);
+        lines.push('');
+        // Top bugs
+        const topBugs = report.bugs.slice(0, 5);
+        if (topBugs.length > 0) {
+            lines.push('Top Priority Bugs:');
+            for (const bug of topBugs) {
+                lines.push(`  [${bug.severity.toUpperCase()}] ${bug.description}`);
+                lines.push(`    → ${bug.location.filePath}:${bug.location.line}`);
+            }
+            lines.push('');
+        }
+        // Performance Issues
+        lines.push('───────────────────────────────────────────────────────────');
+        lines.push('PERFORMANCE ISSUES');
+        lines.push('───────────────────────────────────────────────────────────');
+        const perfSummary = this.perfDetector.generateSummary(report.performanceIssues);
+        lines.push(`Total: ${perfSummary.total}`);
+        lines.push(`  High Impact: ${perfSummary.byImpact.high}`);
+        lines.push(`  Medium Impact: ${perfSummary.byImpact.medium}`);
+        lines.push(`  Low Impact: ${perfSummary.byImpact.low}`);
+        lines.push(`Estimated Gain: ${perfSummary.totalEstimatedGain}%`);
+        lines.push('');
+        // Top performance issues
+        const topPerf = report.performanceIssues.slice(0, 5);
+        if (topPerf.length > 0) {
+            lines.push('Top Impact Issues:');
+            for (const issue of topPerf) {
+                lines.push(`  [${issue.impact.toUpperCase()}] ${issue.description}`);
+                lines.push(`    → ${issue.location.filePath}:${issue.location.line}`);
+                lines.push(`    Expected: ${issue.expectedImprovement}`);
+            }
+            lines.push('');
+        }
+        // Code Smells
+        lines.push('───────────────────────────────────────────────────────────');
+        lines.push('CODE SMELLS');
+        lines.push('───────────────────────────────────────────────────────────');
+        const smellSummary = this.codeSmellDetector.generateSummary(report.codeSmells);
+        lines.push(`Total: ${smellSummary.total}`);
+        lines.push(`  High: ${smellSummary.bySeverity.high}`);
+        lines.push(`  Medium: ${smellSummary.bySeverity.medium}`);
+        lines.push(`  Low: ${smellSummary.bySeverity.low}`);
+        lines.push(`Avg Complexity: ${smellSummary.avgComplexity}`);
+        lines.push('');
+        // Recommendations
+        lines.push('───────────────────────────────────────────────────────────');
+        lines.push('RECOMMENDATIONS');
+        lines.push('───────────────────────────────────────────────────────────');
+        if (bugSummary.fixable > 0) {
+            lines.push(`• Apply ${bugSummary.fixable} auto-fixable bugs immediately`);
+        }
+        if (perfSummary.totalEstimatedGain > 30) {
+            lines.push(`• Address performance issues for ${perfSummary.totalEstimatedGain}% potential improvement`);
+        }
+        if (bugSummary.bySeverity.critical > 0) {
+            lines.push(`• CRITICAL: Fix ${bugSummary.bySeverity.critical} critical bugs before deployment`);
+        }
+        lines.push('');
+        lines.push('═══════════════════════════════════════════════════════════');
+        lines.push('');
+        return lines.join('\n');
+    }
+    /**
+     * Calculate potential impact score (0-100)
+     */
+    calculatePotentialImpact(bugs, perfIssues, codeSmells) {
+        const bugWeight = 2;
+        const perfWeight = 1;
+        const smellWeight = 0.5;
+        const bugScore = Math.min(bugs.length * bugWeight, 40);
+        const perfScore = Math.min(perfIssues.reduce((sum, p) => sum + (p.estimatedGain || 0), 0) / 10, 40);
+        const smellScore = Math.min(codeSmells.reduce((sum, s) => sum + (s.complexityScore || 0), 0) / 20, 20);
+        return Math.round(Math.min(bugScore + perfScore + smellScore, 100));
+    }
+    /**
+     * Estimate time to fix all issues
+     */
+    estimateFixTime(bugCount, perfCount, smellCount) {
+        const bugTime = bugCount * 15; // 15 minutes per bug
+        const perfTime = perfCount * 30; // 30 minutes per perf issue
+        const smellTime = smellCount * 20; // 20 minutes per code smell
+        const totalMinutes = bugTime + perfTime + smellTime;
+        if (totalMinutes < 60) {
+            return `${totalMinutes} minutes`;
+        }
+        const hours = Math.floor(totalMinutes / 60);
+        const minutes = totalMinutes % 60;
+        if (hours < 8) {
+            return minutes > 0 ? `${hours}h ${minutes}m` : `${hours} hours`;
+        }
+        const days = Math.ceil(hours / 8);
+        return `${days} days`;
+    }
+    /**
+     * Calculate estimated improvement from applied optimizations
+     */
+    calculateEstimatedImprovement(optimizations) {
+        if (optimizations.length === 0) {
+            return 'No optimizations applied';
+        }
+        const perfOpts = optimizations.filter(o => o.type === 'performance').length;
+        const bugOpts = optimizations.filter(o => o.type === 'bug-fix').length;
+        const refactorOpts = optimizations.filter(o => o.type === 'refactoring').length;
+        const improvements = [];
+        if (perfOpts > 0) {
+            improvements.push(`~${perfOpts * 5}% performance improvement`);
+        }
+        if (bugOpts > 0) {
+            improvements.push(`${bugOpts} bugs fixed`);
+        }
+        if (refactorOpts > 0) {
+            improvements.push(`${refactorOpts} refactorings applied`);
+        }
+        return improvements.join(', ') || 'Minor improvements';
+    }
+    /**
+     * Detect project framework
+     */
+    async detectFramework(projectPath) {
+        try {
+            const pkgPath = path.join(projectPath, 'package.json');
+            const pkgContent = await fs.readFile(pkgPath, 'utf-8');
+            const pkg = JSON.parse(pkgContent);
+            const deps = { ...pkg.dependencies, ...pkg.devDependencies };
+            if (deps.next)
+                return 'Next.js';
+            if (deps.react && deps.vite)
+                return 'Vite + React';
+            if (deps.vue && deps.vite)
+                return 'Vite + Vue';
+            if (deps.svelte && deps.vite)
+                return 'Vite + Svelte';
+            if (deps.remix)
+                return 'Remix';
+            if (deps['@sveltejs/kit'])
+                return 'SvelteKit';
+            if (deps.nuxt)
+                return 'Nuxt';
+            if (deps.astro)
+                return 'Astro';
+            if (deps.gatsby)
+                return 'Gatsby';
+            if (deps.angular)
+                return 'Angular';
+            if (deps.react)
+                return 'React';
+            if (deps.vue)
+                return 'Vue';
+            if (deps.svelte)
+                return 'Svelte';
+            if (deps.express)
+                return 'Express';
+            if (deps.nest)
+                return 'NestJS';
+            if (deps.fastify)
+                return 'Fastify';
+            if (deps.hono)
+                return 'Hono';
+            return undefined;
+        }
+        catch {
+            return undefined;
+        }
+    }
+    /**
+     * Collect file statistics
+     */
+    async collectFileStats(projectPath) {
+        let fileCount = 0;
+        let linesOfCode = 0;
+        const extensions = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.svelte'];
+        async function walk(currentPath) {
+            try {
+                const entries = await fs.readdir(currentPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    if (entry.name === 'node_modules' ||
+                        entry.name === '.git' ||
+                        entry.name === 'dist' ||
+                        entry.name === 'build') {
+                        continue;
+                    }
+                    const fullPath = path.join(currentPath, entry.name);
+                    if (entry.isDirectory()) {
+                        await walk(fullPath);
+                    }
+                    else if (entry.isFile()) {
+                        const ext = path.extname(entry.name);
+                        if (extensions.includes(ext)) {
+                            fileCount++;
+                            try {
+                                const content = await fs.readFile(fullPath, 'utf-8');
+                                linesOfCode += content.split('\n').length;
+                            }
+                            catch {
+                                // Skip files that can't be read
+                            }
+                        }
+                    }
+                }
+            }
+            catch {
+                // Skip directories we can't read
+            }
+        }
+        await walk(projectPath);
+        return { fileCount, linesOfCode };
+    }
+    /**
+     * Check if working directory has uncommitted changes
+     */
+    async hasUncommittedChanges(projectPath) {
+        try {
+            const { exec } = await import('node:child_process');
+            const util = require('node:util');
+            const execAsync = util.promisify(exec);
+            const { stdout } = await execAsync('git status --porcelain', {
+                cwd: projectPath,
+            });
+            return stdout.trim().length > 0;
+        }
+        catch {
+            // Not a git repo or git not available
+            return false;
+        }
+    }
+    /**
+     * Check if severity matches minimum requirement
+     */
+    isSeverityMatch(severity, minSeverity) {
+        const order = ['critical', 'high', 'medium', 'low'];
+        return order.indexOf(severity) <= order.indexOf(minSeverity);
+    }
+}
+//# sourceMappingURL=optimization.service.js.map