@m3hti/commit-genie 1.2.0 → 1.2.2

package/dist/services/analyzerService.js

@@ -40,6 +40,181 @@ const BREAKING_PATTERNS = [
     // 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
+    ],
+};
+// 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' },
+};
 class AnalyzerService {
     /**
      * Analyze staged changes and return structured analysis
@@ -84,18 +259,37 @@ class AnalyzerService {
         const totalChanges = stats.insertions + stats.deletions;
         const isLargeChange = stagedFiles.length >= 3 || totalChanges >= 100;
         // Determine commit type based on file types and changes
-        const commitType = this.determineCommitType(filesAffected, diff, stagedFiles);
-        // Generate description
+        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);
-        // Determine scope if applicable
-        const scope = this.determineScope(stagedFiles);
-        // Detect breaking changes
-        const { isBreaking, reasons } = this.detectBreakingChanges(diff, stagedFiles);
+        }, stagedFiles, diff, semanticAnalysis);
         return {
             commitType,
             scope,
@@ -105,6 +299,7 @@ class AnalyzerService {
             isLargeChange,
             isBreakingChange: isBreaking,
             breakingChangeReasons: reasons,
+            semanticAnalysis,
         };
     }
     /**
@@ -200,22 +395,36 @@ class AnalyzerService {
             return 'docs';
         }
         // === STYLE DETECTION ===
-        // Check for style/formatting files
-        const isStyleChange = filePaths.some(p => p.endsWith('.css') ||
+        // 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.includes('.style') ||
-            p.includes('styles/'));
-        // Check for formatting-only changes (whitespace, semicolons, quotes)
-        const formattingPatterns = [
-            /^[+-]\s*$/gm, // Only whitespace changes
-            /^[+-]\s*['"`];?\s*$/gm, // Quote changes
-            /^[+-].*;\s*$/gm, // Semicolon additions/removals
-        ];
-        const isFormattingChange = formattingPatterns.some(p => p.test(diff));
-        if (isStyleChange || (isFormattingChange && !this.hasLogicChanges(diff))) {
+            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 ===
@@ -412,6 +621,61 @@ class AnalyzerService {
         }
         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)
@@ -453,10 +717,364 @@ class AnalyzerService {
         }
         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);
+        const primaryIntent = this.determineIntent(diff, stagedFiles, roleChanges);
+        const affectedElements = this.extractAffectedElements(diff);
+        // Generate human-readable descriptions
+        const intentDescription = this.generateIntentDescription(primaryIntent, primaryRole, roleChanges);
+        const whatChanged = this.generateWhatChanged(roleChanges, affectedElements, stagedFiles);
+        return {
+            primaryRole,
+            primaryIntent,
+            roleChanges,
+            intentDescription,
+            whatChanged,
+            hasMultipleRoles: roleChanges.filter(r => r.significance > 20).length > 1,
+        };
+    }
+    /**
+     * 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
+    }
+    /**
+     * 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) {
+    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;
@@ -473,7 +1091,11 @@ class AnalyzerService {
                 return fileName ? `add comments to ${fileName}` : 'add code comments';
             }
         }
-        // Single file changes
+        // 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);
@@ -519,6 +1141,50 @@ class AnalyzerService {
         // 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];
+        // 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
      */
@@ -574,27 +1240,47 @@ class AnalyzerService {
     }
     /**
      * Generate commit body for larger changes
+     * Includes semantic role context when available
      */
     static generateBody(analysis) {
-        if (!analysis.isLargeChange) {
-            return undefined;
-        }
         const lines = [];
-        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}`);
+        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('');
         }
-        if (analysis.fileChanges.deleted.length > 0) {
-            lines.push(`- Remove ${analysis.fileChanges.deleted.join(', ')}`);
+        // Only add file details for truly large changes
+        if (!analysis.isLargeChange && lines.length === 0) {
+            return undefined;
         }
-        if (analysis.fileChanges.renamed.length > 0) {
-            lines.push(`- Rename ${analysis.fileChanges.renamed.join(', ')}`);
+        // 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;
     }