@m3hti/commit-genie 3.1.0 → 3.2.0

package/dist/services/analyzerService.js

@@ -6,28 +6,14 @@ const configService_1 = require("./configService");
 const historyService_1 = require("./historyService");
 const aiService_1 = require("./aiService");
 const filePatterns_1 = require("../utils/filePatterns");
+const commitTypeDetector_1 = require("./commitTypeDetector");
 const astExportAnalyzer_1 = require("./astExportAnalyzer");
 const astClassifier_1 = require("./astClassifier");
-const fileContentAnalyzer_1 = require("./fileContentAnalyzer");
-const COMMIT_EMOJIS = {
-    feat: '✨',
-    fix: '🐛',
-    docs: '📚',
-    style: '💄',
-    refactor: '♻️',
-    test: '🧪',
-    chore: '🔧',
-    perf: '⚡',
-};
-// Default keywords that indicate breaking changes
-// Note: generic words like "removed" are excluded to avoid false positives
-// from descriptive comments (e.g. "// Return array with zeros removed")
-const DEFAULT_BREAKING_KEYWORDS = [
-    'breaking',
-    'breaking change',
-    'breaking-change',
-    'incompatible',
-];
+const breakingChangeDetector_1 = require("./breakingChangeDetector");
+const descriptionGenerator_1 = require("./descriptionGenerator");
+const semanticAnalyzer_1 = require("./semanticAnalyzer");
+const scopeDetector_1 = require("./scopeDetector");
+const messageBuilder_1 = require("./messageBuilder");
 /**
  * Compute the aggregate export diff across all staged source files
  * using AST analysis on full file contents (before vs after).
@@ -48,186 +34,6 @@ function computeExportDiffForStagedFiles(stagedFiles) {
     }
     return { removed: allRemoved, added: allAdded };
 }
-// 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
-        /^\+.*\b(?:onClick|onSubmit|onChange|onFocus|onBlur|onKeyDown|onKeyUp|onMouseEnter|onMouseLeave)\b/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
@@ -284,22 +90,49 @@ class AnalyzerService {
         catch {
             // AST pipeline failure: fall through to regex analysis
         }
-        // Determine commit type: AST wins when it has strong signals (weight > 1)
-        // Weak signals (weight 1 only, e.g. new non-exported helper) allow regex/semantic override
-        const astMaxWeight = astResult
-            ? Math.max(...astResult.signals.map(s => s.weight), 0)
-            : 0;
+        // Determine commit type: AST is primary for parseable files, regex is fallback
+        const allParseable = stagedFiles.every(f => (0, astExportAnalyzer_1.isParseableFile)(f.path));
+        const hasParseable = stagedFiles.some(f => (0, astExportAnalyzer_1.isParseableFile)(f.path));
         let commitType;
-        if (astResult?.primaryType && astMaxWeight > 1) {
-            commitType = astResult.primaryType;
+        let classificationSource;
+        let confidence;
+        if (astResult?.primaryType) {
+            // AST produced a classification
+            if (allParseable) {
+                // Pure JS/TS commit: AST is authoritative
+                commitType = astResult.primaryType;
+                classificationSource = 'ast';
+                confidence = astResult.confidence;
+            }
+            else {
+                // Mixed commit (JS/TS + non-parseable files like CSS, MD, JSON)
+                // File-type tiers (test-only, docs-only, config-only) are more specific
+                const fileTypeResult = (0, commitTypeDetector_1.determineCommitTypeFileOnly)(filesAffected);
+                if (fileTypeResult) {
+                    commitType = fileTypeResult;
+                    classificationSource = 'file-type';
+                }
+                else {
+                    commitType = astResult.primaryType;
+                    classificationSource = 'ast';
+                    confidence = astResult.confidence;
+                }
+            }
+        }
+        else if (hasParseable && !astResult) {
+            // Parseable files exist but AST produced nothing (parse failure or zero signals)
+            commitType = (0, commitTypeDetector_1.determineCommitType)(filesAffected, diff, stagedFiles, exportDiff);
+            classificationSource = 'regex';
         }
         else {
-            commitType = this.determineCommitType(filesAffected, diff, stagedFiles, exportDiff);
+            // No parseable files at all (CSS, MD, JSON, YAML, etc.)
+            commitType = (0, commitTypeDetector_1.determineCommitType)(filesAffected, diff, stagedFiles, exportDiff);
+            classificationSource = 'regex';
         }
         // Determine scope if applicable
-        const scope = this.determineScope(stagedFiles);
+        const scope = (0, scopeDetector_1.determineScope)(stagedFiles);
         // Detect breaking changes (merge AST + regex results)
-        let { isBreaking, reasons } = this.detectBreakingChanges(diff, stagedFiles, exportDiff);
+        let { isBreaking, reasons } = (0, breakingChangeDetector_1.detectBreakingChanges)(diff, stagedFiles, exportDiff);
         if (astResult?.isBreaking) {
             isBreaking = true;
             reasons = [...new Set([...reasons, ...astResult.breakingReasons])];
@@ -308,7 +141,7 @@ class AnalyzerService {
         // 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);
+            semanticAnalysis = (0, semanticAnalyzer_1.analyzeSemanticChanges)(diff, stagedFiles);
         }
         // Non-exported renames don't break consumers — the function still exists with a new name
         // But a renamed EXPORT is breaking because consumers' import statements break
@@ -324,8 +157,8 @@ class AnalyzerService {
         // 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
-        // Skip this override if AST pipeline determined the type with strong signals
-        if (semanticAnalysis && commitType === 'feat' && astMaxWeight <= 1) {
+        // Skip this override if AST pipeline determined the type
+        if (semanticAnalysis && commitType === 'feat' && classificationSource !== 'ast') {
             const intentToType = {
                 fix: 'fix',
                 refactor: 'refactor',
@@ -337,7 +170,7 @@ class AnalyzerService {
             }
         }
         // Generate description (uses AST analysis, then semantic analysis as fallback)
-        const description = this.generateDescription(filesAffected, {
+        const description = (0, descriptionGenerator_1.generateDescription)(filesAffected, {
             added: fileChanges.added.length,
             modified: fileChanges.modified.length,
             deleted: fileChanges.deleted.length,
@@ -354,1585 +187,10 @@ class AnalyzerService {
             breakingChangeReasons: reasons,
             semanticAnalysis,
             astResult,
+            classificationSource,
+            confidence,
         };
     }
-    /**
-     * Detect breaking changes from diff content and file changes
-     */
-    static detectBreakingChanges(diff, stagedFiles, exportDiff) {
-        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 = [];
-        // Check for keyword-based breaking changes
-        // Only check against non-comment code changes to avoid false positives
-        // from descriptive comments (e.g. "// Return array with zeros removed")
-        const keywords = breakingConfig?.keywords || DEFAULT_BREAKING_KEYWORDS;
-        const codeChangesLower = this.extractNonCommentChanges(diff).toLowerCase();
-        for (const keyword of keywords) {
-            if (codeChangesLower.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}`);
-        }
-        // Export-aware breaking change detection (AST-based)
-        const addedExportNames = new Set(exportDiff.added.map(e => e.name));
-        // Exported symbols that were removed entirely (not renamed/moved)
-        const trulyRemovedExports = exportDiff.removed.filter(e => !addedExportNames.has(e.name));
-        if (trulyRemovedExports.length > 0) {
-            const names = trulyRemovedExports.map(e => e.name).join(', ');
-            reasons.push(`Removed exported members: ${names}`);
-        }
-        // Check for breaking signature changes on exported functions
-        for (const removedExport of exportDiff.removed) {
-            const matchingAdded = exportDiff.added.find(e => e.name === removedExport.name);
-            if (matchingAdded && removedExport.params && matchingAdded.params) {
-                if ((0, astExportAnalyzer_1.isSignatureBreakingAST)(removedExport.params, matchingAdded.params)) {
-                    reasons.push(`Breaking signature change on exported ${removedExport.kind}: ${removedExport.name}`);
-                }
-            }
-        }
-        // 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, exportDiff) {
-        const diffLower = diff.toLowerCase();
-        const cleanedDiff = this.extractNonCommentChanges(diff);
-        const cleanedDiffLower = cleanedDiff.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(cleanedDiffLower))) {
-            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);
-        // Detect new class/object methods - exclude control flow keywords (if, for, while, etc.)
-        // which share the `keyword(...) {` shape but are NOT method declarations
-        const hasNewMethods = /^\+\s+(async\s+)?(?!if|else|for|while|do|switch|catch|return|throw|new|typeof|instanceof|delete|void|yield|await\b)\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 (export-aware, AST-based) - CHECK BEFORE FIX ===
-        // Only treat as feat when the PUBLIC export surface grows
-        const removedExportNames = new Set(exportDiff.removed.map(e => e.name));
-        const hasNewExportedSymbols = exportDiff.added.some(e => !removedExportNames.has(e.name));
-        const hasAnyExportChanges = exportDiff.added.length > 0 || exportDiff.removed.length > 0;
-        if (hasNewFiles) {
-            return 'feat';
-        }
-        // New EXPORTED symbols = feat (public API surface grows)
-        if (hasNewExportedSymbols) {
-            return 'feat';
-        }
-        // New functions/classes that are NOT exported: internal refactoring
-        if (hasNewFunctionality && !hasNewExportedSymbols && !hasAnyExportChanges) {
-            // Balanced add/remove ratio indicates extraction/reorganization → refactor
-            if (addedLines > 0 && removedLines > 0) {
-                const ratio = Math.min(addedLines, removedLines) / Math.max(addedLines, removedLines);
-                if (ratio > 0.3) {
-                    return 'refactor';
-                }
-            }
-            // Heavily additive internal code falls through to feat patterns / fallback below
-        }
-        // 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(cleanedDiff))) {
-            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 (arr[i] <= 0)
-            /^\+.*\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(cleanedDiff))) {
-            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(cleanedDiff))) {
-            return 'refactor';
-        }
-        // If modifications with balanced adds/removes and no new functionality, likely refactor
-        // UNLESS the change modifies conditional logic (if/while/for/switch conditions),
-        // which typically alters behavior and should be treated as a fix, not a refactor
-        if (hasOnlyModifications && !hasNewFunctionality) {
-            // Check if the diff modifies conditions inside control flow statements.
-            // When both the removed and added lines contain the SAME control flow keyword
-            // but with different conditions, it's a behavioral change (fix), not a refactor.
-            const removedCondition = /^-\s*(if|while|for|switch)\s*\(/m.test(diff);
-            const addedCondition = /^\+\s*(if|while|for|switch)\s*\(/m.test(diff);
-            const isConditionChange = removedCondition && addedCondition;
-            if (isConditionChange) {
-                return 'fix';
-            }
-            // 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(cleanedDiff)) || 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;
-    }
-    /**
-     * Extract non-comment changed lines from a diff for keyword analysis.
-     * Filters out comment lines to prevent false positives from descriptive text.
-     */
-    static extractNonCommentChanges(diff) {
-        return diff.split('\n')
-            .filter(line => (line.startsWith('+') || line.startsWith('-')) &&
-            !line.startsWith('+++') &&
-            !line.startsWith('---'))
-            .map(line => line.substring(1))
-            .filter(line => {
-            const trimmed = line.trim();
-            if (trimmed.length === 0)
-                return false;
-            // Filter out comment lines
-            if (trimmed.startsWith('//') ||
-                trimmed.startsWith('/*') ||
-                trimmed.startsWith('*') ||
-                trimmed.startsWith('*/') ||
-                trimmed.startsWith('#') ||
-                trimmed.startsWith('<!--') ||
-                trimmed.startsWith('-->') ||
-                trimmed.startsWith('"""') ||
-                trimmed.startsWith("'''") ||
-                /^\/\*\*/.test(trimmed) ||
-                /^\*\s*@\w+/.test(trimmed)) {
-                return false;
-            }
-            // Filter out lines that are purely string literals
-            if (/^(?:return\s+)?(['"`]).*\1[;,]?\s*$/.test(trimmed)) {
-                return false;
-            }
-            return true;
-        })
-            .join('\n');
-    }
-    /**
-     * 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);
-        const hunkContext = this.extractHunkContext(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, hunkContext);
-        return {
-            primaryRole,
-            primaryIntent,
-            roleChanges,
-            intentDescription,
-            whatChanged,
-            hasMultipleRoles: roleChanges.filter(r => r.significance > 20).length > 1,
-            renames: renames.length > 0 ? renames : undefined,
-            hunkContext: hunkContext.length > 0 ? hunkContext : 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 = [];
-        // Helper to add unique element names
-        const addUnique = (name) => {
-            if (!elements.includes(name)) {
-                elements.push(name);
-            }
-        };
-        // Match both added (+) and modified (-) top-level declarations.
-        // For fix/refactor commits, the declaration line often appears as a removed line
-        // (the old version) or only in the - side of the diff. Using [+-] ensures we
-        // capture the affected function/class/component name regardless of whether
-        // the declaration itself was added, removed, or modified.
-        // (?!\s) after [+-] rejects indented lines (local variables inside function bodies)
-        // Extract component names (PascalCase function/const declarations)
-        const componentFuncMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([A-Z][a-zA-Z0-9]*)/gm);
-        if (componentFuncMatches) {
-            for (const match of componentFuncMatches) {
-                const nameMatch = match.match(/function\s+([A-Z][a-zA-Z0-9]*)/);
-                if (nameMatch)
-                    addUnique(nameMatch[1]);
-            }
-        }
-        const componentConstMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?const\s+([A-Z][a-zA-Z0-9]*)\s*=\s*(?:async\s+)?(?:function|\()/gm);
-        if (componentConstMatches) {
-            for (const match of componentConstMatches) {
-                const nameMatch = match.match(/const\s+([A-Z][a-zA-Z0-9]*)/);
-                if (nameMatch)
-                    addUnique(nameMatch[1]);
-            }
-        }
-        // Extract function names (camelCase declarations)
-        const funcKeywordMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([a-z][a-zA-Z0-9]*)\s*\(/gm);
-        if (funcKeywordMatches) {
-            for (const match of funcKeywordMatches) {
-                const nameMatch = match.match(/function\s+([a-z][a-zA-Z0-9]*)/);
-                if (nameMatch)
-                    addUnique(nameMatch[1]);
-            }
-        }
-        // const/let arrow or function expression: const foo = (, export const foo = async (
-        const funcConstMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?const\s+([a-z][a-zA-Z0-9]*)\s*=\s*(?:async\s+)?(?:function|\()/gm);
-        if (funcConstMatches) {
-            for (const match of funcConstMatches) {
-                const nameMatch = match.match(/const\s+([a-z][a-zA-Z0-9]*)/);
-                if (nameMatch)
-                    addUnique(nameMatch[1]);
-            }
-        }
-        // Extract interface/type names
-        const typeMatches = diff.match(/^[+-](?!\s)(?:export\s+)?(?: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)
-                    addUnique(nameMatch[1]);
-            }
-        }
-        // Extract class names
-        const classMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?(?:abstract\s+)?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)
-                    addUnique(nameMatch[1]);
-            }
-        }
-        return elements.slice(0, 5); // Limit to top 5 elements
-    }
-    /**
-     * Extract function/class/method names from git diff by analyzing both hunk headers
-     * and the actual context lines around changes.
-     *
-     * This method prioritizes function declarations found in context lines near the
-     * actual changes, which is more accurate than just using hunk headers (which may
-     * show preceding functions instead of the one being modified).
-     */
-    static extractHunkContext(diff) {
-        const names = [];
-        // Split diff into hunks
-        const hunks = diff.split(/^@@/gm).slice(1); // Skip header before first @@
-        for (const hunk of hunks) {
-            const lines = hunk.split('\n');
-            let lastFunctionName = null;
-            let foundChange = false;
-            // Skip first line (hunk header like " -425,7 +425,7 @@ function normalize...")
-            for (let i = 1; i < lines.length; i++) {
-                const line = lines[i];
-                // Check if this is a context line (starts with space) or added line (starts with +)
-                // Context lines show surrounding code that hasn't changed
-                if (line.startsWith(' ') || (line.startsWith('+') && !line.startsWith('+++'))) {
-                    const extractedName = this.extractNameFromLine(line);
-                    if (extractedName) {
-                        lastFunctionName = extractedName;
-                    }
-                }
-                // If we find an actual change (+/-) and we have a function name, record it
-                if ((line.startsWith('+') || line.startsWith('-')) &&
-                    !line.startsWith('+++') && !line.startsWith('---') &&
-                    lastFunctionName &&
-                    !foundChange) {
-                    if (!names.includes(lastFunctionName)) {
-                        names.push(lastFunctionName);
-                    }
-                    foundChange = true; // Only record once per hunk
-                }
-            }
-            // Fallback: if no function found in context lines, try hunk header
-            if (!foundChange && lines[0]) {
-                const headerMatch = lines[0].match(/^@?\s+[^@]+@@\s+(.+)$/);
-                if (headerMatch) {
-                    const name = this.extractNameFromLine(headerMatch[1]);
-                    if (name && !names.includes(name)) {
-                        names.push(name);
-                    }
-                }
-            }
-        }
-        return names.slice(0, 5);
-    }
-    /**
-     * Extract a function/class/method name from a single line of code
-     */
-    static extractNameFromLine(line) {
-        // Remove leading diff markers and whitespace
-        const cleanLine = line.replace(/^[+\-\s@]*/, '').trim();
-        // Skip lines that are clearly control flow (for, if, while, etc.)
-        if (/^\s*(if|else|for|while|do|switch|catch|return|throw)\s*\(/.test(cleanLine)) {
-            return null;
-        }
-        // function declarations: function foo(, async function foo(, export function foo(
-        const funcMatch = cleanLine.match(/(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
-        if (funcMatch)
-            return funcMatch[1];
-        // const/let/var arrow or function expression: const foo = (, export const foo = async (
-        // Only match if it looks like a function (has = followed by function keyword, arrow, or paren)
-        const constMatch = cleanLine.match(/(?:export\s+(?:default\s+)?)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:function|\(|[a-zA-Z_$])/);
-        if (constMatch)
-            return constMatch[1];
-        // class declarations: class Foo {, export class Foo extends Bar {
-        const classMatch = cleanLine.match(/(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Z][a-zA-Z0-9]*)/);
-        if (classMatch)
-            return classMatch[1];
-        // class method: methodName(, async methodName(, private methodName(, static async methodName(
-        // Exclude control flow keywords (if, for, while, etc.) which share the `keyword(` shape
-        const methodMatch = cleanLine.match(/(?:public|private|protected)?\s*(?:static\s+)?(?:async\s+)?(?!if|else|for|while|do|switch|catch|return|throw|new|typeof|instanceof|delete|void|yield|await\b)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
-        if (methodMatch)
-            return methodMatch[1];
-        // interface/type declarations
-        const typeMatch = cleanLine.match(/(?:export\s+)?(?:interface|type)\s+([A-Z][a-zA-Z0-9]*)/);
-        if (typeMatch)
-            return typeMatch[1];
-        return null;
-    }
-    /**
-     * 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, hunkContext) {
-        // If we have specific elements from declarations, 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 hunk context (function/class names from @@ headers)
-        // This is especially useful for fix/refactor where changes are inside
-        // function bodies and the declaration line itself isn't in the diff
-        if (hunkContext && hunkContext.length > 0) {
-            if (hunkContext.length === 1) {
-                return hunkContext[0];
-            }
-            if (hunkContext.length <= 3) {
-                return hunkContext.join(', ');
-            }
-            return `${hunkContext.slice(0, 2).join(', ')} and ${hunkContext.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 description from AST analysis results.
-     * Produces specific, human-readable descriptions based on structural signals.
-     * Returns empty string if AST data is insufficient for a good description.
-     */
-    static generateASTDescription(astResult, commitType) {
-        const { declarations, signals } = astResult;
-        // Handle renames — most specific and readable
-        if (declarations.renamed.length > 0) {
-            const r = declarations.renamed[0];
-            if (declarations.renamed.length === 1) {
-                return `rename ${r.oldName} to ${r.newName}`;
-            }
-            return `rename ${r.oldName} to ${r.newName} and ${declarations.renamed.length - 1} more`;
-        }
-        // Handle removed exported declarations (breaking refactor)
-        const removedExported = declarations.removed.filter(d => d.exported);
-        if (removedExported.length > 0) {
-            if (removedExported.length === 1) {
-                return `remove ${removedExported[0].name} export`;
-            }
-            return `remove ${removedExported[0].name} and ${removedExported.length - 1} more exports`;
-        }
-        // Handle breaking signature changes
-        const sigChangeSignals = signals.filter(s => s.signal === 'changed-exported-sig');
-        if (sigChangeSignals.length > 0) {
-            const nameMatch = sigChangeSignals[0].detail.match(/on '([^']+)'/);
-            if (nameMatch) {
-                return `change ${nameMatch[1]} signature`;
-            }
-        }
-        // Handle new declarations (feat)
-        if (commitType === 'feat' && declarations.added.length > 0) {
-            const exported = declarations.added.filter(d => d.exported);
-            const target = exported.length > 0 ? exported : declarations.added;
-            if (target.length === 1) {
-                return `add ${target[0].name} ${target[0].kind}`;
-            }
-            if (target.length === 2) {
-                return `add ${target[0].name} and ${target[1].name}`;
-            }
-            return `add ${target[0].name}, ${target[1].name} and ${target.length - 2} more`;
-        }
-        // Handle fix signals (error handling, guards)
-        if (commitType === 'fix') {
-            const errorSignals = signals.filter(s => s.signal === 'error-handling-change');
-            if (errorSignals.length > 0) {
-                const nameMatch = errorSignals[0].detail.match(/in '([^']+)'/);
-                if (nameMatch) {
-                    return `handle errors in ${nameMatch[1]}`;
-                }
-            }
-            const guardSignals = signals.filter(s => s.signal === 'guard-added');
-            if (guardSignals.length > 0) {
-                const nameMatch = guardSignals[0].detail.match(/in '([^']+)'/);
-                if (nameMatch) {
-                    return `add validation to ${nameMatch[1]}`;
-                }
-            }
-            // Literal-only changes
-            const literalSignals = signals.filter(s => s.signal === 'literal-only-change');
-            if (literalSignals.length > 0) {
-                const nameMatch = literalSignals[0].detail.match(/in '([^']+)'/);
-                if (nameMatch) {
-                    return `fix values in ${nameMatch[1]}`;
-                }
-            }
-        }
-        // Handle perf signals
-        if (commitType === 'perf') {
-            const perfSignals = signals.filter(s => s.signal === 'perf-pattern');
-            if (perfSignals.length > 0) {
-                const nameMatch = perfSignals[0].detail.match(/in '([^']+)'/);
-                if (nameMatch) {
-                    return `optimize ${nameMatch[1]} performance`;
-                }
-            }
-        }
-        // Handle refactor signals (control flow, modified)
-        if (commitType === 'refactor') {
-            const controlFlowSignals = signals.filter(s => s.signal === 'control-flow-restructured');
-            if (controlFlowSignals.length > 0) {
-                const nameMatch = controlFlowSignals[0].detail.match(/in '([^']+)'/);
-                if (nameMatch) {
-                    return `simplify ${nameMatch[1]} control flow`;
-                }
-            }
-            if (declarations.modified.length > 0) {
-                const names = declarations.modified.map(m => m.name);
-                if (names.length === 1) {
-                    return `refactor ${names[0]}`;
-                }
-                if (names.length === 2) {
-                    return `refactor ${names[0]} and ${names[1]}`;
-                }
-                return `refactor ${names[0]}, ${names[1]} and ${names.length - 2} more`;
-            }
-        }
-        // Generic fallback using affectedElements
-        if (astResult.affectedElements.length > 0) {
-            const verb = commitType === 'feat' ? 'add' :
-                commitType === 'fix' ? 'fix' :
-                    commitType === 'refactor' ? 'refactor' :
-                        commitType === 'perf' ? 'optimize' : 'update';
-            const els = astResult.affectedElements;
-            if (els.length === 1) {
-                return `${verb} ${els[0]}`;
-            }
-            if (els.length === 2) {
-                return `${verb} ${els[0]} and ${els[1]}`;
-            }
-            return `${verb} ${els[0]}, ${els[1]} and ${els.length - 2} more`;
-        }
-        return '';
-    }
-    /**
-     * Detect test+implementation file pairs.
-     * Returns the pair info if files match naming conventions, null otherwise.
-     */
-    static detectTestImplPair(stagedFiles) {
-        if (stagedFiles.length < 2)
-            return null;
-        for (const file of stagedFiles) {
-            const path = file.path;
-            // Check if this is a test file
-            const testMatch = path.match(/^(.+)\.(test|spec)\.(ts|tsx|js|jsx|mts|cts)$/);
-            const dirTestMatch = path.match(/^(.+\/)__tests__\/(.+)\.(ts|tsx|js|jsx|mts|cts)$/);
-            if (testMatch) {
-                const implPath = `${testMatch[1]}.${testMatch[3]}`;
-                const implFile = stagedFiles.find(f => f.path === implPath);
-                if (implFile) {
-                    return {
-                        implFile: this.getFileName(implFile.path),
-                        testFile: this.getFileName(file.path),
-                        implStatus: implFile.status,
-                        testStatus: file.status,
-                    };
-                }
-            }
-            if (dirTestMatch) {
-                const implPath = `${dirTestMatch[1]}${dirTestMatch[2]}.${dirTestMatch[3]}`;
-                const implFile = stagedFiles.find(f => f.path === implPath);
-                if (implFile) {
-                    return {
-                        implFile: this.getFileName(implFile.path),
-                        testFile: this.getFileName(file.path),
-                        implStatus: implFile.status,
-                        testStatus: file.status,
-                    };
-                }
-            }
-        }
-        return null;
-    }
-    /**
-     * Generate description using lightweight file content analysis (JSON, CSS, YAML, MD).
-     * Returns null if no structural info is available.
-     */
-    static generateFileContentDescription(stagedFiles, diff) {
-        if (stagedFiles.length !== 1)
-            return null;
-        const file = stagedFiles[0];
-        const analysis = (0, fileContentAnalyzer_1.analyzeFileContent)(file.path, diff);
-        if (!analysis || analysis.changedElements.length === 0)
-            return null;
-        const fileName = this.getFileName(file.path);
-        const elements = analysis.changedElements;
-        const elementStr = elements.length <= 2
-            ? elements.join(' and ')
-            : `${elements[0]} and ${elements.length - 1} more`;
-        const verb = analysis.changeKind === 'added' ? 'add'
-            : analysis.changeKind === 'removed' ? 'remove'
-                : 'update';
-        return `${verb} ${elementStr} in ${fileName}`;
-    }
-    /**
-     * Generate description using hunk header context (function/class names).
-     * Works for any language that git can identify scope for.
-     * Returns null if no hunk context is available.
-     */
-    static generateHunkDescription(stagedFiles, diff, commitType) {
-        const hunkNames = this.extractHunkContext(diff);
-        if (hunkNames.length === 0)
-            return null;
-        const verb = commitType === 'feat' ? 'add' :
-            commitType === 'fix' ? 'fix' :
-                commitType === 'refactor' ? 'refactor' :
-                    commitType === 'perf' ? 'optimize' : 'update';
-        const nameStr = hunkNames.length <= 2
-            ? hunkNames.join(' and ')
-            : `${hunkNames[0]} and ${hunkNames.length - 1} more`;
-        if (stagedFiles.length === 1) {
-            const fileName = this.getFileName(stagedFiles[0].path);
-            return `${verb} ${nameStr} in ${fileName}`;
-        }
-        return `${verb} ${nameStr}`;
-    }
-    /**
-     * Generate a descriptive commit message
-     * Uses AST analysis for specific descriptions when available,
-     * falls back to semantic analysis and regex-based descriptions.
-     */
-    static generateDescription(filesAffected, fileStatuses, stagedFiles, diff, semanticAnalysis, astResult, commitType) {
-        // 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 AST analysis for specific, human-readable descriptions when available
-        // AST descriptions are preferred because they name exact functions/classes
-        if (astResult && commitType) {
-            const astMaxWeight = astResult.signals.length > 0
-                ? Math.max(...astResult.signals.map(s => s.weight), 0)
-                : 0;
-            if (astMaxWeight > 1 || astResult.declarations.renamed.length > 0) {
-                const astDesc = this.generateASTDescription(astResult, commitType);
-                if (astDesc) {
-                    return astDesc;
-                }
-            }
-        }
-        // Use semantic analysis for intent-based descriptions when available
-        if (semanticAnalysis && semanticAnalysis.roleChanges.length > 0) {
-            return this.generateSemanticDescription(semanticAnalysis, stagedFiles);
-        }
-        // Detect test + implementation file pairs
-        const pair = this.detectTestImplPair(stagedFiles);
-        if (pair) {
-            const implName = pair.implFile.replace(/\.\w+$/, '');
-            if (pair.implStatus === 'A' && pair.testStatus === 'A') {
-                return `add ${implName} with tests`;
-            }
-            else if (pair.implStatus === 'M' && pair.testStatus === 'A') {
-                return `update ${implName} and add tests`;
-            }
-            else if (pair.implStatus === 'A' && pair.testStatus === 'M') {
-                return `add ${implName} and update tests`;
-            }
-            else {
-                return `update ${implName} and tests`;
-            }
-        }
-        // Use lightweight file content analysis (JSON keys, CSS selectors, etc.)
-        const fileContentDesc = this.generateFileContentDescription(stagedFiles, diff);
-        if (fileContentDesc) {
-            return fileContentDesc;
-        }
-        // Use hunk header context for function/class names (works for any language)
-        if (commitType) {
-            const hunkDesc = this.generateHunkDescription(stagedFiles, diff, commitType);
-            if (hunkDesc) {
-                return hunkDesc;
-            }
-        }
-        // 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];
-        const hunkContext = semantic.hunkContext;
-        // 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 with identified elements
-        if (stagedFiles.length > 1 && whatChanged && whatChanged !== 'code') {
-            // whatChanged contains specific element names (from extractAffectedElements or hunkContext)
-            if (/^[a-zA-Z_$][a-zA-Z0-9_$,\s]*$/.test(whatChanged) && !Object.values(ROLE_DESCRIPTIONS).includes(whatChanged)) {
-                return `${verb} ${whatChanged} ${roleDesc}`;
-            }
-        }
-        // When whatChanged is generic but hunk context provides specific function/class names
-        if (hunkContext && hunkContext.length > 0) {
-            const contextNames = hunkContext.length <= 2
-                ? hunkContext.join(' and ')
-                : `${hunkContext[0]} and ${hunkContext.length - 1} more`;
-            return `${verb} ${contextNames} ${roleDesc}`;
-        }
-        // 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
      */
@@ -1940,123 +198,6 @@ class AnalyzerService {
         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
      */
@@ -2068,9 +209,9 @@ class AnalyzerService {
         if (includeEmoji === undefined) {
             includeEmoji = historyService_1.HistoryService.projectUsesEmojis();
         }
-        const body = this.generateBody(analysis);
+        const body = (0, messageBuilder_1.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);
+        const full = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, analysis.scope, analysis.description, body, includeEmoji, ticketInfo, analysis.isBreakingChange, analysis.breakingChangeReasons);
         return {
             type: analysis.commitType,
             scope: analysis.scope,
@@ -2078,6 +219,8 @@ class AnalyzerService {
             body,
             full,
             isBreaking: analysis.isBreakingChange,
+            confidence: analysis.confidence,
+            classificationSource: analysis.classificationSource,
         };
     }
     /**
@@ -2092,7 +235,7 @@ class AnalyzerService {
             includeEmoji = historyService_1.HistoryService.projectUsesEmojis();
         }
         const suggestions = [];
-        const body = this.generateBody(analysis);
+        const body = (0, messageBuilder_1.generateBody)(analysis);
         const ticketInfo = historyService_1.HistoryService.detectTicketFromBranch();
         const { isBreakingChange, breakingChangeReasons } = analysis;
         // Try to get a better scope from history if none detected
@@ -2103,7 +246,7 @@ class AnalyzerService {
             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);
+        const defaultFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, scope, analysis.description, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
         suggestions.push({
             id: 1,
             label: isBreakingChange ? 'Breaking Change' : 'Recommended',
@@ -2114,11 +257,13 @@ class AnalyzerService {
                 body,
                 full: defaultFull,
                 isBreaking: isBreakingChange,
+                confidence: analysis.confidence,
+                classificationSource: analysis.classificationSource,
             },
         });
         // Suggestion 2: Without scope (more concise)
         if (scope) {
-            const noScopeFull = this.buildFullMessage(analysis.commitType, undefined, analysis.description, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+            const noScopeFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, undefined, analysis.description, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
             suggestions.push({
                 id: 2,
                 label: 'Concise',
@@ -2129,13 +274,15 @@ class AnalyzerService {
                     body,
                     full: noScopeFull,
                     isBreaking: isBreakingChange,
+                    confidence: analysis.confidence,
+                    classificationSource: analysis.classificationSource,
                 },
             });
         }
         // Suggestion 3: Alternative description style
-        const altDescription = this.generateAlternativeDescription(analysis, gitService_1.GitService.getDiff());
+        const altDescription = (0, descriptionGenerator_1.generateAlternativeDescription)(analysis, gitService_1.GitService.getDiff());
         if (altDescription && altDescription !== analysis.description) {
-            const altFull = this.buildFullMessage(analysis.commitType, scope, altDescription, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
+            const altFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, scope, altDescription, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
             suggestions.push({
                 id: suggestions.length + 1,
                 label: 'Detailed',
@@ -2146,12 +293,14 @@ class AnalyzerService {
                     body,
                     full: altFull,
                     isBreaking: isBreakingChange,
+                    confidence: analysis.confidence,
+                    classificationSource: analysis.classificationSource,
                 },
             });
         }
         // 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);
+            const compactFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, scope, analysis.description, undefined, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
             suggestions.push({
                 id: suggestions.length + 1,
                 label: 'Compact',
@@ -2162,12 +311,14 @@ class AnalyzerService {
                     body: undefined,
                     full: compactFull,
                     isBreaking: isBreakingChange,
+                    confidence: analysis.confidence,
+                    classificationSource: analysis.classificationSource,
                 },
             });
         }
         // 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);
+            const noTicketFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, scope, analysis.description, body, includeEmoji, null, isBreakingChange, breakingChangeReasons);
             suggestions.push({
                 id: suggestions.length + 1,
                 label: 'No Ticket',
@@ -2178,12 +329,14 @@ class AnalyzerService {
                     body,
                     full: noTicketFull,
                     isBreaking: isBreakingChange,
+                    confidence: analysis.confidence,
+                    classificationSource: analysis.classificationSource,
                 },
             });
         }
         // 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, []);
+            const noBreakingFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, scope, analysis.description, body, includeEmoji, ticketInfo, false, []);
             suggestions.push({
                 id: suggestions.length + 1,
                 label: 'No Breaking Flag',
@@ -2194,6 +347,8 @@ class AnalyzerService {
                     body,
                     full: noBreakingFull,
                     isBreaking: false,
+                    confidence: analysis.confidence,
+                    classificationSource: analysis.classificationSource,
                 },
             });
         }
@@ -2217,7 +372,7 @@ class AnalyzerService {
             if (includeEmoji === undefined) {
                 includeEmoji = historyService_1.HistoryService.projectUsesEmojis();
             }
-            const body = this.generateBody(analysis);
+            const body = (0, messageBuilder_1.generateBody)(analysis);
             const ticketInfo = historyService_1.HistoryService.detectTicketFromBranch();
             const { isBreakingChange, breakingChangeReasons } = analysis;
             // Get scope
@@ -2231,7 +386,7 @@ class AnalyzerService {
             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);
+                const aiFull = (0, messageBuilder_1.buildFullMessage)(analysis.commitType, scope, aiDescription, body, includeEmoji, ticketInfo, isBreakingChange, breakingChangeReasons);
                 // Insert AI suggestion at the beginning
                 suggestions.unshift({
                     id: 0,
@@ -2257,96 +412,6 @@ class AnalyzerService {
         }
         return suggestions;
     }
-    /**
-     * Generate an alternative description style
-     * Uses AST data when available, otherwise falls back to regex extraction.
-     */
-    static generateAlternativeDescription(analysis, diff) {
-        const { fileChanges, filesAffected } = analysis;
-        const totalFiles = fileChanges.added.length + fileChanges.modified.length +
-            fileChanges.deleted.length + fileChanges.renamed.length;
-        // Use AST data to build a detailed alternative with file context
-        if (analysis.astResult && analysis.astResult.affectedElements.length > 0) {
-            const elements = analysis.astResult.affectedElements;
-            const verb = analysis.commitType === 'feat' ? 'add' :
-                analysis.commitType === 'fix' ? 'fix' :
-                    analysis.commitType === 'refactor' ? 'refactor' : 'update';
-            // For single file, include file name for extra context
-            if (totalFiles === 1) {
-                const fileName = fileChanges.added[0] || fileChanges.modified[0] || fileChanges.deleted[0] || fileChanges.renamed[0];
-                if (elements.length === 1) {
-                    return `${verb} ${elements[0]} in ${fileName}`;
-                }
-                if (elements.length === 2) {
-                    return `${verb} ${elements[0]} and ${elements[1]} in ${fileName}`;
-                }
-                return `${verb} ${elements[0]}, ${elements[1]} and ${elements.length - 2} more in ${fileName}`;
-            }
-            // For multiple files, list elements across files
-            if (elements.length === 1) {
-                return `${verb} ${elements[0]}`;
-            }
-            if (elements.length === 2) {
-                return `${verb} ${elements[0]} and ${elements[1]}`;
-            }
-            return `${verb} ${elements[0]}, ${elements[1]} and ${elements.length - 2} more`;
-        }
-        // For single file, provide more detail using extracted elements when available
-        if (totalFiles === 1) {
-            const elements = this.extractAffectedElements(diff);
-            const fileName = fileChanges.added[0] || fileChanges.modified[0] || fileChanges.deleted[0] || fileChanges.renamed[0];
-            if (elements.length > 0) {
-                const verb = analysis.commitType === 'feat' ? 'add' :
-                    analysis.commitType === 'fix' ? 'fix' :
-                        analysis.commitType === 'refactor' ? 'refactor' : 'update';
-                if (elements.length === 1) {
-                    return `${verb} ${elements[0]} in ${fileName}`;
-                }
-                if (elements.length === 2) {
-                    return `${verb} ${elements[0]} and ${elements[1]} in ${fileName}`;
-                }
-                return `${verb} ${elements[0]}, ${elements[1]} and ${elements.length - 2} more in ${fileName}`;
-            }
-            // Fall back to hunk context for modified files where declarations aren't in the diff
-            const hunkNames = this.extractHunkContext(diff);
-            if (hunkNames.length > 0) {
-                const verb = analysis.commitType === 'feat' ? 'add' :
-                    analysis.commitType === 'fix' ? 'fix' :
-                        analysis.commitType === 'refactor' ? 'refactor' : 'update';
-                if (hunkNames.length === 1) {
-                    return `${verb} ${hunkNames[0]} in ${fileName}`;
-                }
-                if (hunkNames.length === 2) {
-                    return `${verb} ${hunkNames[0]} and ${hunkNames[1]} in ${fileName}`;
-                }
-                return `${verb} ${hunkNames[0]}, ${hunkNames[1]} and ${hunkNames.length - 2} more in ${fileName}`;
-            }
-            if (fileChanges.added.length === 1) {
-                return `implement ${fileChanges.added[0]}`;
-            }
-            if (fileChanges.modified.length === 1) {
-                return `update ${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