@m3hti/commit-genie 1.2.5 → 1.2.7

package/dist/services/analyzerService.js

@@ -0,0 +1,1811 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AnalyzerService = void 0;
+const gitService_1 = require("./gitService");
+const configService_1 = require("./configService");
+const historyService_1 = require("./historyService");
+const aiService_1 = require("./aiService");
+const filePatterns_1 = require("../utils/filePatterns");
+const COMMIT_EMOJIS = {
+    feat: '✨',
+    fix: '🐛',
+    docs: '📚',
+    style: '💄',
+    refactor: '♻️',
+    test: '🧪',
+    chore: '🔧',
+    perf: '⚡',
+};
+// Default keywords that indicate breaking changes
+const DEFAULT_BREAKING_KEYWORDS = [
+    'breaking',
+    'breaking change',
+    'breaking-change',
+    'removed',
+    'deprecated',
+    'incompatible',
+];
+// Patterns that indicate breaking changes in code
+const BREAKING_PATTERNS = [
+    // Removed exports
+    /^-\s*export\s+(function|class|const|let|var|interface|type|enum)\s+(\w+)/gm,
+    // Removed function parameters
+    /^-\s*(public|private|protected)?\s*(async\s+)?function\s+\w+\s*\([^)]+\)/gm,
+    // Changed function signatures (removed parameters)
+    /^-\s*\w+\s*\([^)]+\)\s*[:{]/gm,
+    // Removed class methods
+    /^-\s*(public|private|protected)\s+(static\s+)?(async\s+)?\w+\s*\(/gm,
+    // Removed interface/type properties
+    /^-\s+\w+\s*[?:]?\s*:/gm,
+    // Major version bump in package.json
+    /^-\s*"version":\s*"\d+/gm,
+];
+// Role detection patterns for semantic analysis
+const ROLE_PATTERNS = {
+    ui: [
+        // JSX elements and components
+        /^\+.*<[A-Z][a-zA-Z]*[\s/>]/m, // JSX component usage
+        /^\+.*<\/[A-Z][a-zA-Z]*>/m, // JSX component closing
+        /^\+.*<(div|span|p|h[1-6]|button|input|form|ul|li|table|img|a|section|header|footer|nav|main|article|aside)\b/mi,
+        /^\+.*className\s*=/m, // className attribute
+        /^\+.*style\s*=\s*\{/m, // inline styles
+        /^\+.*return\s*\(/m, // render return
+        /^\+.*render\s*\(\s*\)/m, // render method
+        /^\+.*<>|<\/>/m, // React fragments
+        /^\+.*aria-\w+=/m, // accessibility attributes
+        /^\+.*role\s*=/m, // role attribute
+        /^\+.*onClick|onSubmit|onChange|onFocus|onBlur|onKeyDown|onKeyUp|onMouseEnter|onMouseLeave/m,
+    ],
+    logic: [
+        // Business logic patterns
+        /^\+.*\bif\s*\(/m, // conditionals
+        /^\+.*\bswitch\s*\(/m, // switch statements
+        /^\+.*\bfor\s*\(/m, // for loops
+        /^\+.*\bwhile\s*\(/m, // while loops
+        /^\+.*\.map\s*\(/m, // array operations
+        /^\+.*\.filter\s*\(/m,
+        /^\+.*\.reduce\s*\(/m,
+        /^\+.*\.find\s*\(/m,
+        /^\+.*\.some\s*\(/m,
+        /^\+.*\.every\s*\(/m,
+        /^\+.*\btry\s*\{/m, // error handling
+        /^\+.*\bcatch\s*\(/m,
+        /^\+.*\bthrow\s+/m,
+        /^\+.*\breturn\s+(?![\s(]?<)/m, // return (not JSX)
+        /^\+.*\bawait\s+/m, // async operations
+        /^\+.*\bnew\s+[A-Z]/m, // object instantiation
+        /^\+.*=>\s*\{/m, // arrow function body
+    ],
+    data: [
+        // State and data management
+        /^\+.*\buseState\s*[<(]/m, // React state
+        /^\+.*\buseReducer\s*\(/m, // React reducer
+        /^\+.*\buseContext\s*\(/m, // React context
+        /^\+.*\buseSelector\s*\(/m, // Redux selector
+        /^\+.*\bdispatch\s*\(/m, // Redux dispatch
+        /^\+.*\bsetState\s*\(/m, // Class component state
+        /^\+.*\bthis\.state\b/m, // Class component state access
+        /^\+.*\bprops\./m, // Props access
+        /^\+.*interface\s+\w+Props/m, // Props interface
+        /^\+.*type\s+\w+Props/m, // Props type
+        /^\+.*\bconst\s+\[[a-z]+,\s*set[A-Z]/m, // State destructuring
+        /^\+.*:\s*\w+\[\]/m, // Array type
+        /^\+.*:\s*(string|number|boolean|object)/m, // Primitive types
+        /^\+.*\binterface\s+\w+/m, // Interface definition
+        /^\+.*\btype\s+\w+\s*=/m, // Type definition
+    ],
+    style: [
+        // CSS and styling
+        /^\+.*\bstyles?\./m, // styles object access
+        /^\+.*\bstyled\./m, // styled-components
+        /^\+.*\bcss`/m, // CSS template literal
+        /^\+.*\bsx\s*=\s*\{/m, // MUI sx prop
+        /^\+.*:\s*['"]?[0-9]+(px|em|rem|%|vh|vw)/m, // CSS units
+        /^\+.*:\s*['"]?#[0-9a-fA-F]{3,8}/m, // Hex colors
+        /^\+.*:\s*['"]?rgb(a)?\s*\(/m, // RGB colors
+        /^\+.*(margin|padding|width|height|border|background|color|font|display|flex|grid)\s*:/m,
+        /^\+.*\btheme\./m, // Theme access
+        /^\+.*\.module\.css/m, // CSS modules import
+    ],
+    api: [
+        // API and network calls
+        /^\+.*\bfetch\s*\(/m, // fetch API
+        /^\+.*\baxios\./m, // axios
+        /^\+.*\.get\s*\(/m, // HTTP GET
+        /^\+.*\.post\s*\(/m, // HTTP POST
+        /^\+.*\.put\s*\(/m, // HTTP PUT
+        /^\+.*\.delete\s*\(/m, // HTTP DELETE
+        /^\+.*\.patch\s*\(/m, // HTTP PATCH
+        /^\+.*\bapi\./m, // api object access
+        /^\+.*\/api\//m, // API path
+        /^\+.*\bendpoint/mi, // endpoint reference
+        /^\+.*\bheaders\s*:/m, // HTTP headers
+        /^\+.*\bAuthorization:/m, // Auth header
+        /^\+.*\buseQuery\s*\(/m, // React Query
+        /^\+.*\buseMutation\s*\(/m, // React Query mutation
+        /^\+.*\bswr\b/mi, // SWR
+        /^\+.*\bgraphql`/m, // GraphQL
+        /^\+.*\bquery\s*\{/m, // GraphQL query
+        /^\+.*\bmutation\s*\{/m, // GraphQL mutation
+    ],
+    config: [
+        // Configuration
+        /^\+.*\bprocess\.env\./m, // Environment variables
+        /^\+.*\bimport\.meta\.env\./m, // Vite env
+        /^\+.*\bCONFIG\./m, // Config constant
+        /^\+.*\bsettings\./m, // Settings object
+        /^\+.*\boptions\s*:/m, // Options object
+        /^\+.*\bdefaultProps/m, // Default props
+        /^\+.*\bexport\s+(const|let)\s+[A-Z_]+\s*=/m, // Constant export
+        /^\+.*:\s*['"]?(development|production|test)['"]/m, // Environment strings
+    ],
+    test: [
+        // Testing patterns
+        /^\+.*\bdescribe\s*\(/m, // Test suite
+        /^\+.*\bit\s*\(/m, // Test case
+        /^\+.*\btest\s*\(/m, // Test case
+        /^\+.*\bexpect\s*\(/m, // Assertion
+        /^\+.*\bjest\./m, // Jest
+        /^\+.*\bmock\(/m, // Mocking
+        /^\+.*\bspyOn\s*\(/m, // Spy
+        /^\+.*\bbeforeEach\s*\(/m, // Setup
+        /^\+.*\bafterEach\s*\(/m, // Teardown
+        /^\+.*\brender\s*\(/m, // React testing library
+    ],
+    unknown: [],
+};
+// Intent detection patterns
+const INTENT_PATTERNS = {
+    add: [
+        /^\+\s*export\s+(function|class|const|interface|type)/m,
+        /^\+\s*(async\s+)?function\s+\w+/m,
+        /^\+\s*const\s+\w+\s*=\s*(async\s+)?\(/m,
+        /^\+\s*class\s+\w+/m,
+    ],
+    modify: [
+    // Changes that have both additions and deletions of similar patterns
+    ],
+    fix: [
+        /^\+.*\btypeof\s+\w+\s*[!=]==?\s*['"`]/m,
+        /^\+.*\binstanceof\s+/m,
+        /^\+.*\bArray\.isArray\s*\(/m,
+        /^\+.*\bif\s*\(\s*!\w+\s*\)/m,
+        /^\+.*\?\?/m,
+        /^\+.*\?\./m,
+        /^\+.*\|\|\s*['"{\[0]/m, // Default values
+        /^\+.*\bcatch\s*\(/m,
+        /^\+.*\btry\s*\{/m,
+    ],
+    remove: [
+        /^-\s*export\s+(function|class|const|interface|type)/m,
+        /^-\s*(async\s+)?function\s+\w+/m,
+        /^-\s*class\s+\w+/m,
+    ],
+    refactor: [
+        /^\+.*=>/m, // Arrow function conversion
+        /^\+.*\.\.\./m, // Spread operator
+        /^\+.*`\$\{/m, // Template literal
+        /^\+.*Object\.(keys|values|entries)/m, // Object methods
+    ],
+    enhance: [
+        /^\+.*\bmemo\s*\(/m, // React memo
+        /^\+.*\buseMemo\s*\(/m, // useMemo hook
+        /^\+.*\buseCallback\s*\(/m, // useCallback hook
+        /^\+.*\blazy\s*\(/m, // React lazy
+        /^\+.*\bSuspense\b/m, // React Suspense
+    ],
+    rename: [
+    // Rename detection is handled by detectRenames() method
+    // which compares removed and added function/class/type names
+    ],
+};
+// Role descriptions for commit messages
+const ROLE_DESCRIPTIONS = {
+    ui: 'UI/rendering',
+    logic: 'business logic',
+    data: 'data/state management',
+    style: 'styling',
+    api: 'API integration',
+    config: 'configuration',
+    test: 'tests',
+    unknown: 'code',
+};
+// Intent verb mappings for commit messages
+const INTENT_VERBS = {
+    add: { past: 'added', present: 'add' },
+    modify: { past: 'updated', present: 'update' },
+    fix: { past: 'fixed', present: 'fix' },
+    remove: { past: 'removed', present: 'remove' },
+    refactor: { past: 'refactored', present: 'refactor' },
+    enhance: { past: 'enhanced', present: 'improve' },
+    rename: { past: 'renamed', present: 'rename' },
+};
+class AnalyzerService {
+    /**
+     * Analyze staged changes and return structured analysis
+     */
+    static analyzeChanges() {
+        const stagedFiles = gitService_1.GitService.getStagedFiles();
+        const diff = gitService_1.GitService.getDiff();
+        const stats = gitService_1.GitService.getDiffStats();
+        const filesAffected = {
+            test: 0,
+            docs: 0,
+            config: 0,
+            source: 0,
+        };
+        const fileChanges = {
+            added: [],
+            modified: [],
+            deleted: [],
+            renamed: [],
+        };
+        // Analyze file types and statuses
+        for (const file of stagedFiles) {
+            const fileType = (0, filePatterns_1.detectFileType)(file.path);
+            filesAffected[fileType]++;
+            const fileName = this.getFileName(file.path);
+            switch (file.status) {
+                case 'A':
+                    fileChanges.added.push(fileName);
+                    break;
+                case 'M':
+                    fileChanges.modified.push(fileName);
+                    break;
+                case 'D':
+                    fileChanges.deleted.push(fileName);
+                    break;
+                case 'R':
+                    fileChanges.renamed.push(fileName);
+                    break;
+            }
+        }
+        // Determine if this is a large change (3+ files or 100+ lines changed)
+        const totalChanges = stats.insertions + stats.deletions;
+        const isLargeChange = stagedFiles.length >= 3 || totalChanges >= 100;
+        // Determine commit type based on file types and changes
+        let commitType = this.determineCommitType(filesAffected, diff, stagedFiles);
+        // Determine scope if applicable
+        const scope = this.determineScope(stagedFiles);
+        // Detect breaking changes
+        let { isBreaking, reasons } = this.detectBreakingChanges(diff, stagedFiles);
+        // Perform semantic analysis for intent-based messages
+        // Only perform for source files to avoid overhead on simple config/doc changes
+        let semanticAnalysis;
+        if (filesAffected.source > 0 && diff.length > 0) {
+            semanticAnalysis = this.analyzeSemanticChanges(diff, stagedFiles);
+        }
+        // Renames don't remove functionality — the function still exists with a new name
+        if (semanticAnalysis?.primaryIntent === 'rename' && isBreaking) {
+            isBreaking = false;
+            reasons = [];
+        }
+        // Apply semantic intent → commit type mapping policy
+        // Only override heuristic 'feat' type when semantic analysis provides specific intent
+        // This preserves specialized types (perf, docs, test, style, chore) detected by heuristics
+        if (semanticAnalysis && commitType === 'feat') {
+            const intentToType = {
+                fix: 'fix',
+                refactor: 'refactor',
+                rename: 'refactor',
+            };
+            const mappedType = intentToType[semanticAnalysis.primaryIntent];
+            if (mappedType) {
+                commitType = mappedType;
+            }
+        }
+        // Generate description (uses semantic analysis when available)
+        const description = this.generateDescription(filesAffected, {
+            added: fileChanges.added.length,
+            modified: fileChanges.modified.length,
+            deleted: fileChanges.deleted.length,
+            renamed: fileChanges.renamed.length
+        }, stagedFiles, diff, semanticAnalysis);
+        return {
+            commitType,
+            scope,
+            description,
+            filesAffected,
+            fileChanges,
+            isLargeChange,
+            isBreakingChange: isBreaking,
+            breakingChangeReasons: reasons,
+            semanticAnalysis,
+        };
+    }
+    /**
+     * Detect breaking changes from diff content and file changes
+     */
+    static detectBreakingChanges(diff, stagedFiles) {
+        const config = configService_1.ConfigService.getConfig();
+        const breakingConfig = config.breakingChangeDetection;
+        // Check if breaking change detection is disabled
+        if (breakingConfig?.enabled === false) {
+            return { isBreaking: false, reasons: [] };
+        }
+        const reasons = [];
+        const diffLower = diff.toLowerCase();
+        // Check for keyword-based breaking changes
+        const keywords = breakingConfig?.keywords || DEFAULT_BREAKING_KEYWORDS;
+        for (const keyword of keywords) {
+            if (diffLower.includes(keyword.toLowerCase())) {
+                reasons.push(`Contains "${keyword}" keyword`);
+            }
+        }
+        // Check for deleted source files (potentially breaking)
+        const deletedSourceFiles = stagedFiles.filter(f => f.status === 'D' && (0, filePatterns_1.detectFileType)(f.path) === 'source');
+        if (deletedSourceFiles.length > 0) {
+            const fileNames = deletedSourceFiles.map(f => this.getFileName(f.path)).join(', ');
+            reasons.push(`Deleted source files: ${fileNames}`);
+        }
+        // Check for pattern-based breaking changes in diff
+        for (const pattern of BREAKING_PATTERNS) {
+            pattern.lastIndex = 0; // Reset regex state
+            const matches = diff.match(pattern);
+            if (matches && matches.length > 0) {
+                // Identify what type of breaking change
+                if (pattern.source.includes('export')) {
+                    reasons.push('Removed exported members');
+                }
+                else if (pattern.source.includes('function')) {
+                    reasons.push('Changed function signatures');
+                }
+                else if (pattern.source.includes('public|private|protected')) {
+                    reasons.push('Removed class methods');
+                }
+                else if (pattern.source.includes('version')) {
+                    reasons.push('Major version change detected');
+                }
+                break; // Only add one pattern-based reason
+            }
+        }
+        // Check for renamed files that might break imports
+        const renamedFiles = stagedFiles.filter(f => f.status === 'R');
+        if (renamedFiles.length > 0) {
+            const sourceRenames = renamedFiles.filter(f => (0, filePatterns_1.detectFileType)(f.path) === 'source');
+            if (sourceRenames.length > 0) {
+                reasons.push('Renamed source files (may break imports)');
+            }
+        }
+        // Deduplicate reasons
+        const uniqueReasons = [...new Set(reasons)];
+        return {
+            isBreaking: uniqueReasons.length > 0,
+            reasons: uniqueReasons,
+        };
+    }
+    /**
+     * Determine the commit type based on analysis
+     */
+    static determineCommitType(filesAffected, diff, stagedFiles) {
+        const diffLower = diff.toLowerCase();
+        const filePaths = stagedFiles.map((f) => f.path.toLowerCase());
+        // === FILE TYPE BASED DETECTION (highest priority) ===
+        // If only test files changed
+        if (filesAffected.test > 0 &&
+            filesAffected.source === 0 &&
+            filesAffected.docs === 0) {
+            return 'test';
+        }
+        // If only docs changed
+        if (filesAffected.docs > 0 &&
+            filesAffected.source === 0 &&
+            filesAffected.test === 0) {
+            return 'docs';
+        }
+        // If only config files changed
+        if (filesAffected.config > 0 &&
+            filesAffected.source === 0 &&
+            filesAffected.test === 0 &&
+            filesAffected.docs === 0) {
+            return 'chore';
+        }
+        // === DOCS DETECTION (comment-only changes) ===
+        // Check if the changes are only adding/modifying comments (documentation)
+        if (this.isCommentOnlyChange(diff)) {
+            return 'docs';
+        }
+        // === FORMATTING-ONLY DETECTION (code style, not CSS) ===
+        // Per Conventional Commits: "style" = changes that do not affect the meaning of the code
+        // (white-space, formatting, missing semi-colons, etc.)
+        if (this.isFormattingOnlyChange(diff)) {
+            return 'style';
+        }
+        // === STYLE DETECTION (CSS/UI) ===
+        // CSS/UI styling changes also classify as "style"
+        // Check for CSS/styling file extensions
+        const isStyleFile = filePaths.some(p => p.endsWith('.css') ||
+            p.endsWith('.scss') ||
+            p.endsWith('.sass') ||
+            p.endsWith('.less') ||
+            p.endsWith('.styl') ||
+            p.endsWith('.stylus') ||
+            p.includes('.styles.') ||
+            p.includes('.style.') ||
+            p.includes('styles/') ||
+            p.includes('/theme') ||
+            p.includes('theme.') ||
+            p.includes('.theme.'));
+        // Check for styled-components, Tailwind, or inline style changes in diff content
+        const hasStyledComponentChanges = /^\+.*\bstyled\s*[.(]/m.test(diff) ||
+            /^\+.*\bcss\s*`/m.test(diff) ||
+            /^\+.*\@emotion\/styled/m.test(diff);
+        const hasTailwindChanges = /^\+.*\bclassName\s*=.*\b(flex|grid|bg-|text-|p-|m-|w-|h-|rounded|border|shadow|hover:|focus:|sm:|md:|lg:|xl:)/m.test(diff);
+        const hasInlineStyleChanges = /^\+.*\bstyle\s*=\s*\{\{/m.test(diff);
+        const hasThemeChanges = /^\+.*(theme\s*[:=]|colors\s*[:=]|palette\s*[:=]|spacing\s*[:=]|typography\s*[:=])/m.test(diff);
+        const hasSxPropChanges = /^\+.*\bsx\s*=\s*\{/m.test(diff);
+        // Only classify as "style" if it's a CSS file OR contains actual CSS/styling code
+        const hasActualStyleChanges = isStyleFile || hasStyledComponentChanges ||
+            hasTailwindChanges || hasInlineStyleChanges ||
+            hasThemeChanges || hasSxPropChanges;
+        // NEVER classify as style if it's just JS without CSS
+        // This prevents console.log, debug statements, comments, test prints from being labeled as style
+        if (hasActualStyleChanges && !this.hasOnlyNonStyleJsChanges(diff, filePaths)) {
+            return 'style';
+        }
+        // === PERFORMANCE DETECTION ===
+        const perfPatterns = [
+            /\bperformance\b/i,
+            /\boptimiz(e|ation|ing)\b/i,
+            /\bfaster\b/i,
+            /\bspeed\s*(up|improvement)\b/i,
+            /\bcach(e|ing)\b/i,
+            /\bmemoiz(e|ation)\b/i,
+            /\blazy\s*load/i,
+            /\basync\b.*\bawait\b/i,
+            /\bparallel\b/i,
+            /\bbatch(ing)?\b/i,
+        ];
+        if (perfPatterns.some(p => p.test(diffLower))) {
+            return 'perf';
+        }
+        // === DETECT NEW FUNCTIONALITY FIRST ===
+        // This must come BEFORE fix detection to avoid false positives when new functions contain validation
+        const hasNewFiles = stagedFiles.some((f) => f.status === 'A');
+        // Comprehensive new code detection
+        const hasNewExports = /^\+\s*export\s+(function|class|const|let|var|interface|type|default)/m.test(diff);
+        const hasNewFunctions = /^\+\s*(async\s+)?function\s+\w+/m.test(diff);
+        const hasNewArrowFunctions = /^\+\s*(export\s+)?(const|let|var)\s+\w+\s*=\s*(async\s+)?\([^)]*\)\s*=>/m.test(diff);
+        const hasNewClasses = /^\+\s*(export\s+)?(class|abstract\s+class)\s+\w+/m.test(diff);
+        const hasNewMethods = /^\+\s+(async\s+)?\w+\s*\([^)]*\)\s*{/m.test(diff);
+        const hasNewInterfaces = /^\+\s*(export\s+)?(interface|type)\s+\w+/m.test(diff);
+        const hasNewComponents = /^\+\s*(export\s+)?(const|function)\s+[A-Z]\w+/m.test(diff); // React components start with capital
+        const hasNewImports = /^\+\s*import\s+/m.test(diff);
+        // Count significant additions vs removals
+        const addedLines = (diff.match(/^\+[^+]/gm) || []).length;
+        const removedLines = (diff.match(/^-[^-]/gm) || []).length;
+        const netNewLines = addedLines - removedLines;
+        // Detect if we're adding new functionality
+        const hasNewFunctionality = hasNewExports || hasNewFunctions || hasNewArrowFunctions ||
+            hasNewClasses || hasNewMethods || hasNewInterfaces || hasNewComponents;
+        // === FEAT DETECTION (new functionality) - CHECK BEFORE FIX ===
+        if (hasNewFiles) {
+            return 'feat';
+        }
+        // New functions, classes, components = feat (even if they contain validation code)
+        if (hasNewFunctionality) {
+            return 'feat';
+        }
+        // Significant net additions with new imports often means new feature
+        if (hasNewImports && netNewLines > 5) {
+            return 'feat';
+        }
+        // Check for new feature indicators in comments/strings
+        const featPatterns = [
+            /\badd(s|ed|ing)?\s+(new\s+)?(feature|support|ability|option|functionality)/i,
+            /\bimplement(s|ed|ing)?\s+\w+/i,
+            /\bintroduc(e|es|ed|ing)\s+(new\s+)?\w+/i,
+            /\benable(s|d|ing)?\s+(new\s+)?\w+/i,
+            /\bnew\s+(feature|function|method|api|endpoint)/i,
+        ];
+        if (featPatterns.some(p => p.test(diff))) {
+            return 'feat';
+        }
+        // === FIX DETECTION ===
+        // Only check for validation patterns AFTER confirming no new functions/classes were added
+        // Check if this is adding validation/guards to existing code (defensive coding = fix)
+        const hasOnlyModifications = stagedFiles.every((f) => f.status === 'M');
+        const validationPatterns = [
+            /^\+.*\btypeof\s+\w+\s*===?\s*['"`]\w+['"`]/m, // typeof checks
+            /^\+.*\binstanceof\s+\w+/m, // instanceof checks
+            /^\+.*\bArray\.isArray\s*\(/m, // Array.isArray checks
+            /^\+.*\b(Number|String|Boolean)\.is\w+\s*\(/m, // Number.isNaN, etc.
+            /^\+.*\bif\s*\(\s*typeof\b/m, // if (typeof ...
+            /^\+.*\bif\s*\(\s*!\w+\s*\)/m, // if (!var) guards
+            /^\+.*\bif\s*\(\s*\w+\s*(===?|!==?)\s*(null|undefined)\s*\)/m, // null/undefined checks
+            /^\+.*\bif\s*\(\s*(null|undefined)\s*(===?|!==?)\s*\w+\s*\)/m, // null/undefined checks (reversed)
+            /^\+.*\bif\s*\(\s*\w+\s*[<>]=?\s*-?\d/m, // numeric boundary checks: if (n < 0), if (x > 10)
+            /^\+.*\bif\s*\(\s*-?\d+\s*[<>]=?\s*\w+/m, // numeric boundary checks (reversed): if (0 > n)
+            /^\+.*\?\?/m, // Nullish coalescing
+            /^\+.*\?\./m, // Optional chaining
+            /^\+.*\|\|/m, // Default value patterns (when combined with guards)
+        ];
+        // Check if this is a simplification refactor (using modern syntax to replace verbose code)
+        // When deletions > additions significantly, it's likely simplifying existing code, not adding new checks
+        const isSimplificationRefactor = removedLines > addedLines &&
+            (removedLines - addedLines) >= 3 && // At least 3 net lines removed (significant simplification)
+            (/^\+.*\?\./m.test(diff) || // Using optional chaining
+                /^\+.*\?\?/m.test(diff) // Using nullish coalescing
+            ) &&
+            (/^-.*\bif\s*\(/m.test(diff) // Removing if statements
+            );
+        // If it's a simplification (replacing verbose ifs with optional chaining), it's refactor
+        if (isSimplificationRefactor) {
+            return 'refactor';
+        }
+        // If only modifying files (no new functions detected) and adding validation patterns, it's likely a fix
+        if (hasOnlyModifications && validationPatterns.some(p => p.test(diff))) {
+            return 'fix';
+        }
+        const fixPatterns = [
+            /\bfix(es|ed|ing)?\s*(the\s*)?(bug|issue|error|problem|crash)/i,
+            /\bfix(es|ed|ing)?\b/i, // Simple "fix" or "fixed" alone
+            /\bbug\s*fix/i,
+            /\bBUG:/i, // Bug comment markers
+            /\bhotfix\b/i,
+            /\bpatch(es|ed|ing)?\b/i,
+            /\bresolv(e|es|ed|ing)\s*(the\s*)?(issue|bug|error)/i,
+            /\bcorrect(s|ed|ing)?\s*(the\s*)?(bug|issue|error|problem)/i,
+            /\brepair(s|ed|ing)?\b/i,
+            /\bhandle\s*(error|exception|null|undefined)/i,
+            /\bnull\s*check/i,
+            /\bundefined\s*check/i,
+            /\btry\s*{\s*.*\s*}\s*catch/i,
+            /\bif\s*\(\s*!\s*\w+\s*\)/, // Null/undefined guards
+            /\bwas\s*broken\b/i, // "was broken" indicates fixing
+            /\bbroken\b.*\bfix/i, // broken...fix pattern
+        ];
+        if (fixPatterns.some(p => p.test(diff))) {
+            return 'fix';
+        }
+        // === REFACTOR DETECTION ===
+        const refactorPatterns = [
+            /\brefactor(s|ed|ing)?\b/i,
+            /\brestructur(e|es|ed|ing)\b/i,
+            /\bclean\s*up\b/i,
+            /\bsimplif(y|ies|ied|ying)\b/i,
+            /\brenam(e|es|ed|ing)\b/i,
+            /\bmov(e|es|ed|ing)\s*(to|from|into)\b/i,
+            /\bextract(s|ed|ing)?\s*(function|method|class|component)/i,
+            /\binline(s|d|ing)?\b/i,
+            /\bdedup(licate)?\b/i,
+            /\bDRY\b/,
+            /\breorganiz(e|es|ed|ing)\b/i,
+        ];
+        if (refactorPatterns.some(p => p.test(diff))) {
+            return 'refactor';
+        }
+        // If modifications with balanced adds/removes and no new functionality, likely refactor
+        if (hasOnlyModifications && !hasNewFunctionality) {
+            // If roughly equal adds and removes, it's likely refactoring
+            if (addedLines > 0 && removedLines > 0) {
+                const ratio = Math.min(addedLines, removedLines) / Math.max(addedLines, removedLines);
+                if (ratio > 0.5) { // More strict ratio - must be very balanced
+                    return 'refactor';
+                }
+            }
+        }
+        // === CHORE DETECTION ===
+        const chorePatterns = [
+            /\bdependenc(y|ies)\b/i,
+            /\bupgrade\b/i,
+            /\bupdate\s*(version|dep)/i,
+            /\bbump\b/i,
+            /\bpackage\.json\b/i,
+            /\bpackage-lock\.json\b/i,
+            /\byarn\.lock\b/i,
+            /\b\.gitignore\b/i,
+            /\bci\b.*\b(config|setup)\b/i,
+            /\blint(er|ing)?\b/i,
+        ];
+        if (chorePatterns.some(p => p.test(diff)) || chorePatterns.some(p => filePaths.some(f => p.test(f)))) {
+            return 'chore';
+        }
+        // === FALLBACK ===
+        // If we have more additions than removals, lean towards feat
+        if (filesAffected.source > 0) {
+            if (netNewLines > 10) {
+                return 'feat'; // Significant new code added
+            }
+            if (hasOnlyModifications) {
+                return 'refactor'; // Modifications without clear new functionality
+            }
+            return 'feat'; // Default for source changes with new files
+        }
+        return 'chore';
+    }
+    /**
+     * Check if diff contains actual logic changes (not just formatting)
+     */
+    static hasLogicChanges(diff) {
+        // Remove formatting-only changes and check if there's real code
+        const lines = diff.split('\n').filter(line => (line.startsWith('+') || line.startsWith('-')) &&
+            !line.startsWith('+++') &&
+            !line.startsWith('---'));
+        for (const line of lines) {
+            const content = line.substring(1).trim();
+            // Skip empty lines, comments, and whitespace-only
+            if (content.length === 0 ||
+                content.startsWith('//') ||
+                content.startsWith('/*') ||
+                content.startsWith('*') ||
+                content === '{' ||
+                content === '}' ||
+                content === ';') {
+                continue;
+            }
+            // Has actual code change
+            return true;
+        }
+        return false;
+    }
+    /**
+     * Check if the diff contains ONLY formatting changes (no logic impact).
+     * Formatting changes include: semicolons, blank lines, indentation, trailing commas, braces.
+     * Per Conventional Commits, these should be classified as "style".
+     */
+    static isFormattingOnlyChange(diff) {
+        const lines = diff.split('\n').filter(line => (line.startsWith('+') || line.startsWith('-')) &&
+            !line.startsWith('+++') &&
+            !line.startsWith('---'));
+        if (lines.length === 0) {
+            return false;
+        }
+        // Pair up removed and added lines to detect indentation-only changes
+        const removed = [];
+        const added = [];
+        for (const line of lines) {
+            const content = line.substring(1);
+            const trimmed = content.trim();
+            // Empty / whitespace-only lines are always formatting
+            if (trimmed.length === 0) {
+                continue;
+            }
+            // Standalone semicolons, braces, trailing commas are formatting
+            if (trimmed === ';' || trimmed === '{' || trimmed === '}' || trimmed === ',') {
+                continue;
+            }
+            // Collect lines for indentation-only and semicolon-only comparison
+            if (line.startsWith('-')) {
+                removed.push(trimmed);
+            }
+            else {
+                added.push(trimmed);
+            }
+        }
+        // If no added/removed content lines remain, it's purely blank line changes
+        if (removed.length === 0 && added.length === 0) {
+            return true;
+        }
+        // Check if each added line corresponds to a removed line that differs only by
+        // formatting (trailing semicolons, trailing commas, whitespace)
+        if (removed.length !== added.length) {
+            return false;
+        }
+        for (let i = 0; i < removed.length; i++) {
+            // Normalize: strip trailing semicolons, commas, and whitespace
+            const normalizeFormatting = (s) => s.replace(/[;\s,]+$/g, '').replace(/^\s+/, '');
+            const normRemoved = normalizeFormatting(removed[i]);
+            const normAdded = normalizeFormatting(added[i]);
+            if (normRemoved !== normAdded) {
+                return false;
+            }
+        }
+        return true;
+    }
+    /**
+     * Generate a description for formatting-only changes
+     */
+    static generateFormattingDescription(diff, stagedFiles) {
+        const lines = diff.split('\n').filter(line => (line.startsWith('+') || line.startsWith('-')) &&
+            !line.startsWith('+++') &&
+            !line.startsWith('---'));
+        let hasSemicolonChanges = false;
+        let hasBlankLineChanges = false;
+        let hasIndentationChanges = false;
+        let hasBraceChanges = false;
+        let hasTrailingCommaChanges = false;
+        const removed = [];
+        const added = [];
+        for (const line of lines) {
+            const trimmed = line.substring(1).trim();
+            if (trimmed.length === 0) {
+                hasBlankLineChanges = true;
+                continue;
+            }
+            if (trimmed === ';') {
+                hasSemicolonChanges = true;
+                continue;
+            }
+            if (trimmed === '{' || trimmed === '}') {
+                hasBraceChanges = true;
+                continue;
+            }
+            if (trimmed === ',') {
+                hasTrailingCommaChanges = true;
+                continue;
+            }
+            if (line.startsWith('-')) {
+                removed.push(trimmed);
+            }
+            else {
+                added.push(trimmed);
+            }
+        }
+        // Check paired lines for semicolon-only or indentation-only diffs
+        for (let i = 0; i < removed.length && i < added.length; i++) {
+            const r = removed[i];
+            const a = added[i];
+            // If trimmed content is identical, the only difference was indentation
+            if (r === a) {
+                hasIndentationChanges = true;
+            }
+            // Semicolon difference (one has semicolon, the other doesn't)
+            else if (r + ';' === a || a + ';' === r) {
+                hasSemicolonChanges = true;
+            }
+            // Trailing comma difference
+            else if (r + ',' === a || a + ',' === r) {
+                hasTrailingCommaChanges = true;
+            }
+            else {
+                hasIndentationChanges = true;
+            }
+        }
+        // Build description based on what changed
+        let description;
+        if (hasSemicolonChanges && !hasBlankLineChanges && !hasIndentationChanges && !hasBraceChanges && !hasTrailingCommaChanges) {
+            description = 'add missing semicolons';
+        }
+        else if (hasBlankLineChanges && !hasSemicolonChanges && !hasIndentationChanges && !hasBraceChanges && !hasTrailingCommaChanges) {
+            description = 'remove blank lines';
+        }
+        else if (hasIndentationChanges && !hasSemicolonChanges && !hasBlankLineChanges && !hasBraceChanges && !hasTrailingCommaChanges) {
+            description = 'fix indentation';
+        }
+        else if (hasBraceChanges && !hasSemicolonChanges && !hasBlankLineChanges && !hasIndentationChanges && !hasTrailingCommaChanges) {
+            description = 'fix brace formatting';
+        }
+        else if (hasTrailingCommaChanges && !hasSemicolonChanges && !hasBlankLineChanges && !hasIndentationChanges && !hasBraceChanges) {
+            description = 'fix trailing commas';
+        }
+        else {
+            description = 'fix code formatting';
+        }
+        // Append filename for single-file changes
+        if (stagedFiles.length === 1) {
+            const fileName = stagedFiles[0].path.split('/').pop() || stagedFiles[0].path;
+            description += ` in ${fileName}`;
+        }
+        return description;
+    }
+    /**
+     * Check if the changes are ONLY non-style JavaScript changes
+     * (console.log, debug statements, test prints, comments, etc.)
+     * Returns true if JS files have changes but NO actual styling changes
+     */
+    static hasOnlyNonStyleJsChanges(diff, filePaths) {
+        // Check if all files are JavaScript/TypeScript (not CSS)
+        const hasOnlyJsFiles = filePaths.every(p => p.endsWith('.js') ||
+            p.endsWith('.jsx') ||
+            p.endsWith('.ts') ||
+            p.endsWith('.tsx') ||
+            p.endsWith('.mjs') ||
+            p.endsWith('.cjs'));
+        if (!hasOnlyJsFiles) {
+            return false;
+        }
+        // Patterns that indicate NON-style changes (debug, logging, test output)
+        const nonStylePatterns = [
+            /console\.(log|debug|info|warn|error|trace|dir|table)/,
+            /debugger\b/,
+            /logger\.\w+/i,
+            /debug\s*\(/,
+            /print\s*\(/,
+            /console\.assert/,
+            /console\.time/,
+            /console\.count/,
+            /console\.group/,
+            /process\.stdout/,
+            /process\.stderr/,
+            /\.toLog\(/,
+            /\.log\(/,
+            /winston\./,
+            /pino\./,
+            /bunyan\./,
+            /log4js\./,
+        ];
+        // Get all added/changed lines
+        const changedLines = diff.split('\n').filter(line => line.startsWith('+') && !line.startsWith('+++'));
+        // If the changes match non-style patterns, return true
+        const hasNonStyleChanges = changedLines.some(line => nonStylePatterns.some(pattern => pattern.test(line)));
+        // Check if there are NO style-related patterns in the JS files
+        const stylePatterns = [
+            /styled\s*[.(]/,
+            /css\s*`/,
+            /\bstyle\s*=\s*\{\{/,
+            /className\s*=/,
+            /\bsx\s*=/,
+            /theme\./,
+            /colors\./,
+            /palette\./,
+        ];
+        const hasStylePatterns = changedLines.some(line => stylePatterns.some(pattern => pattern.test(line)));
+        // Return true only if we have non-style changes AND no style patterns
+        return hasNonStyleChanges && !hasStylePatterns;
+    }
+    /**
+     * Check if the diff contains only comment changes (documentation)
+     * Returns true if ALL changes are comments (no code changes)
+     */
+    static isCommentOnlyChange(diff) {
+        // Get all changed lines (additions and deletions)
+        const lines = diff.split('\n').filter(line => (line.startsWith('+') || line.startsWith('-')) &&
+            !line.startsWith('+++') &&
+            !line.startsWith('---'));
+        if (lines.length === 0) {
+            return false;
+        }
+        let hasCommentChanges = false;
+        for (const line of lines) {
+            const content = line.substring(1).trim();
+            // Skip empty lines
+            if (content.length === 0) {
+                continue;
+            }
+            // Check if line is a comment
+            const isComment = content.startsWith('//') || // Single-line comment
+                content.startsWith('/*') || // Multi-line comment start
+                content.startsWith('*') || // Multi-line comment body
+                content.startsWith('*/') || // Multi-line comment end
+                content.startsWith('#') || // Shell/Python/Ruby comments
+                content.startsWith('<!--') || // HTML comments
+                content.startsWith('-->') || // HTML comment end
+                content.startsWith('"""') || // Python docstring
+                content.startsWith("'''") || // Python docstring
+                /^\/\*\*/.test(content) || // JSDoc start
+                /^\*\s*@\w+/.test(content); // JSDoc tag
+            if (isComment) {
+                hasCommentChanges = true;
+            }
+            else {
+                // Found a non-comment change - not a comment-only diff
+                return false;
+            }
+        }
+        return hasCommentChanges;
+    }
+    /**
+     * Perform semantic analysis on the diff to understand the nature of changes
+     * This provides intent-based understanding rather than line-count metrics
+     */
+    static analyzeSemanticChanges(diff, stagedFiles) {
+        const roleChanges = this.detectRoleChanges(diff, stagedFiles);
+        const primaryRole = this.determinePrimaryRole(roleChanges);
+        let primaryIntent = this.determineIntent(diff, stagedFiles, roleChanges);
+        const affectedElements = this.extractAffectedElements(diff);
+        // Detect renames - this takes priority for determining intent
+        const renames = this.detectRenames(diff);
+        if (renames.length > 0) {
+            primaryIntent = 'rename';
+        }
+        // Generate human-readable descriptions
+        const intentDescription = this.generateIntentDescription(primaryIntent, primaryRole, roleChanges);
+        const whatChanged = renames.length > 0
+            ? `${renames[0].oldName} to ${renames[0].newName}`
+            : this.generateWhatChanged(roleChanges, affectedElements, stagedFiles);
+        return {
+            primaryRole,
+            primaryIntent,
+            roleChanges,
+            intentDescription,
+            whatChanged,
+            hasMultipleRoles: roleChanges.filter(r => r.significance > 20).length > 1,
+            renames: renames.length > 0 ? renames : undefined,
+        };
+    }
+    /**
+     * Detect which roles are affected by the changes and calculate semantic significance
+     * Significance is NOT based on line count - it's based on the semantic weight of patterns
+     */
+    static detectRoleChanges(diff, _stagedFiles) {
+        const roleChanges = [];
+        // Check each role for matches
+        for (const [role, patterns] of Object.entries(ROLE_PATTERNS)) {
+            if (role === 'unknown' || patterns.length === 0)
+                continue;
+            let matchCount = 0;
+            let highValueMatches = 0;
+            for (const pattern of patterns) {
+                pattern.lastIndex = 0;
+                const matches = diff.match(pattern);
+                if (matches) {
+                    matchCount += matches.length;
+                    // Some patterns indicate more significant changes
+                    if (this.isHighValuePattern(pattern, role)) {
+                        highValueMatches += matches.length;
+                    }
+                }
+            }
+            if (matchCount > 0) {
+                // Calculate significance based on pattern matches, not line counts
+                // High-value patterns contribute more to significance
+                const baseSignificance = Math.min(matchCount * 10, 40);
+                const highValueBonus = highValueMatches * 15;
+                const significance = Math.min(baseSignificance + highValueBonus, 100);
+                const intent = this.detectRoleIntent(diff, role);
+                const summary = this.generateRoleSummary(role, intent, matchCount);
+                roleChanges.push({
+                    role,
+                    intent,
+                    significance,
+                    summary,
+                    affectedElements: this.extractElementsForRole(diff, role),
+                });
+            }
+        }
+        // Sort by significance (highest first)
+        return roleChanges.sort((a, b) => b.significance - a.significance);
+    }
+    /**
+     * Determine if a pattern represents a high-value semantic change
+     */
+    static isHighValuePattern(pattern, role) {
+        const patternStr = pattern.source;
+        // High-value patterns for each role
+        const highValueIndicators = {
+            ui: ['<[A-Z]', 'className', 'onClick', 'onSubmit', 'aria-'],
+            logic: ['function', 'class', 'if\\s*\\(', 'switch', 'try\\s*\\{', 'throw'],
+            data: ['useState', 'useReducer', 'interface', 'type\\s+\\w+'],
+            style: ['styled\\.', 'css`', 'theme\\.'],
+            api: ['fetch\\s*\\(', 'axios', 'useQuery', 'useMutation', 'graphql'],
+            config: ['process\\.env', 'CONFIG\\.', 'export\\s+(const|let)\\s+[A-Z_]+'],
+            test: ['describe\\s*\\(', 'it\\s*\\(', 'test\\s*\\(', 'expect\\s*\\('],
+            unknown: [],
+        };
+        return highValueIndicators[role].some(indicator => patternStr.includes(indicator));
+    }
+    /**
+     * Detect the intent for changes in a specific role
+     */
+    static detectRoleIntent(diff, _role) {
+        // Check for intent patterns (role context reserved for future use)
+        const addedLines = (diff.match(/^\+[^+]/gm) || []).length;
+        const removedLines = (diff.match(/^-[^-]/gm) || []).length;
+        // Check for add patterns in this role's context
+        for (const pattern of INTENT_PATTERNS.add) {
+            if (pattern.test(diff)) {
+                // If adding new constructs, it's an 'add' intent
+                return 'add';
+            }
+        }
+        // Check for remove patterns
+        for (const pattern of INTENT_PATTERNS.remove) {
+            if (pattern.test(diff)) {
+                return 'remove';
+            }
+        }
+        // Check for fix patterns
+        for (const pattern of INTENT_PATTERNS.fix) {
+            if (pattern.test(diff)) {
+                return 'fix';
+            }
+        }
+        // Check for enhance patterns
+        for (const pattern of INTENT_PATTERNS.enhance) {
+            if (pattern.test(diff)) {
+                return 'enhance';
+            }
+        }
+        // Determine based on add/remove ratio
+        if (addedLines > 0 && removedLines === 0) {
+            return 'add';
+        }
+        else if (removedLines > 0 && addedLines === 0) {
+            return 'remove';
+        }
+        else if (addedLines > 0 && removedLines > 0) {
+            const ratio = Math.min(addedLines, removedLines) / Math.max(addedLines, removedLines);
+            if (ratio > 0.5) {
+                return 'refactor'; // Balanced changes suggest refactoring
+            }
+            return addedLines > removedLines ? 'add' : 'modify';
+        }
+        return 'modify';
+    }
+    /**
+     * Determine the primary role from all detected role changes
+     */
+    static determinePrimaryRole(roleChanges) {
+        if (roleChanges.length === 0) {
+            return 'unknown';
+        }
+        // The role with highest significance is primary
+        // But if multiple roles have similar significance, prefer more specific ones
+        const topRole = roleChanges[0];
+        // If there's a close second that's more specific, consider it
+        if (roleChanges.length > 1) {
+            const secondRole = roleChanges[1];
+            const significanceDiff = topRole.significance - secondRole.significance;
+            // If within 15 points and second is more specific (api > logic > ui)
+            if (significanceDiff <= 15) {
+                const specificityOrder = ['api', 'data', 'style', 'logic', 'ui', 'config', 'test', 'unknown'];
+                const topIndex = specificityOrder.indexOf(topRole.role);
+                const secondIndex = specificityOrder.indexOf(secondRole.role);
+                if (secondIndex < topIndex) {
+                    return secondRole.role;
+                }
+            }
+        }
+        return topRole.role;
+    }
+    /**
+     * Determine the overall intent of the changes
+     */
+    static determineIntent(diff, stagedFiles, roleChanges) {
+        // Check file statuses first
+        const hasOnlyAdded = stagedFiles.every(f => f.status === 'A');
+        const hasOnlyDeleted = stagedFiles.every(f => f.status === 'D');
+        const hasOnlyModified = stagedFiles.every(f => f.status === 'M');
+        if (hasOnlyAdded) {
+            return 'add';
+        }
+        if (hasOnlyDeleted) {
+            return 'remove';
+        }
+        // If we have role changes, use the most significant role's intent
+        if (roleChanges.length > 0) {
+            const primaryRoleChange = roleChanges[0];
+            // Special case: if the primary intent is 'fix' and we see validation patterns
+            // even in non-modified files, treat it as a fix
+            if (hasOnlyModified && primaryRoleChange.intent === 'fix') {
+                return 'fix';
+            }
+            // If we're enhancing (useMemo, useCallback, etc.), that takes precedence
+            if (roleChanges.some(r => r.intent === 'enhance')) {
+                return 'enhance';
+            }
+            return primaryRoleChange.intent;
+        }
+        // Fallback to diff analysis
+        const addedLines = (diff.match(/^\+[^+]/gm) || []).length;
+        const removedLines = (diff.match(/^-[^-]/gm) || []).length;
+        if (addedLines > 0 && removedLines === 0) {
+            return 'add';
+        }
+        if (removedLines > 0 && addedLines === 0) {
+            return 'remove';
+        }
+        const ratio = Math.min(addedLines, removedLines) / Math.max(addedLines, removedLines);
+        if (ratio > 0.6) {
+            return 'refactor';
+        }
+        return 'modify';
+    }
+    /**
+     * Extract affected element names (components, functions, etc.) from the diff
+     */
+    static extractAffectedElements(diff) {
+        const elements = [];
+        // Extract component names (React/JSX)
+        const componentMatches = diff.match(/^\+.*(?:function|const)\s+([A-Z][a-zA-Z0-9]*)/gm);
+        if (componentMatches) {
+            for (const match of componentMatches) {
+                const nameMatch = match.match(/(?:function|const)\s+([A-Z][a-zA-Z0-9]*)/);
+                if (nameMatch) {
+                    elements.push(nameMatch[1]);
+                }
+            }
+        }
+        // Extract function names
+        const functionMatches = diff.match(/^\+.*(?:function|const)\s+([a-z][a-zA-Z0-9]*)\s*[=(]/gm);
+        if (functionMatches) {
+            for (const match of functionMatches) {
+                const nameMatch = match.match(/(?:function|const)\s+([a-z][a-zA-Z0-9]*)/);
+                if (nameMatch && !elements.includes(nameMatch[1])) {
+                    elements.push(nameMatch[1]);
+                }
+            }
+        }
+        // Extract interface/type names
+        const typeMatches = diff.match(/^\+.*(?:interface|type)\s+([A-Z][a-zA-Z0-9]*)/gm);
+        if (typeMatches) {
+            for (const match of typeMatches) {
+                const nameMatch = match.match(/(?:interface|type)\s+([A-Z][a-zA-Z0-9]*)/);
+                if (nameMatch && !elements.includes(nameMatch[1])) {
+                    elements.push(nameMatch[1]);
+                }
+            }
+        }
+        // Extract class names
+        const classMatches = diff.match(/^\+.*class\s+([A-Z][a-zA-Z0-9]*)/gm);
+        if (classMatches) {
+            for (const match of classMatches) {
+                const nameMatch = match.match(/class\s+([A-Z][a-zA-Z0-9]*)/);
+                if (nameMatch && !elements.includes(nameMatch[1])) {
+                    elements.push(nameMatch[1]);
+                }
+            }
+        }
+        return elements.slice(0, 5); // Limit to top 5 elements
+    }
+    /**
+     * Detect function/class/type renames by comparing removed and added names
+     * Returns an array of { oldName, newName } objects
+     */
+    static detectRenames(diff) {
+        const renames = [];
+        // Patterns for extracting function/class/type names from removed and added lines
+        const patterns = [
+            // Function declarations: function name( or const name = or const name: Type =
+            { regex: /^[-+].*(?:function)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/gm, type: 'function' },
+            { regex: /^[-+].*(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*[=:]/gm, type: 'function' },
+            // Class declarations
+            { regex: /^[-+].*class\s+([A-Z][a-zA-Z0-9]*)/gm, type: 'class' },
+            // Interface declarations
+            { regex: /^[-+].*interface\s+([A-Z][a-zA-Z0-9]*)/gm, type: 'interface' },
+            // Type declarations
+            { regex: /^[-+].*type\s+([A-Z][a-zA-Z0-9]*)\s*=/gm, type: 'type' },
+        ];
+        for (const { regex, type } of patterns) {
+            const removed = [];
+            const added = [];
+            let match;
+            regex.lastIndex = 0;
+            while ((match = regex.exec(diff)) !== null) {
+                const line = match[0];
+                const name = match[1];
+                if (line.startsWith('-') && !line.startsWith('---')) {
+                    removed.push(name);
+                }
+                else if (line.startsWith('+') && !line.startsWith('+++')) {
+                    added.push(name);
+                }
+            }
+            // If we have exactly one removed and one added of the same type,
+            // and they're different names, it's likely a rename
+            if (removed.length === 1 && added.length === 1 && removed[0] !== added[0]) {
+                renames.push({ oldName: removed[0], newName: added[0], type });
+            }
+        }
+        return renames;
+    }
+    /**
+     * Extract affected elements for a specific role
+     */
+    static extractElementsForRole(diff, role) {
+        const elements = [];
+        switch (role) {
+            case 'ui':
+                // Extract JSX component names being used
+                const jsxMatches = diff.match(/^\+.*<([A-Z][a-zA-Z0-9]*)/gm);
+                if (jsxMatches) {
+                    for (const match of jsxMatches) {
+                        const nameMatch = match.match(/<([A-Z][a-zA-Z0-9]*)/);
+                        if (nameMatch && !elements.includes(nameMatch[1])) {
+                            elements.push(nameMatch[1]);
+                        }
+                    }
+                }
+                break;
+            case 'data':
+                // Extract state variable names
+                const stateMatches = diff.match(/^\+.*const\s+\[([a-z][a-zA-Z0-9]*),/gm);
+                if (stateMatches) {
+                    for (const match of stateMatches) {
+                        const nameMatch = match.match(/const\s+\[([a-z][a-zA-Z0-9]*)/);
+                        if (nameMatch) {
+                            elements.push(nameMatch[1]);
+                        }
+                    }
+                }
+                break;
+            case 'api':
+                // Extract API endpoints
+                const apiMatches = diff.match(/['"`]\/api\/[^'"`]+['"`]/g);
+                if (apiMatches) {
+                    elements.push(...apiMatches.map(m => m.replace(/['"`]/g, '')));
+                }
+                break;
+            default:
+                // Use generic extraction
+                return this.extractAffectedElements(diff).slice(0, 3);
+        }
+        return elements.slice(0, 3);
+    }
+    /**
+     * Generate a human-readable summary for a role change
+     */
+    static generateRoleSummary(role, intent, matchCount) {
+        const roleDesc = ROLE_DESCRIPTIONS[role];
+        const intentVerb = INTENT_VERBS[intent].past;
+        if (matchCount === 1) {
+            return `${intentVerb} ${roleDesc}`;
+        }
+        return `${intentVerb} ${roleDesc} (${matchCount} changes)`;
+    }
+    /**
+     * Generate the WHY description for the commit
+     */
+    static generateIntentDescription(intent, role, roleChanges) {
+        const roleDesc = ROLE_DESCRIPTIONS[role];
+        switch (intent) {
+            case 'add':
+                return `to add new ${roleDesc}`;
+            case 'fix':
+                return `to fix ${roleDesc} issues`;
+            case 'refactor':
+                return `to improve ${roleDesc} structure`;
+            case 'enhance':
+                return `to optimize ${roleDesc} performance`;
+            case 'remove':
+                return `to remove unused ${roleDesc}`;
+            case 'modify':
+            default:
+                if (roleChanges.length > 1) {
+                    return `to update ${roleDesc} and related code`;
+                }
+                return `to update ${roleDesc}`;
+        }
+    }
+    /**
+     * Generate the WHAT changed description
+     */
+    static generateWhatChanged(roleChanges, affectedElements, stagedFiles) {
+        // If we have specific elements, use them
+        if (affectedElements.length > 0) {
+            if (affectedElements.length === 1) {
+                return affectedElements[0];
+            }
+            if (affectedElements.length <= 3) {
+                return affectedElements.join(', ');
+            }
+            return `${affectedElements.slice(0, 2).join(', ')} and ${affectedElements.length - 2} more`;
+        }
+        // Fall back to role-based description
+        if (roleChanges.length > 0) {
+            const primaryRole = roleChanges[0];
+            if (primaryRole.affectedElements.length > 0) {
+                return primaryRole.affectedElements[0];
+            }
+            return ROLE_DESCRIPTIONS[primaryRole.role];
+        }
+        // Fall back to file names
+        if (stagedFiles.length === 1) {
+            const parts = stagedFiles[0].path.split('/');
+            return parts[parts.length - 1].replace(/\.\w+$/, '');
+        }
+        return 'code';
+    }
+    /**
+     * Generate a descriptive commit message
+     * Uses semantic analysis when available for intent-based descriptions
+     */
+    static generateDescription(filesAffected, fileStatuses, stagedFiles, diff, semanticAnalysis) {
+        // Check for comment-only changes (documentation in source files)
+        if (this.isCommentOnlyChange(diff)) {
+            const fileName = stagedFiles.length === 1 ? this.getFileName(stagedFiles[0].path) : null;
+            // Detect type of comments being added
+            const hasJSDoc = /^\+\s*\/\*\*/.test(diff) || /^\+\s*\*\s*@\w+/.test(diff);
+            const hasFunctionComments = /^\+\s*\/\/.*\b(function|method|param|return|arg)/i.test(diff);
+            if (hasJSDoc) {
+                return fileName ? `add JSDoc comments to ${fileName}` : 'add JSDoc documentation';
+            }
+            else if (hasFunctionComments) {
+                return fileName ? `add function documentation to ${fileName}` : 'add function documentation';
+            }
+            else {
+                return fileName ? `add comments to ${fileName}` : 'add code comments';
+            }
+        }
+        // Check for formatting-only changes (semicolons, whitespace, etc.)
+        if (this.isFormattingOnlyChange(diff)) {
+            return this.generateFormattingDescription(diff, stagedFiles);
+        }
+        // Use semantic analysis for intent-based descriptions when available
+        if (semanticAnalysis && semanticAnalysis.roleChanges.length > 0) {
+            return this.generateSemanticDescription(semanticAnalysis, stagedFiles);
+        }
+        // Single file changes (fallback)
+        if (stagedFiles.length === 1) {
+            const file = stagedFiles[0];
+            const fileName = this.getFileName(file.path);
+            if (file.status === 'A') {
+                return `add ${fileName}`;
+            }
+            else if (file.status === 'D') {
+                return `remove ${fileName}`;
+            }
+            else if (file.status === 'M') {
+                return `update ${fileName}`;
+            }
+            else if (file.status === 'R') {
+                return `rename ${fileName}`;
+            }
+        }
+        // Multiple files of the same type
+        if (filesAffected.test > 0 && filesAffected.source === 0) {
+            return `update test files`;
+        }
+        if (filesAffected.docs > 0 && filesAffected.source === 0) {
+            return `update documentation`;
+        }
+        if (filesAffected.config > 0 && filesAffected.source === 0) {
+            return `update configuration`;
+        }
+        // Mixed changes - try to be descriptive
+        const parts = [];
+        if (fileStatuses.added > 0) {
+            parts.push(`add ${fileStatuses.added} file${fileStatuses.added > 1 ? 's' : ''}`);
+        }
+        if (fileStatuses.modified > 0) {
+            if (parts.length === 0) {
+                parts.push(`update ${fileStatuses.modified} file${fileStatuses.modified > 1 ? 's' : ''}`);
+            }
+        }
+        if (fileStatuses.deleted > 0) {
+            parts.push(`remove ${fileStatuses.deleted} file${fileStatuses.deleted > 1 ? 's' : ''}`);
+        }
+        if (parts.length > 0) {
+            return parts.join(' and ');
+        }
+        // Fallback
+        return `update ${stagedFiles.length} file${stagedFiles.length > 1 ? 's' : ''}`;
+    }
+    /**
+     * Generate description based on semantic analysis
+     * Creates intent-based messages like "update UserProfile validation logic"
+     */
+    static generateSemanticDescription(semantic, stagedFiles) {
+        const intent = semantic.primaryIntent;
+        const role = semantic.primaryRole;
+        const verb = INTENT_VERBS[intent].present;
+        const roleDesc = ROLE_DESCRIPTIONS[role];
+        // Handle renames specially - use "rename X to Y" format
+        if (intent === 'rename' && semantic.renames && semantic.renames.length > 0) {
+            const rename = semantic.renames[0];
+            return `${verb} ${rename.oldName} to ${rename.newName}`;
+        }
+        // If we have specific elements affected, include them
+        const whatChanged = semantic.whatChanged;
+        // For single file with identified elements
+        if (stagedFiles.length === 1 && whatChanged && whatChanged !== 'code') {
+            // Check if whatChanged is a component/function name
+            if (/^[A-Z][a-zA-Z0-9]*$/.test(whatChanged)) {
+                // It's a component name
+                return `${verb} ${whatChanged} ${roleDesc}`;
+            }
+            if (/^[a-z][a-zA-Z0-9]*$/.test(whatChanged)) {
+                // It's a function name
+                return `${verb} ${whatChanged} ${roleDesc}`;
+            }
+            // Multiple elements or descriptive text
+            return `${verb} ${whatChanged}`;
+        }
+        // For multiple files or when we only have role info
+        if (semantic.hasMultipleRoles) {
+            // Changes span multiple concerns
+            const roles = semantic.roleChanges
+                .filter(r => r.significance > 20)
+                .slice(0, 2)
+                .map(r => ROLE_DESCRIPTIONS[r.role]);
+            if (roles.length > 1) {
+                return `${verb} ${roles.join(' and ')}`;
+            }
+        }
+        // Single role with file context
+        if (stagedFiles.length === 1) {
+            const fileName = this.getFileName(stagedFiles[0].path).replace(/\.\w+$/, '');
+            return `${verb} ${fileName} ${roleDesc}`;
+        }
+        // Multiple files, same role
+        return `${verb} ${roleDesc}`;
+    }
+    /**
+     * Determine scope from file paths
+     */
+    static determineScope(stagedFiles) {
+        if (stagedFiles.length === 0)
+            return undefined;
+        const config = configService_1.ConfigService.getConfig();
+        const paths = stagedFiles.map((f) => f.path);
+        // Check config-based scope mappings first
+        if (config.scopes && config.scopes.length > 0) {
+            for (const mapping of config.scopes) {
+                const matchingFiles = paths.filter((p) => p.includes(mapping.pattern));
+                if (matchingFiles.length === paths.length) {
+                    return mapping.scope;
+                }
+            }
+            // If most files match a pattern, use that scope
+            for (const mapping of config.scopes) {
+                const matchingFiles = paths.filter((p) => p.includes(mapping.pattern));
+                if (matchingFiles.length > paths.length / 2) {
+                    return mapping.scope;
+                }
+            }
+        }
+        // Fallback to default heuristic
+        const firstPath = paths[0];
+        const parts = firstPath.split('/');
+        if (parts.length > 1) {
+            const potentialScope = parts[0];
+            // Common scope names to look for
+            const validScopes = [
+                'api',
+                'ui',
+                'auth',
+                'db',
+                'core',
+                'utils',
+                'components',
+                'services',
+            ];
+            if (validScopes.includes(potentialScope.toLowerCase())) {
+                return potentialScope;
+            }
+        }
+        return undefined;
+    }
+    /**
+     * Extract file name from path
+     */
+    static getFileName(path) {
+        const parts = path.split('/');
+        return parts[parts.length - 1];
+    }
+    /**
+     * Generate commit body for larger changes
+     * Includes semantic role context when available
+     */
+    static generateBody(analysis) {
+        const lines = [];
+        const semantic = analysis.semanticAnalysis;
+        // Include semantic context (WHY the change was made) for multi-role changes
+        if (semantic && semantic.hasMultipleRoles) {
+            lines.push('Changes:');
+            for (const roleChange of semantic.roleChanges.filter(r => r.significance > 15).slice(0, 4)) {
+                const elements = roleChange.affectedElements.length > 0
+                    ? ` (${roleChange.affectedElements.slice(0, 2).join(', ')})`
+                    : '';
+                lines.push(`- ${roleChange.summary}${elements}`);
+            }
+            lines.push('');
+        }
+        // Only add file details for truly large changes
+        if (!analysis.isLargeChange && lines.length === 0) {
+            return undefined;
+        }
+        // Add file change details for large changes
+        if (analysis.isLargeChange) {
+            if (lines.length > 0) {
+                lines.push('Files:');
+            }
+            if (analysis.fileChanges.added.length > 0) {
+                lines.push(`- Add ${analysis.fileChanges.added.join(', ')}`);
+            }
+            if (analysis.fileChanges.modified.length > 0) {
+                const files = analysis.fileChanges.modified.slice(0, 5);
+                const suffix = analysis.fileChanges.modified.length > 5
+                    ? ` and ${analysis.fileChanges.modified.length - 5} more`
+                    : '';
+                lines.push(`- Update ${files.join(', ')}${suffix}`);
+            }
+            if (analysis.fileChanges.deleted.length > 0) {
+                lines.push(`- Remove ${analysis.fileChanges.deleted.join(', ')}`);
+            }
+            if (analysis.fileChanges.renamed.length > 0) {
+                lines.push(`- Rename ${analysis.fileChanges.renamed.join(', ')}`);
+            }
+        }
+        return lines.length > 0 ? lines.join('\n') : undefined;
+    }
+    /**
+     * Apply a template to build the commit message subject line
+     */
+    static applyTemplate(template, type, scope, description, includeEmoji, isBreaking) {
+        const emoji = includeEmoji ? COMMIT_EMOJIS[type] : '';
+        const breakingIndicator = isBreaking ? '!' : '';
+        let result = template
+            .replace('{emoji}', emoji)
+            .replace('{type}', type + breakingIndicator)
+            .replace('{description}', description);
+        // Handle scope - if no scope, use noScope template or remove scope placeholder
+        if (scope) {
+            result = result.replace('{scope}', scope);
+        }
+        else {
+            // Remove scope and parentheses if no scope
+            result = result.replace('({scope})', '').replace('{scope}', '');
+        }
+        // Clean up extra spaces
+        result = result.replace(/\s+/g, ' ').trim();
+        return result;
+    }
+    /**
+     * Build full commit message string
+     */
+    static buildFullMessage(type, scope, description, body, includeEmoji, ticketInfo, isBreaking, breakingReasons) {
+        const config = configService_1.ConfigService.getConfig();
+        const includeBreakingFooter = config.breakingChangeDetection?.includeFooter !== false;
+        const templates = config.templates;
+        let full = '';
+        // Use template if available
+        if (templates) {
+            const template = scope
+                ? (templates.default || '{emoji} {type}({scope}): {description}')
+                : (templates.noScope || '{emoji} {type}: {description}');
+            full = this.applyTemplate(template, type, scope, description, includeEmoji, isBreaking);
+        }
+        else {
+            // Fallback to original logic
+            if (includeEmoji) {
+                full += `${COMMIT_EMOJIS[type]} `;
+            }
+            full += type;
+            if (scope) {
+                full += `(${scope})`;
+            }
+            // Add breaking change indicator
+            if (isBreaking) {
+                full += '!';
+            }
+            full += `: ${description}`;
+        }
+        if (body) {
+            full += `\n\n${body}`;
+        }
+        // Add BREAKING CHANGE footer if enabled and breaking
+        if (isBreaking && includeBreakingFooter && breakingReasons && breakingReasons.length > 0) {
+            full += '\n\nBREAKING CHANGE: ' + breakingReasons[0];
+            if (breakingReasons.length > 1) {
+                for (let i = 1; i < breakingReasons.length; i++) {
+                    full += `\n- ${breakingReasons[i]}`;
+                }
+            }
+        }
+        // Add ticket reference as footer
+        if (ticketInfo) {
+            const prefix = ticketInfo.prefix || 'Refs:';
+            full += `\n\n${prefix} ${ticketInfo.id}`;
+        }
+        return full;
+    }
+    /**
+     * Generate the final commit message
+     */
+    static generateCommitMessage() {
+        const analysis = this.analyzeChanges();
+        const config = configService_1.ConfigService.getConfig();
+        // Determine emoji usage: config overrides, then history learning
+        let includeEmoji = config.includeEmoji;
+        if (includeEmoji === undefined) {
+            includeEmoji = historyService_1.HistoryService.projectUsesEmojis();
+        }
+        const body = this.generateBody(analysis);
+        const ticketInfo = historyService_1.HistoryService.detectTicketFromBranch();
+        const full = this.buildFullMessage(analysis.commitType, analysis.scope, analysis.description, body, includeEmoji, ticketInfo, analysis.isBreakingChange, analysis.breakingChangeReasons);
+        return {
+            type: analysis.commitType,
+            scope: analysis.scope,
+            description: analysis.description,
+            body,
+            full,
+            isBreaking: analysis.isBreakingChange,
+        };
+    }
+    /**
+     * Generate multiple message suggestions
+     */
+    static generateMultipleSuggestions() {
+        const analysis = this.analyzeChanges();
+        const config = configService_1.ConfigService.getConfig();
+        // Determine emoji usage: config overrides, then history learning
+        let includeEmoji = config.includeEmoji;
+        if (includeEmoji === undefined) {
+            includeEmoji = historyService_1.HistoryService.projectUsesEmojis();
+        }
+        const suggestions = [];
+        const body = this.generateBody(analysis);
+        const ticketInfo = historyService_1.HistoryService.detectTicketFromBranch();
+        const { isBreakingChange, breakingChangeReasons } = analysis;
+        // Try to get a better scope from history if none detected
+        let scope = analysis.scope;
+        if (!scope) {
+            const stagedFiles = gitService_1.GitService.getStagedFiles();
+            const filePaths = stagedFiles.map(f => f.path);
+            scope = historyService_1.HistoryService.getSuggestedScope(filePaths);
+        }
+        // Suggestion 1: Default (with scope if detected, with ticket, with breaking change)
+        const defaultFull = this.buildFullMessage(analysis.commitType, scope, analysis.description, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+        suggestions.push({
+            id: 1,
+            label: isBreakingChange ? 'Breaking Change' : 'Recommended',
+            message: {
+                type: analysis.commitType,
+                scope: scope,
+                description: analysis.description,
+                body,
+                full: defaultFull,
+                isBreaking: isBreakingChange,
+            },
+        });
+        // Suggestion 2: Without scope (more concise)
+        if (scope) {
+            const noScopeFull = this.buildFullMessage(analysis.commitType, undefined, analysis.description, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+            suggestions.push({
+                id: 2,
+                label: 'Concise',
+                message: {
+                    type: analysis.commitType,
+                    scope: undefined,
+                    description: analysis.description,
+                    body,
+                    full: noScopeFull,
+                    isBreaking: isBreakingChange,
+                },
+            });
+        }
+        // Suggestion 3: Alternative description style
+        const altDescription = this.generateAlternativeDescription(analysis);
+        if (altDescription && altDescription !== analysis.description) {
+            const altFull = this.buildFullMessage(analysis.commitType, scope, altDescription, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+            suggestions.push({
+                id: suggestions.length + 1,
+                label: 'Detailed',
+                message: {
+                    type: analysis.commitType,
+                    scope: scope,
+                    description: altDescription,
+                    body,
+                    full: altFull,
+                    isBreaking: isBreakingChange,
+                },
+            });
+        }
+        // Suggestion 4: Without body (compact) - only if body exists
+        if (body) {
+            const compactFull = this.buildFullMessage(analysis.commitType, scope, analysis.description, undefined, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+            suggestions.push({
+                id: suggestions.length + 1,
+                label: 'Compact',
+                message: {
+                    type: analysis.commitType,
+                    scope: scope,
+                    description: analysis.description,
+                    body: undefined,
+                    full: compactFull,
+                    isBreaking: isBreakingChange,
+                },
+            });
+        }
+        // Suggestion 5: Without ticket reference (if ticket was detected)
+        if (ticketInfo) {
+            const noTicketFull = this.buildFullMessage(analysis.commitType, scope, analysis.description, body, includeEmoji, null, isBreakingChange, breakingChangeReasons);
+            suggestions.push({
+                id: suggestions.length + 1,
+                label: 'No Ticket',
+                message: {
+                    type: analysis.commitType,
+                    scope: scope,
+                    description: analysis.description,
+                    body,
+                    full: noTicketFull,
+                    isBreaking: isBreakingChange,
+                },
+            });
+        }
+        // Suggestion 6: Without breaking change indicator (if breaking change detected)
+        if (isBreakingChange) {
+            const noBreakingFull = this.buildFullMessage(analysis.commitType, scope, analysis.description, body, includeEmoji, ticketInfo, false, []);
+            suggestions.push({
+                id: suggestions.length + 1,
+                label: 'No Breaking Flag',
+                message: {
+                    type: analysis.commitType,
+                    scope: scope,
+                    description: analysis.description,
+                    body,
+                    full: noBreakingFull,
+                    isBreaking: false,
+                },
+            });
+        }
+        return suggestions;
+    }
+    /**
+     * Generate suggestions with optional AI enhancement
+     */
+    static async generateSuggestionsWithAI(useAI = false) {
+        const suggestions = this.generateMultipleSuggestions();
+        // If AI is not requested or not enabled, return regular suggestions
+        if (!useAI || !aiService_1.AIService.isEnabled()) {
+            return suggestions;
+        }
+        try {
+            const analysis = this.analyzeChanges();
+            const diff = gitService_1.GitService.getDiff();
+            const config = configService_1.ConfigService.getConfig();
+            // Determine emoji usage
+            let includeEmoji = config.includeEmoji;
+            if (includeEmoji === undefined) {
+                includeEmoji = historyService_1.HistoryService.projectUsesEmojis();
+            }
+            const body = this.generateBody(analysis);
+            const ticketInfo = historyService_1.HistoryService.detectTicketFromBranch();
+            const { isBreakingChange, breakingChangeReasons } = analysis;
+            // Get scope
+            let scope = analysis.scope;
+            if (!scope) {
+                const stagedFiles = gitService_1.GitService.getStagedFiles();
+                const filePaths = stagedFiles.map(f => f.path);
+                scope = historyService_1.HistoryService.getSuggestedScope(filePaths);
+            }
+            // Get AI-enhanced description
+            const aiResponse = await aiService_1.AIService.generateDescription(analysis, diff);
+            if (aiResponse && aiResponse.description) {
+                const aiDescription = aiResponse.description;
+                const aiFull = this.buildFullMessage(analysis.commitType, scope, aiDescription, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+                // Insert AI suggestion at the beginning
+                suggestions.unshift({
+                    id: 0,
+                    label: 'AI Enhanced',
+                    message: {
+                        type: analysis.commitType,
+                        scope: scope,
+                        description: aiDescription,
+                        body,
+                        full: aiFull,
+                        isBreaking: isBreakingChange,
+                    },
+                });
+                // Re-number suggestions
+                suggestions.forEach((s, i) => {
+                    s.id = i + 1;
+                });
+            }
+        }
+        catch (error) {
+            // AI failed - error already logged by AIService
+            console.log('Falling back to rule-based suggestions.\n');
+        }
+        return suggestions;
+    }
+    /**
+     * Generate an alternative description style
+     */
+    static generateAlternativeDescription(analysis) {
+        const { fileChanges, filesAffected } = analysis;
+        const totalFiles = fileChanges.added.length + fileChanges.modified.length +
+            fileChanges.deleted.length + fileChanges.renamed.length;
+        // For single file, provide more detail
+        if (totalFiles === 1) {
+            if (fileChanges.added.length === 1) {
+                return `implement ${fileChanges.added[0]}`;
+            }
+            if (fileChanges.modified.length === 1) {
+                return `improve ${fileChanges.modified[0]}`;
+            }
+        }
+        // For multiple files, be more descriptive about categories
+        const parts = [];
+        if (filesAffected.source > 0) {
+            parts.push(`${filesAffected.source} source file${filesAffected.source > 1 ? 's' : ''}`);
+        }
+        if (filesAffected.test > 0) {
+            parts.push(`${filesAffected.test} test${filesAffected.test > 1 ? 's' : ''}`);
+        }
+        if (filesAffected.docs > 0) {
+            parts.push(`${filesAffected.docs} doc${filesAffected.docs > 1 ? 's' : ''}`);
+        }
+        if (filesAffected.config > 0) {
+            parts.push(`${filesAffected.config} config${filesAffected.config > 1 ? 's' : ''}`);
+        }
+        if (parts.length > 0) {
+            return `update ${parts.join(', ')}`;
+        }
+        return analysis.description;
+    }
+}
+exports.AnalyzerService = AnalyzerService;
+//# sourceMappingURL=analyzerService.js.map