@jmruthers/pace-core 0.6.5 → 0.6.7

package/scripts/audit/core/checks/style.cjs

@@ -1,584 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * Code Style Check Module
- * @package @jmruthers/pace-core
- * @module Audit/Checks/Style
- * 
- * Checks for:
- * - Inline styles usage
- * - Inconsistent naming conventions
- * - Missing TypeScript types
- * - any type usage
- * - Console.log statements
- */
-
-const fs = require('fs');
-const path = require('path');
-const { getRelativePath, getLineNumber } = require('../utils.cjs');
-
-const styleCheck = {
-  name: 'style',
-  description: 'Code style issues (inline styles, any types, console.log)',
-  severity: 'warning',
-  
-  async run(context) {
-    const { projectRoot, files } = context;
-    const issues = [];
-    const warnings = [];
-    const suggestions = [];
-    
-    if (!files || files.length === 0) {
-      return { issues, warnings, suggestions };
-    }
-    
-    for (const filePath of files) {
-      try {
-        const content = fs.readFileSync(filePath, 'utf8');
-        const relativePath = getRelativePath(filePath, projectRoot);
-        const normalizedPath = relativePath.replace(/\\/g, '/');
-        
-        // Skip root-level src directory - in pace-core repository, this is a demo/showcase app
-        // Note: We DO check packages/core/ files because style issues (any types, console.log, inline styles) are real issues that should be fixed
-        const isRootSrc = normalizedPath.startsWith('src/') && !normalizedPath.includes('packages/');
-        if (isRootSrc) {
-          continue; // Skip demo app files
-        }
-        
-        // Skip scripts directory - utility scripts don't need style validation
-        const isScript = normalizedPath.startsWith('scripts/') || normalizedPath.includes('/scripts/');
-        if (isScript) {
-          continue; // Skip script files
-        }
-        
-        // Skip test setup, teardown, and configuration files - these are test infrastructure
-        // Test setup/teardown files legitimately use 'any' types for mocking and may have simpler type annotations
-        const fileName = path.basename(normalizedPath);
-        const isTestInfrastructure = normalizedPath.includes('.setup.') || 
-                                    normalizedPath.includes('.teardown.') ||
-                                    normalizedPath.includes('.config.') ||
-                                    normalizedPath.includes('setupTests') ||
-                                    normalizedPath.includes('test-setup') ||
-                                    normalizedPath.includes('test-setup.') ||
-                                    fileName.match(/^(vitest|jest|setupTests)\.(setup|teardown)\.(ts|js|tsx|jsx)$/i) ||
-                                    fileName.match(/\.(setup|teardown)\.(ts|js|tsx|jsx)$/i) ||
-                                    fileName.match(/^test-setup\.(ts|js|tsx|jsx)$/i);
-        if (isTestInfrastructure) {
-          continue; // Skip test infrastructure files
-        }
-        
-        // Skip example files - these are demo/showcase code, not production code
-        const isExample = normalizedPath.includes('/examples/') || 
-                         normalizedPath.includes('/example/') ||
-                         fileName.includes('Example');
-        if (isExample) {
-          continue; // Skip example files
-        }
-        
-        // Skip logger utility files - they intentionally use console.* and any[] for variadic arguments
-        const isLogger = normalizedPath.includes('/utils/core/logger') ||
-                        normalizedPath.includes('/utils/core/debugLogger') ||
-                        (normalizedPath.includes('/rbac/config') && content.includes('createLogger') && content.includes('RBACLogger'));
-        if (isLogger) {
-          continue; // Skip logger utilities
-        }
-        
-        // Skip development utility files - these are meant to log to console for development/debugging
-        const isDevUtility = normalizedPath.includes('/utils/performance/') ||
-                            normalizedPath.includes('/utils/debug/') ||
-                            normalizedPath.includes('/utils/development/');
-        if (isDevUtility) {
-          continue; // Skip development utilities
-        }
-        
-        // Check for inline styles
-        const inlineStylePattern = /style\s*=\s*\{\{/g;
-        let styleMatch;
-        while ((styleMatch = inlineStylePattern.exec(content)) !== null) {
-          // Get context around the inline style to check if it's necessary
-          const contextStart = Math.max(0, styleMatch.index - 100);
-          const contextEnd = Math.min(content.length, styleMatch.index + 300);
-          const context = content.substring(contextStart, contextEnd);
-          
-          // Skip empty style objects - these are harmless placeholders
-          // Check if the style attribute contains only empty braces: style={{}}
-          // Look ahead from the match position to find the closing braces
-          const afterMatch = content.substring(styleMatch.index, Math.min(content.length, styleMatch.index + 50));
-          // Match patterns like: style={{}} or style={{ }} or style={{  }}
-          const isEmptyStyle = /style\s*=\s*\{\s*\{\s*\}\s*\}/.test(afterMatch);
-          if (isEmptyStyle) {
-            continue; // Skip empty style objects
-          }
-          
-          // Skip legitimate inline styles that can't be replaced with Tailwind:
-          // 1. Dynamic positioning (top/bottom based on direction)
-          // 2. Dynamic maxHeight/maxWidth from props
-          // 3. Virtual scrolling styles (transform, position: absolute with dynamic values)
-          // 4. Dynamic height/width from props or calculations
-          // 5. Dynamic indentation/padding for hierarchical data
-          const isDynamicPositioning = context.includes('[opensUpward') || 
-                                      context.includes('direction') ||
-                                      context.includes('opensUpward ?') ||
-                                      context.includes('direction ===');
-          
-          const isVirtualization = context.includes('transform') && 
-                                  (context.includes('translateY') || context.includes('translateX')) &&
-                                  (context.includes('virtualRow') || context.includes('virtualItem') || context.includes('virtualizer'));
-          
-          const isDynamicSize = (context.includes('maxHeight') || context.includes('maxWidth') ||
-                                context.includes('minHeight') || context.includes('minWidth') ||
-                                context.includes('height:') || context.includes('width:') ||
-                                context.includes('totalSize') || context.includes('virtualRow.size')) &&
-                                !context.includes('style={{}}'); // But not empty objects
-          
-          // Skip dynamic indentation/padding for hierarchical rows
-          const isDynamicIndentation = (context.includes('paddingLeft') || context.includes('paddingRight') ||
-                                       context.includes('indentation') || context.includes('indent')) &&
-                                      (context.includes('px') || context.includes('${'));
-          
-          // Skip if it's just pointerEvents and className already has pointer-events-none
-          const isRedundantPointerEvents = context.includes('pointerEvents') && 
-                                          context.includes('pointer-events-none');
-          
-          // Skip text overflow styles that are necessary for ellipsis
-          const isTextOverflow = context.includes('textOverflow') || 
-                                context.includes('whiteSpace') ||
-                                context.includes('overflow:') && context.includes('hidden');
-          
-          if (isDynamicPositioning || isVirtualization || (isDynamicSize && !isEmptyStyle) || isTextOverflow || isDynamicIndentation) {
-            continue; // Skip dynamic styles that require runtime values
-          }
-          
-          if (isRedundantPointerEvents) {
-            continue; // Skip redundant pointer events
-          }
-          
-          warnings.push({
-            type: 'inline-style',
-            file: relativePath,
-            line: getLineNumber(content, styleMatch.index),
-            message: 'Inline style detected',
-            recommendation: 'Use Tailwind classes or pace-core component props instead of inline styles'
-          });
-        }
-        
-        // Check for console.log in non-test files, but exclude CLI scripts and development utilities
-        if (!relativePath.includes('.test.') && !relativePath.includes('.spec.')) {
-          // Check if this is a CLI script (has shebang or is in scripts/ directory)
-          const isCLIScript = content.startsWith('#!/usr/bin/env node') || 
-                             content.startsWith('#!/bin/node') ||
-                             content.startsWith('#!/bin/env node') ||
-                             relativePath.includes('/scripts/') ||
-                             relativePath.startsWith('scripts/');
-          
-          // Skip RBAC config - it's a logger utility that intentionally uses console methods
-          const isRBACConfig = normalizedPath.includes('/rbac/config');
-          
-          // Skip development utilities - these are meant to log to console
-          const isDevUtility = normalizedPath.includes('/utils/performance/') ||
-                              normalizedPath.includes('/utils/debug/') ||
-                              normalizedPath.includes('/utils/development/');
-          
-          if (!isCLIScript && !isRBACConfig && !isDevUtility) {
-            const consoleLogPattern = /console\.(log|debug|info)\s*\(/g;
-            let consoleMatch;
-            while ((consoleMatch = consoleLogPattern.exec(content)) !== null) {
-              // Skip if it's in a comment (JSDoc examples, etc.)
-              const beforeMatch = content.substring(Math.max(0, consoleMatch.index - 150), consoleMatch.index);
-              const afterMatch = content.substring(consoleMatch.index, Math.min(content.length, consoleMatch.index + 50));
-              
-              // Check if it's in a comment block (JSDoc, regular comments)
-              // Look for JSDoc comment markers (* at start of line) or regular comment markers
-              const isInJSDocComment = beforeMatch.match(/\n\s*\*\s/) || beforeMatch.match(/\/\*\*/);
-              const isInRegularComment = beforeMatch.includes('//') || beforeMatch.includes('/*');
-              const isInComment = isInJSDocComment || isInRegularComment;
-              
-              // Check if it's in a code example within JSDoc (between ``` markers or in @example blocks)
-              const beforeCode = content.substring(Math.max(0, consoleMatch.index - 500), consoleMatch.index);
-              const isInCodeBlock = beforeCode.includes('```') && 
-                                   (beforeCode.match(/```/g) || []).length % 2 === 1; // Odd number of ``` means we're inside a code block
-              const isInJSDocExample = beforeMatch.match(/\*\s*@example/) || 
-                                      beforeMatch.match(/\*\s*```/) ||
-                                      beforeMatch.match(/\*\s*</); // JSX in JSDoc examples
-              const isInCodeExample = isInCodeBlock || isInJSDocExample;
-              
-              // Check if it's wrapped in a development check (process.env.NODE_ENV === 'development')
-              const contextForDevCheck = content.substring(Math.max(0, consoleMatch.index - 200), Math.min(content.length, consoleMatch.index + 200));
-              const isInDevCheck = contextForDevCheck.includes('process.env.NODE_ENV') && 
-                                  (contextForDevCheck.includes("=== 'development'") || 
-                                   contextForDevCheck.includes('=== "development"') ||
-                                   contextForDevCheck.includes("== 'development'") ||
-                                   contextForDevCheck.includes('== "development"'));
-              
-              if (isInComment || isInCodeExample || isInDevCheck) {
-                continue; // Skip console.log in comments/documentation/code examples or development checks
-              }
-              
-              warnings.push({
-                type: 'console-log',
-                file: relativePath,
-                line: getLineNumber(content, consoleMatch.index),
-                message: `console.${consoleMatch[1]} found in production code`,
-                recommendation: 'Remove console.log statements or use a proper logging utility. CLI scripts in scripts/ directory are allowed to use console output.'
-              });
-            }
-          }
-        }
-        
-        // Check for 'any' type usage in TypeScript files
-        if (filePath.match(/\.(ts|tsx)$/)) {
-          const anyTypePattern = /:\s*any\b|<\s*any\s*>|any\[\]/g;
-          let anyMatch;
-          while ((anyMatch = anyTypePattern.exec(content)) !== null) {
-            // Skip if it's in a comment or string
-            const beforeMatch = content.substring(Math.max(0, anyMatch.index - 50), anyMatch.index);
-            const isInComment = beforeMatch.includes('//') || beforeMatch.includes('/*');
-            
-            if (isInComment) {
-              continue;
-            }
-            
-            // Skip legitimate any[] usage in variadic function arguments (e.g., logger utilities)
-            const contextMatch = content.substring(Math.max(0, anyMatch.index - 100), Math.min(content.length, anyMatch.index + 50));
-            const isVariadicArg = contextMatch.match(/\.\.\.\s*args?\s*:\s*any\[\]/) ||
-                                 contextMatch.match(/\.\.\.\s*args?\s*:\s*any\b/);
-            if (isVariadicArg) {
-              continue; // Skip variadic arguments - these are legitimate uses of any[]
-            }
-            
-            // Skip generic cache implementations where any is used for value types
-            const isCacheGeneric = contextMatch.includes('CacheEntry<any>') ||
-                                   contextMatch.includes('Map<string, any>') ||
-                                   (contextMatch.includes('Map<') && contextMatch.includes('any>')) ||
-                                   (contextMatch.includes('Map<') && contextMatch.includes('any')) ||
-                                   (contextMatch.includes('cache') && (contextMatch.includes('data: any') || contextMatch.includes('{ data: any'))) ||
-                                   (contextMatch.includes('Cache') && contextMatch.includes('any')) ||
-                                   (contextMatch.includes('new Map') && contextMatch.includes('any'));
-            if (isCacheGeneric) {
-              continue; // Skip generic cache types - these are legitimate
-            }
-            
-            // Skip generic component types (React.ComponentType<any>, etc.)
-            const isGenericComponentType = contextMatch.includes('ComponentType<any>') ||
-                                          contextMatch.includes('React.ComponentType<any>') ||
-                                          (contextMatch.includes('ComponentType') && contextMatch.includes('<any>'));
-            if (isGenericComponentType) {
-              continue; // Skip generic component types - necessary for dynamic components
-            }
-            
-            // Skip generic Promise callbacks
-            const isPromiseCallback = contextMatch.includes('Promise<any>') ||
-                                     contextMatch.includes('Promise<') && contextMatch.includes('any>') ||
-                                     (contextMatch.includes('Promise') && contextMatch.includes('() => Promise<any>'));
-            if (isPromiseCallback) {
-              continue; // Skip Promise callbacks with any - necessary for generic async operations
-            }
-            
-            // Skip props: any in generic wrapper components
-            const isGenericProps = (contextMatch.includes('props: any') || contextMatch.includes('props?: any')) &&
-                                  (normalizedPath.includes('/utils/') || normalizedPath.includes('/components/'));
-            if (isGenericProps) {
-              continue; // Skip generic props - necessary for wrapper components
-            }
-            
-            // Skip this: any in utility functions (throttle, debounce, etc.) - necessary for preserving context
-            const isThisContext = contextMatch.includes('this: any') &&
-                                 (normalizedPath.includes('/hooks/') || normalizedPath.includes('/utils/'));
-            if (isThisContext) {
-              continue; // Skip this: any - necessary for function binding utilities
-            }
-            
-            // Skip any types in generic library components (DataTable, RBAC, etc.)
-            // These are necessary for flexibility when working with unknown data structures
-            const isGenericLibraryCode = 
-              // DataTable components - any is necessary for row data flexibility and generic components
-              (normalizedPath.includes('/DataTable/') || normalizedPath.includes('/DataTable.tsx')) ||
-              // RBAC code - needs any to work with Supabase's dynamic types and unknown data structures
-              (normalizedPath.includes('/rbac/')) ||
-              // Generic utility functions that need to work with unknown types
-              (normalizedPath.includes('/utils/') && (
-                contextMatch.includes('unknown') ||
-                contextMatch.includes('Record<string') ||
-                contextMatch.includes('lazyLoad') ||
-                contextMatch.includes('dynamic')
-              )) ||
-              // Form components that work with generic form data
-              (normalizedPath.includes('/Form/') && (
-                contextMatch.includes('formData') ||
-                contextMatch.includes('values:')
-              )) ||
-              // React.ReactElement<any> - common React pattern for generic elements
-              contextMatch.includes('React.ReactElement<any>') ||
-              contextMatch.includes('ReactElement<any>') ||
-              // Icon props - common pattern for icon components (can be any icon type)
-              (contextMatch.includes('icon') && (contextMatch.includes('?: any') || contextMatch.includes(': any'))) ||
-              // Callback functions with generic row/data parameters
-              (contextMatch.includes('onClick') && contextMatch.includes('(row: any)')) ||
-              (contextMatch.includes('onClick') && contextMatch.includes('(data: any)')) ||
-              (contextMatch.includes('callback') && contextMatch.includes(': any')) ||
-              // Generic hooks that work with unknown data - exclude all hooks in /hooks/public/ and specific hook files
-              (normalizedPath.includes('/hooks/public/')) ||
-              (normalizedPath.includes('/hooks/useDataTable')) ||
-              (normalizedPath.includes('/hooks/useFileDisplay')) ||
-              (normalizedPath.includes('/hooks/useQueryCache')) ||
-              (normalizedPath.includes('/hooks/useDataTablePerformance')) ||
-              (normalizedPath.includes('/hooks/useDataTableState')) ||
-              (normalizedPath.includes('/hooks/useInactivityTracker')) ||
-              (normalizedPath.includes('/hooks/') && (
-                contextMatch.includes('useDataTable') ||
-                contextMatch.includes('useFileDisplay') ||
-                contextMatch.includes('usePublic') ||
-                contextMatch.includes('useQueryCache') ||
-                contextMatch.includes('useInactivityTracker')
-              )) ||
-              // Calendar component - works with generic event data
-              (normalizedPath.includes('/Calendar/')) ||
-              // Select component - works with generic option values
-              (normalizedPath.includes('/Select/') && (
-                contextMatch.includes('value:') ||
-                contextMatch.includes('option')
-              )) ||
-              // OrganisationProvider - works with dynamic organisation data
-              (normalizedPath.includes('OrganisationProvider')) ||
-              // Theming utilities - work with dynamic color data
-              (normalizedPath.includes('/theming/')) ||
-              // Services that work with Supabase data - exclude all services working with dynamic data
-              (normalizedPath.includes('/services/') && (
-                contextMatch.includes('Supabase') ||
-                contextMatch.includes('Database') ||
-                contextMatch.includes('forEach') ||
-                contextMatch.includes('role: any') ||
-                contextMatch.includes('data: any') ||
-                contextMatch.includes(': any)')
-              )) ||
-              // Utils directory - many generic utilities, exclude dynamic and request utilities
-              (normalizedPath.includes('/utils/dynamic/')) ||
-              (normalizedPath.includes('/utils/request-')) ||
-              (normalizedPath.includes('/utils/') && (
-                contextMatch.includes('lazyLoad') ||
-                contextMatch.includes('createLazyComponent') ||
-                contextMatch.includes('request-deduplication')
-              ));
-            
-            if (isGenericLibraryCode) {
-              continue; // Skip legitimate any usage in generic library code
-            }
-            
-            warnings.push({
-              type: 'any-type',
-              file: relativePath,
-              line: getLineNumber(content, anyMatch.index),
-              message: 'TypeScript any type usage detected',
-              recommendation: 'Replace any with proper types for better type safety'
-            });
-          }
-          
-          // Check for missing return types on exported functions
-          // Skip React components and hooks where TypeScript inference is sufficient
-          const exportedFunctionPattern = /export\s+(?:default\s+)?(?:async\s+)?(function|const)\s+(\w+)\s*[=\(]/g;
-          let funcMatch;
-          while ((funcMatch = exportedFunctionPattern.exec(content)) !== null) {
-            const funcName = funcMatch[2];
-            // Get more context to handle multi-line function signatures
-            const startPos = funcMatch.index;
-            const afterMatch = content.substring(startPos, Math.min(content.length, startPos + 800));
-            
-            // For const declarations, check if it's actually a function (arrow function)
-            // Skip const declarations that are just values (zod schemas, objects, etc.)
-            if (funcMatch[1] === 'const') {
-              // Extract the part after the equals sign to check what follows
-              const equalsIndex = afterMatch.indexOf('=');
-              if (equalsIndex === -1) {
-                continue; // No equals sign found, skip
-              }
-              
-              const afterEquals = afterMatch.substring(equalsIndex + 1).trim();
-              
-              // Check if it's an arrow function: const name = (...) => ... or const name = async (...) => ...
-              const isArrowFunction = /^\s*(?:async\s+)?\([^)]*\)\s*=>/.test(afterEquals) || 
-                                     /^\s*(?:async\s+)?\w+\s*=>/.test(afterEquals) ||
-                                     /^\s*\([^)]*\)\s*:\s*\w+\s*=>/.test(afterEquals);
-              
-              // If it's not an arrow function, it's a const value (zod schema, object, etc.)
-              if (!isArrowFunction) {
-                continue; // Skip const values - not functions
-              }
-              
-              // Additional check: if it looks like a value assignment before the arrow function
-              // Pattern: const name = z.string()... or const name = new Class()... or const name = {...}
-              // But only if there's no arrow function syntax
-              const looksLikeValueBeforeArrow = /=\s*(z\.|new\s+\w+\(|\[|{|\d+|'|"|`|true|false|null)/.test(afterMatch);
-              if (looksLikeValueBeforeArrow && !isArrowFunction) {
-                continue; // Skip const values
-              }
-            }
-            
-            // Skip React hooks - TypeScript infers return types well for hooks
-            if (funcName.startsWith('use') && funcName.length > 3) {
-              continue; // Skip hooks - inference is sufficient
-            }
-            
-            // Skip React components - TypeScript infers JSX.Element well
-            // Check if function returns JSX (has return statement with JSX or is a component pattern)
-            const hasJSXReturn = afterMatch.includes('return (') || 
-                                afterMatch.includes('return <') ||
-                                afterMatch.includes('return React') ||
-                                (afterMatch.includes('React.') && afterMatch.includes('createElement'));
-            
-            // Check if it's a React component by name pattern (PascalCase, ends with Provider, etc.)
-            const isComponentName = /^[A-Z]/.test(funcName) || 
-                                   funcName.endsWith('Provider') ||
-                                   funcName.endsWith('Layout') ||
-                                   funcName.endsWith('Modal') ||
-                                   funcName.endsWith('Form') ||
-                                   funcName.endsWith('Button') ||
-                                   funcName.endsWith('Input') ||
-                                   funcName.endsWith('Select');
-            
-            if (hasJSXReturn || isComponentName) {
-              continue; // Skip React components - inference is sufficient
-            }
-            
-            // Skip simple utility functions where return type is obvious
-            // (e.g., getX, isX, hasX, createX, parseX, validateX, etc.)
-            const isSimpleUtility = /^(get|is|has|create|parse|validate|format|to|from|can|should|will|do|make|build|generate|find|search|filter|map|reduce|sort|compare|check|test|verify|ensure|normalize|sanitize|escape|unescape|encode|decode)/i.test(funcName);
-            if (isSimpleUtility && afterMatch.length < 150) {
-              // Only skip if function is relatively simple (short context)
-              continue; // Skip simple utilities - inference is usually sufficient
-            }
-            
-            // Check if function has explicit return type
-            if (funcMatch[1] === 'function') {
-              // function name(...): returnType
-              // Look for closing paren followed by colon and then any type annotation
-              // This matches: ): Type, ): Promise<Type>, ): 'type' | 'type', ): { ... }, etc.
-              // Handle both single-line and multi-line function signatures
-              
-              // Find the function body opening brace
-              const braceIndex = afterMatch.indexOf('{');
-              if (braceIndex === -1) {
-                continue; // No function body found, might be a type declaration
-              }
-              
-              // Get everything before the opening brace (the function signature)
-              const funcSignature = afterMatch.substring(0, braceIndex);
-              
-              // Check if there's a return type annotation
-              // Look for closing paren followed by colon (allowing whitespace/newlines)
-              // Then check for any non-whitespace character (start of return type)
-              // This handles:
-              // - ): Type
-              // - ): Promise<void>
-              // - ): 'type' | 'type'
-              // - ): { ... }
-              // - Multi-line: )\n: Type
-              // - Multi-line async: )\n: Promise<Type>
-              
-              // Find the last closing paren (end of parameter list)
-              // Then check if there's a colon after it (return type annotation)
-              let lastParenIndex = -1;
-              let depth = 0;
-              let inString = false;
-              let stringChar = '';
-              
-              // Find the last closing paren that's not inside nested parens (parameter list end)
-              // Start from the function name position to find the opening paren of the parameter list
-              const funcNameMatch = funcSignature.match(new RegExp(`\\b${funcName}\\s*\\(`));
-              const startSearchIndex = funcNameMatch ? funcNameMatch.index + funcNameMatch[0].length - 1 : 0;
-              
-              for (let i = startSearchIndex; i < funcSignature.length; i++) {
-                const char = funcSignature[i];
-                
-                // Handle string literals
-                if ((char === '"' || char === "'" || char === '`') && (i === 0 || funcSignature[i - 1] !== '\\')) {
-                  if (!inString) {
-                    inString = true;
-                    stringChar = char;
-                  } else if (char === stringChar) {
-                    inString = false;
-                    stringChar = '';
-                  }
-                }
-                
-                if (!inString) {
-                  if (char === '(') depth++;
-                  else if (char === ')') {
-                    depth--;
-                    if (depth === 0) {
-                      lastParenIndex = i; // This is the end of the parameter list
-                    }
-                  }
-                }
-              }
-              
-              // Check if there's a return type after the last closing paren
-              let hasReturnType = false;
-              if (lastParenIndex >= 0) {
-                const afterLastParen = funcSignature.substring(lastParenIndex);
-                // Look for colon followed by non-whitespace (return type)
-                // Normalize whitespace to handle multi-line signatures
-                const normalizedAfterParen = afterLastParen.replace(/\s+/g, ' ');
-                hasReturnType = /\)\s*:\s*\S/.test(normalizedAfterParen);
-              } else {
-                // Fallback: check if there's a colon anywhere in the signature (might be a return type)
-                // This handles edge cases where paren tracking might fail
-                const hasColonBeforeBrace = funcSignature.includes(':') && 
-                                           funcSignature.lastIndexOf(':') < braceIndex &&
-                                           funcSignature.lastIndexOf(':') > funcSignature.indexOf('(');
-                if (hasColonBeforeBrace) {
-                  // Check if the colon is followed by a type (not a default value)
-                  const colonIndex = funcSignature.lastIndexOf(':');
-                  const afterColon = funcSignature.substring(colonIndex + 1, braceIndex).trim();
-                  // If after colon we see a type-like pattern (starts with letter, Promise, {, [, etc.)
-                  hasReturnType = /^[A-Za-z_$]|^Promise|^\{|^\[|^'|^"/.test(afterColon);
-                }
-              }
-              
-              if (!hasReturnType) {
-                suggestions.push({
-                  type: 'missing-return-type',
-                  file: relativePath,
-                  line: getLineNumber(content, funcMatch.index),
-                  message: `Exported function '${funcName}' missing explicit return type`,
-                  recommendation: 'Add explicit return type annotation for better type safety'
-                });
-              }
-            } else {
-              // const name = (...) => ...
-              // Check if arrow function has return type
-              // Match: const name = (...): ReturnType => ...
-              // Look for ): before the => arrow
-              const arrowIndex = afterMatch.indexOf('=>');
-              if (arrowIndex > 0) {
-                const beforeArrow = afterMatch.substring(0, arrowIndex);
-                // Check if there's a return type annotation (): Type) before the arrow
-                // Normalize newlines to spaces for matching
-                const hasArrowReturnType = /\)\s*:\s*\S/.test(beforeArrow.replace(/\n/g, ' '));
-                
-                if (!hasArrowReturnType) {
-                  suggestions.push({
-                    type: 'missing-return-type',
-                    file: relativePath,
-                    line: getLineNumber(content, funcMatch.index),
-                    message: `Exported function '${funcName}' missing explicit return type`,
-                    recommendation: 'Add explicit return type annotation: const name = (...): ReturnType => ...'
-                  });
-                }
-              }
-            }
-          }
-        }
-        
-        // Check for inconsistent naming (simplified)
-        // This would need more sophisticated analysis
-        
-      } catch (error) {
-        // Skip files with errors
-      }
-    }
-    
-    return { issues, warnings, suggestions };
-  }
-};
-
-module.exports = styleCheck;