@m3hti/commit-genie 3.1.0 → 3.2.0

package/dist/services/semanticAnalyzer.js

@@ -0,0 +1,713 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.INTENT_VERBS = exports.ROLE_DESCRIPTIONS = void 0;
+exports.analyzeSemanticChanges = analyzeSemanticChanges;
+exports.extractAffectedElements = extractAffectedElements;
+exports.extractHunkContext = extractHunkContext;
+// Role detection patterns for semantic analysis
+const ROLE_PATTERNS = {
+    ui: [
+        // JSX elements and components
+        /^\+.*<[A-Z][a-zA-Z]*[\s/>]/m, // JSX component usage
+        /^\+.*<\/[A-Z][a-zA-Z]*>/m, // JSX component closing
+        /^\+.*<(div|span|p|h[1-6]|button|input|form|ul|li|table|img|a|section|header|footer|nav|main|article|aside)\b/mi,
+        /^\+.*className\s*=/m, // className attribute
+        /^\+.*style\s*=\s*\{/m, // inline styles
+        /^\+.*return\s*\(/m, // render return
+        /^\+.*render\s*\(\s*\)/m, // render method
+        /^\+.*(?:<>|<\/>)/m, // React fragments
+        /^\+.*aria-\w+=/m, // accessibility attributes
+        /^\+.*role\s*=/m, // role attribute
+        /^\+.*\b(?:onClick|onSubmit|onChange|onFocus|onBlur|onKeyDown|onKeyUp|onMouseEnter|onMouseLeave)\b/m,
+    ],
+    logic: [
+        // Business logic patterns
+        /^\+.*\bif\s*\(/m, // conditionals
+        /^\+.*\bswitch\s*\(/m, // switch statements
+        /^\+.*\bfor\s*\(/m, // for loops
+        /^\+.*\bwhile\s*\(/m, // while loops
+        /^\+.*\.map\s*\(/m, // array operations
+        /^\+.*\.filter\s*\(/m,
+        /^\+.*\.reduce\s*\(/m,
+        /^\+.*\.find\s*\(/m,
+        /^\+.*\.some\s*\(/m,
+        /^\+.*\.every\s*\(/m,
+        /^\+.*\btry\s*\{/m, // error handling
+        /^\+.*\bcatch\s*\(/m,
+        /^\+.*\bthrow\s+/m,
+        /^\+.*\breturn\s+(?![\s(]?<)/m, // return (not JSX)
+        /^\+.*\bawait\s+/m, // async operations
+        /^\+.*\bnew\s+[A-Z]/m, // object instantiation
+        /^\+.*=>\s*\{/m, // arrow function body
+    ],
+    data: [
+        // State and data management
+        /^\+.*\buseState\s*[<(]/m, // React state
+        /^\+.*\buseReducer\s*\(/m, // React reducer
+        /^\+.*\buseContext\s*\(/m, // React context
+        /^\+.*\buseSelector\s*\(/m, // Redux selector
+        /^\+.*\bdispatch\s*\(/m, // Redux dispatch
+        /^\+.*\bsetState\s*\(/m, // Class component state
+        /^\+.*\bthis\.state\b/m, // Class component state access
+        /^\+.*\bprops\./m, // Props access
+        /^\+.*interface\s+\w+Props/m, // Props interface
+        /^\+.*type\s+\w+Props/m, // Props type
+        /^\+.*\bconst\s+\[[a-z]+,\s*set[A-Z]/m, // State destructuring
+        /^\+.*:\s*\w+\[\]/m, // Array type
+        /^\+.*:\s*(string|number|boolean|object)/m, // Primitive types
+        /^\+.*\binterface\s+\w+/m, // Interface definition
+        /^\+.*\btype\s+\w+\s*=/m, // Type definition
+    ],
+    style: [
+        // CSS and styling
+        /^\+.*\bstyles?\./m, // styles object access
+        /^\+.*\bstyled\./m, // styled-components
+        /^\+.*\bcss`/m, // CSS template literal
+        /^\+.*\bsx\s*=\s*\{/m, // MUI sx prop
+        /^\+.*:\s*['"]?[0-9]+(px|em|rem|%|vh|vw)/m, // CSS units
+        /^\+.*:\s*['"]?#[0-9a-fA-F]{3,8}/m, // Hex colors
+        /^\+.*:\s*['"]?rgb(a)?\s*\(/m, // RGB colors
+        /^\+.*(margin|padding|width|height|border|background|color|font|display|flex|grid)\s*:/m,
+        /^\+.*\btheme\./m, // Theme access
+        /^\+.*\.module\.css/m, // CSS modules import
+    ],
+    api: [
+        // API and network calls
+        /^\+.*\bfetch\s*\(/m, // fetch API
+        /^\+.*\baxios\./m, // axios
+        /^\+.*\.get\s*\(/m, // HTTP GET
+        /^\+.*\.post\s*\(/m, // HTTP POST
+        /^\+.*\.put\s*\(/m, // HTTP PUT
+        /^\+.*\.delete\s*\(/m, // HTTP DELETE
+        /^\+.*\.patch\s*\(/m, // HTTP PATCH
+        /^\+.*\bapi\./m, // api object access
+        /^\+.*\/api\//m, // API path
+        /^\+.*\bendpoint/mi, // endpoint reference
+        /^\+.*\bheaders\s*:/m, // HTTP headers
+        /^\+.*\bAuthorization:/m, // Auth header
+        /^\+.*\buseQuery\s*\(/m, // React Query
+        /^\+.*\buseMutation\s*\(/m, // React Query mutation
+        /^\+.*\bswr\b/mi, // SWR
+        /^\+.*\bgraphql`/m, // GraphQL
+        /^\+.*\bquery\s*\{/m, // GraphQL query
+        /^\+.*\bmutation\s*\{/m, // GraphQL mutation
+    ],
+    config: [
+        // Configuration
+        /^\+.*\bprocess\.env\./m, // Environment variables
+        /^\+.*\bimport\.meta\.env\./m, // Vite env
+        /^\+.*\bCONFIG\./m, // Config constant
+        /^\+.*\bsettings\./m, // Settings object
+        /^\+.*\boptions\s*:/m, // Options object
+        /^\+.*\bdefaultProps/m, // Default props
+        /^\+.*\bexport\s+(const|let)\s+[A-Z_]+\s*=/m, // Constant export
+        /^\+.*:\s*['"]?(development|production|test)['"]/m, // Environment strings
+    ],
+    test: [
+        // Testing patterns
+        /^\+.*\bdescribe\s*\(/m, // Test suite
+        /^\+.*\bit\s*\(/m, // Test case
+        /^\+.*\btest\s*\(/m, // Test case
+        /^\+.*\bexpect\s*\(/m, // Assertion
+        /^\+.*\bjest\./m, // Jest
+        /^\+.*\bmock\(/m, // Mocking
+        /^\+.*\bspyOn\s*\(/m, // Spy
+        /^\+.*\bbeforeEach\s*\(/m, // Setup
+        /^\+.*\bafterEach\s*\(/m, // Teardown
+        /^\+.*\brender\s*\(/m, // React testing library
+    ],
+    unknown: [],
+};
+// Intent detection patterns
+const INTENT_PATTERNS = {
+    add: [
+        /^\+\s*export\s+(function|class|const|interface|type)/m,
+        /^\+\s*(async\s+)?function\s+\w+/m,
+        /^\+\s*const\s+\w+\s*=\s*(async\s+)?\(/m,
+        /^\+\s*class\s+\w+/m,
+    ],
+    modify: [
+    // Changes that have both additions and deletions of similar patterns
+    ],
+    fix: [
+        /^\+.*\btypeof\s+\w+\s*[!=]==?\s*['"`]/m,
+        /^\+.*\binstanceof\s+/m,
+        /^\+.*\bArray\.isArray\s*\(/m,
+        /^\+.*\bif\s*\(\s*!\w+\s*\)/m,
+        /^\+.*\?\?/m,
+        /^\+.*\?\./m,
+        /^\+.*\|\|\s*['"{\[0]/m, // Default values
+        /^\+.*\bcatch\s*\(/m,
+        /^\+.*\btry\s*\{/m,
+    ],
+    remove: [
+        /^-\s*export\s+(function|class|const|interface|type)/m,
+        /^-\s*(async\s+)?function\s+\w+/m,
+        /^-\s*class\s+\w+/m,
+    ],
+    refactor: [
+        /^\+.*=>/m, // Arrow function conversion
+        /^\+.*\.\.\./m, // Spread operator
+        /^\+.*`\$\{/m, // Template literal
+        /^\+.*Object\.(keys|values|entries)/m, // Object methods
+    ],
+    enhance: [
+        /^\+.*\bmemo\s*\(/m, // React memo
+        /^\+.*\buseMemo\s*\(/m, // useMemo hook
+        /^\+.*\buseCallback\s*\(/m, // useCallback hook
+        /^\+.*\blazy\s*\(/m, // React lazy
+        /^\+.*\bSuspense\b/m, // React Suspense
+    ],
+    rename: [
+    // Rename detection is handled by detectRenames() method
+    // which compares removed and added function/class/type names
+    ],
+};
+// Role descriptions for commit messages
+exports.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
+exports.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' },
+};
+/**
+ * Perform semantic analysis on the diff to understand the nature of changes
+ * This provides intent-based understanding rather than line-count metrics
+ */
+function analyzeSemanticChanges(diff, stagedFiles) {
+    const roleChanges = detectRoleChanges(diff, stagedFiles);
+    const primaryRole = determinePrimaryRole(roleChanges);
+    let primaryIntent = determineIntent(diff, stagedFiles, roleChanges);
+    const affectedElements = extractAffectedElements(diff);
+    const hunkContext = extractHunkContext(diff);
+    // Detect renames - this takes priority for determining intent
+    const renames = detectRenames(diff);
+    if (renames.length > 0) {
+        primaryIntent = 'rename';
+    }
+    // Generate human-readable descriptions
+    const intentDescription = generateIntentDescription(primaryIntent, primaryRole, roleChanges);
+    const whatChanged = renames.length > 0
+        ? `${renames[0].oldName} to ${renames[0].newName}`
+        : generateWhatChanged(roleChanges, affectedElements, stagedFiles, hunkContext);
+    return {
+        primaryRole,
+        primaryIntent,
+        roleChanges,
+        intentDescription,
+        whatChanged,
+        hasMultipleRoles: roleChanges.filter(r => r.significance > 20).length > 1,
+        renames: renames.length > 0 ? renames : undefined,
+        hunkContext: hunkContext.length > 0 ? hunkContext : undefined,
+    };
+}
+/**
+ * Detect which roles are affected by the changes and calculate semantic significance
+ * Significance is NOT based on line count - it's based on the semantic weight of patterns
+ */
+function 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 (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 = detectRoleIntent(diff, role);
+            const summary = generateRoleSummary(role, intent, matchCount);
+            roleChanges.push({
+                role,
+                intent,
+                significance,
+                summary,
+                affectedElements: 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
+ */
+function 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
+ */
+function 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
+ */
+function 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
+ */
+function 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
+ */
+function extractAffectedElements(diff) {
+    const elements = [];
+    // Helper to add unique element names
+    const addUnique = (name) => {
+        if (!elements.includes(name)) {
+            elements.push(name);
+        }
+    };
+    // Match both added (+) and modified (-) top-level declarations.
+    // For fix/refactor commits, the declaration line often appears as a removed line
+    // (the old version) or only in the - side of the diff. Using [+-] ensures we
+    // capture the affected function/class/component name regardless of whether
+    // the declaration itself was added, removed, or modified.
+    // (?!\s) after [+-] rejects indented lines (local variables inside function bodies)
+    // Extract component names (PascalCase function/const declarations)
+    const componentFuncMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([A-Z][a-zA-Z0-9]*)/gm);
+    if (componentFuncMatches) {
+        for (const match of componentFuncMatches) {
+            const nameMatch = match.match(/function\s+([A-Z][a-zA-Z0-9]*)/);
+            if (nameMatch)
+                addUnique(nameMatch[1]);
+        }
+    }
+    const componentConstMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?const\s+([A-Z][a-zA-Z0-9]*)\s*=\s*(?:async\s+)?(?:function|\()/gm);
+    if (componentConstMatches) {
+        for (const match of componentConstMatches) {
+            const nameMatch = match.match(/const\s+([A-Z][a-zA-Z0-9]*)/);
+            if (nameMatch)
+                addUnique(nameMatch[1]);
+        }
+    }
+    // Extract function names (camelCase declarations)
+    const funcKeywordMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([a-z][a-zA-Z0-9]*)\s*\(/gm);
+    if (funcKeywordMatches) {
+        for (const match of funcKeywordMatches) {
+            const nameMatch = match.match(/function\s+([a-z][a-zA-Z0-9]*)/);
+            if (nameMatch)
+                addUnique(nameMatch[1]);
+        }
+    }
+    // const/let arrow or function expression: const foo = (, export const foo = async (
+    const funcConstMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?const\s+([a-z][a-zA-Z0-9]*)\s*=\s*(?:async\s+)?(?:function|\()/gm);
+    if (funcConstMatches) {
+        for (const match of funcConstMatches) {
+            const nameMatch = match.match(/const\s+([a-z][a-zA-Z0-9]*)/);
+            if (nameMatch)
+                addUnique(nameMatch[1]);
+        }
+    }
+    // Extract interface/type names
+    const typeMatches = diff.match(/^[+-](?!\s)(?:export\s+)?(?:interface|type)\s+([A-Z][a-zA-Z0-9]*)/gm);
+    if (typeMatches) {
+        for (const match of typeMatches) {
+            const nameMatch = match.match(/(?:interface|type)\s+([A-Z][a-zA-Z0-9]*)/);
+            if (nameMatch)
+                addUnique(nameMatch[1]);
+        }
+    }
+    // Extract class names
+    const classMatches = diff.match(/^[+-](?!\s)(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Z][a-zA-Z0-9]*)/gm);
+    if (classMatches) {
+        for (const match of classMatches) {
+            const nameMatch = match.match(/class\s+([A-Z][a-zA-Z0-9]*)/);
+            if (nameMatch)
+                addUnique(nameMatch[1]);
+        }
+    }
+    return elements.slice(0, 5); // Limit to top 5 elements
+}
+/**
+ * Extract function/class/method names from git diff by analyzing both hunk headers
+ * and the actual context lines around changes.
+ *
+ * This method prioritizes function declarations found in context lines near the
+ * actual changes, which is more accurate than just using hunk headers (which may
+ * show preceding functions instead of the one being modified).
+ */
+function extractHunkContext(diff) {
+    const names = [];
+    // Split diff into hunks
+    const hunks = diff.split(/^@@/gm).slice(1); // Skip header before first @@
+    for (const hunk of hunks) {
+        const lines = hunk.split('\n');
+        let lastFunctionName = null;
+        let foundChange = false;
+        // Skip first line (hunk header like " -425,7 +425,7 @@ function normalize...")
+        for (let i = 1; i < lines.length; i++) {
+            const line = lines[i];
+            // Check if this is a context line (starts with space) or added line (starts with +)
+            // Context lines show surrounding code that hasn't changed
+            if (line.startsWith(' ') || (line.startsWith('+') && !line.startsWith('+++'))) {
+                const extractedName = extractNameFromLine(line);
+                if (extractedName) {
+                    lastFunctionName = extractedName;
+                }
+            }
+            // If we find an actual change (+/-) and we have a function name, record it
+            if ((line.startsWith('+') || line.startsWith('-')) &&
+                !line.startsWith('+++') && !line.startsWith('---') &&
+                lastFunctionName &&
+                !foundChange) {
+                if (!names.includes(lastFunctionName)) {
+                    names.push(lastFunctionName);
+                }
+                foundChange = true; // Only record once per hunk
+            }
+        }
+        // Fallback: if no function found in context lines, try hunk header
+        if (!foundChange && lines[0]) {
+            const headerMatch = lines[0].match(/^@?\s+[^@]+@@\s+(.+)$/);
+            if (headerMatch) {
+                const name = extractNameFromLine(headerMatch[1]);
+                if (name && !names.includes(name)) {
+                    names.push(name);
+                }
+            }
+        }
+    }
+    return names.slice(0, 5);
+}
+/**
+ * Extract a function/class/method name from a single line of code
+ */
+function extractNameFromLine(line) {
+    // Remove leading diff markers and whitespace
+    const cleanLine = line.replace(/^[+\-\s@]*/, '').trim();
+    // Skip lines that are clearly control flow (for, if, while, etc.)
+    if (/^\s*(if|else|for|while|do|switch|catch|return|throw)\s*\(/.test(cleanLine)) {
+        return null;
+    }
+    // function declarations: function foo(, async function foo(, export function foo(
+    const funcMatch = cleanLine.match(/(?:export\s+(?:default\s+)?)?(?:async\s+)?function\s+([a-zA-Z_$][a-zA-Z0-9_$]*)/);
+    if (funcMatch)
+        return funcMatch[1];
+    // const/let/var arrow or function expression: const foo = (, export const foo = async (
+    // Only match if it looks like a function (has = followed by function keyword, arrow, or paren)
+    const constMatch = cleanLine.match(/(?:export\s+(?:default\s+)?)?(?:const|let|var)\s+([a-zA-Z_$][a-zA-Z0-9_$]*)\s*=\s*(?:async\s+)?(?:function|\(|[a-zA-Z_$])/);
+    if (constMatch)
+        return constMatch[1];
+    // class declarations: class Foo {, export class Foo extends Bar {
+    const classMatch = cleanLine.match(/(?:export\s+(?:default\s+)?)?(?:abstract\s+)?class\s+([A-Z][a-zA-Z0-9]*)/);
+    if (classMatch)
+        return classMatch[1];
+    // class method: methodName(, async methodName(, private methodName(, static async methodName(
+    // Exclude control flow keywords (if, for, while, etc.) which share the `keyword(` shape
+    const methodMatch = cleanLine.match(/(?:public|private|protected)?\s*(?:static\s+)?(?:async\s+)?(?!if|else|for|while|do|switch|catch|return|throw|new|typeof|instanceof|delete|void|yield|await\b)([a-zA-Z_$][a-zA-Z0-9_$]*)\s*\(/);
+    if (methodMatch)
+        return methodMatch[1];
+    // interface/type declarations
+    const typeMatch = cleanLine.match(/(?:export\s+)?(?:interface|type)\s+([A-Z][a-zA-Z0-9]*)/);
+    if (typeMatch)
+        return typeMatch[1];
+    return null;
+}
+/**
+ * Extract affected elements for a specific role
+ */
+function 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 extractAffectedElements(diff).slice(0, 3);
+    }
+    return elements.slice(0, 3);
+}
+/**
+ * Detect function/class/type renames by comparing removed and added names
+ * Returns an array of { oldName, newName } objects
+ */
+function 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;
+}
+/**
+ * Generate a human-readable summary for a role change
+ */
+function generateRoleSummary(role, intent, matchCount) {
+    const roleDesc = exports.ROLE_DESCRIPTIONS[role];
+    const intentVerb = exports.INTENT_VERBS[intent].past;
+    if (matchCount === 1) {
+        return `${intentVerb} ${roleDesc}`;
+    }
+    return `${intentVerb} ${roleDesc} (${matchCount} changes)`;
+}
+/**
+ * Generate the WHY description for the commit
+ */
+function generateIntentDescription(intent, role, roleChanges) {
+    const roleDesc = exports.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
+ */
+function generateWhatChanged(roleChanges, affectedElements, stagedFiles, hunkContext) {
+    // If we have specific elements from declarations, use them
+    if (affectedElements.length > 0) {
+        if (affectedElements.length === 1) {
+            return affectedElements[0];
+        }
+        if (affectedElements.length <= 3) {
+            return affectedElements.join(', ');
+        }
+        return `${affectedElements.slice(0, 2).join(', ')} and ${affectedElements.length - 2} more`;
+    }
+    // Fall back to hunk context (function/class names from @@ headers)
+    // This is especially useful for fix/refactor where changes are inside
+    // function bodies and the declaration line itself isn't in the diff
+    if (hunkContext && hunkContext.length > 0) {
+        if (hunkContext.length === 1) {
+            return hunkContext[0];
+        }
+        if (hunkContext.length <= 3) {
+            return hunkContext.join(', ');
+        }
+        return `${hunkContext.slice(0, 2).join(', ')} and ${hunkContext.length - 2} more`;
+    }
+    // Fall back to role-based description
+    if (roleChanges.length > 0) {
+        const primaryRole = roleChanges[0];
+        if (primaryRole.affectedElements.length > 0) {
+            return primaryRole.affectedElements[0];
+        }
+        return exports.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';
+}
+//# sourceMappingURL=semanticAnalyzer.js.map