@jmruthers/pace-core 0.5.193 → 0.6.2

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

@@ -0,0 +1,584 @@
+#!/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;