@m3hti/commit-genie 1.2.4 → 1.2.5

package/dist/services/analyzerService.js

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