@jmruthers/pace-core 0.6.1 → 0.6.2

package/docs/migration/database-changes-december-2025.md

@@ -427,7 +427,7 @@ const { data: files } = await supabase
 
 **Migration:** `20251205211120_migrate_profiles_to_person_scoped.sql` + related migrations  
 **Date:** 2025-12-05  
-**Documentation:** See [Person-Scoped Profiles Migration Guide](./person-scoped-profiles-migration-guide.md)
+**Documentation:** See [Person-Scoped Profiles Migration Guide](./V0.5.190_person-scoped-profiles-migration-guide.md)
 
 ### Quick Summary
 
@@ -501,7 +501,7 @@ const { data } = await supabase
 - [ ] Update `pace_contact` queries to use `person_id` instead of `member_id`
 - [ ] Update profile creation logic (no `organisation_id` needed)
 - [ ] Review profile access patterns (person-scoped, not org-scoped)
-- [ ] See [Person-Scoped Profiles Migration Guide](./person-scoped-profiles-migration-guide.md) for detailed checklist
+- [ ] See [Person-Scoped Profiles Migration Guide](./V0.5.190_person-scoped-profiles-migration-guide.md) for detailed checklist
 
 ### Phase 3: Testing
 
@@ -708,7 +708,7 @@ All migration files are located in:
 
 ### Documentation
 
-- [Person-Scoped Profiles Migration Guide](./person-scoped-profiles-migration-guide.md)
+- [Person-Scoped Profiles Migration Guide](./V0.5.190_person-scoped-profiles-migration-guide.md)
 - [API & RPC Standard](../standards/02-api-and-rpc-standard.md)
 - [Database Schema Requirements](../architecture/database-schema-requirements.md)
 

package/docs/rbac/event-based-apps.md

@@ -973,7 +973,7 @@ VALUES (
 - **[API Reference](./api-reference.md)** - Complete API documentation
 - **[Examples](./examples.md)** - More complex usage patterns
 - **[Troubleshooting](./troubleshooting.md)** - Advanced troubleshooting
-- **[Migration Guide](../migration/rbac-migration.md)** - If migrating from legacy RBAC
+- **[Migration Guide](../migration/V0.4.0_rbac-migration.md)** - If migrating from legacy RBAC
 
 ## 🆘 Still Having Issues?
 

package/docs/rbac/getting-started.md

@@ -843,7 +843,7 @@ function AdaptiveComponent({ appId }) {
 - [Examples](./examples.md) - More complex examples
 - [Event-Based Apps](./event-based-apps.md) - Guide for event-based applications
 - [Troubleshooting](./troubleshooting.md) - Common issues and solutions
-- [Migration Guide](../migration/rbac-migration.md) - Migrating from legacy RBAC
+- [Migration Guide](../migration/V0.4.0_rbac-migration.md) - Migrating from legacy RBAC
 
 ## ♿ Accessibility
 

package/docs/rbac/quick-start.md

@@ -740,7 +740,7 @@ The system will automatically resolve the organisation ID from the event context
 - **[API Reference](./api-reference.md)** - Complete API documentation
 - **[Examples](./examples.md)** - More complex usage patterns
 - **[Troubleshooting](./troubleshooting.md)** - Advanced troubleshooting
-- **[Migration Guide](../migration/rbac-migration.md)** - If migrating from legacy RBAC
+- **[Migration Guide](../migration/V0.4.0_rbac-migration.md)** - If migrating from legacy RBAC
 
 ## 🆘 Still Having Issues?
 

package/docs/standards/README.md

@@ -57,6 +57,7 @@ The cursor rules cover:
 - **05-bug-reports-and-features** - Templates for issue reporting
 - **06-code-quality** - Enforce code quality standards
 - **07-tech-stack-compliance** - Enforce tech stack versions
+- **08-markup-quality** - Enforce clean markup standards, semantic HTML usage, and pace-core component patterns
 
 ### Audit Tool
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@jmruthers/pace-core",
-  "version": "0.6.1",
+  "version": "0.6.2",
   "description": "Clean, modern React component library with Tailwind v4 styling and native utilities",
   "private": false,
   "publishConfig": {
@@ -73,6 +73,7 @@
     "./core-usage-manifest.json": "./core-usage-manifest.json",
     "./cursor-rules": "./cursor-rules",
     "./scripts/install-cursor-rules": "./scripts/install-cursor-rules.cjs",
+    "./scripts/audit": "./scripts/audit/index.cjs",
     "./scripts/audit-consuming-app": "./scripts/audit-consuming-app.cjs",
     "./source": {
       "import": "./src/index.ts",

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

@@ -0,0 +1,197 @@
+#!/usr/bin/env node
+
+/**
+ * Accessibility Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Accessibility
+ * 
+ * Checks for:
+ * - Missing aria-* attributes
+ * - Missing keyboard navigation
+ * - Missing focus management
+ * - Missing alt text on images
+ */
+
+const fs = require('fs');
+const { getRelativePath, getLineNumber } = require('../utils.cjs');
+
+const accessibilityCheck = {
+  name: 'accessibility',
+  description: 'Accessibility checks (aria attributes, keyboard navigation, alt text)',
+  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 {
+        // Only check React component files
+        if (!filePath.match(/\.(tsx|jsx)$/)) {
+          continue;
+        }
+        
+        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 accessibility issues (missing alt attributes, missing form labels) 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 accessibility validation
+        const isScript = normalizedPath.startsWith('scripts/') || normalizedPath.includes('/scripts/');
+        if (isScript) {
+          continue; // Skip script files
+        }
+        
+        // Skip pace-core library components and examples - these are designed to accept accessibility props
+        // Library components accept id, aria-label, etc. via props spread
+        // Examples are demonstration code, not production code
+        const isPaceCorePackage = normalizedPath.includes('packages/core/') || normalizedPath.startsWith('packages/core/');
+        const isExample = normalizedPath.includes('/examples/');
+        const isLibraryComponent = isPaceCorePackage && !isExample;
+        
+        // Check for images without alt text
+        // Skip library components - they accept alt as a prop
+        if (!isLibraryComponent) {
+          const imgPattern = /<img[^>]*>/g;
+          let imgMatch;
+          while ((imgMatch = imgPattern.exec(content)) !== null) {
+            const imgTag = imgMatch[0];
+            // Check for alt attribute, including React props (alt=, alt =, alt={)
+            const hasAlt = imgTag.includes('alt=') || imgTag.includes('alt =') || imgTag.includes('alt={');
+            if (!hasAlt) {
+              warnings.push({
+                type: 'missing-alt-text',
+                file: relativePath,
+                line: getLineNumber(content, imgMatch.index),
+                message: 'Image element missing alt attribute',
+                recommendation: 'Add alt text to all images for accessibility: <img alt="description" ... />'
+              });
+            }
+          }
+        }
+        
+        // Check for buttons/clickable elements without aria-label or accessible text
+        const buttonPattern = /<(button|a|div)\s+[^>]*(onClick|role=["']button["'])[^>]*>/g;
+        let buttonMatch;
+        while ((buttonMatch = buttonPattern.exec(content)) !== null) {
+          const buttonTag = buttonMatch[0];
+          const hasAriaLabel = buttonTag.includes('aria-label=') || buttonTag.includes('ariaLabel=');
+          const hasAccessibleText = buttonTag.includes('>') && content.substring(buttonMatch.index).match(/<[^>]*>([^<]+)</);
+          
+          if (!hasAriaLabel && !hasAccessibleText) {
+            warnings.push({
+              type: 'missing-aria-label',
+              file: relativePath,
+              line: getLineNumber(content, buttonMatch.index),
+              message: 'Interactive element missing accessible label',
+              recommendation: 'Add aria-label or ensure element contains accessible text content'
+            });
+          }
+        }
+        
+        // Check for form inputs without labels
+        // Skip library components - they accept id, aria-label, etc. via props spread
+        // Skip examples - they're demonstration code
+        if (!isLibraryComponent && !isExample) {
+          const inputPattern = /<input[^>]*>/g;
+          let inputMatch;
+          while ((inputMatch = inputPattern.exec(content)) !== null) {
+            // Get the full input tag including multi-line attributes
+            const inputStart = inputMatch.index;
+            const afterInput = content.substring(inputStart, Math.min(content.length, inputStart + 500));
+            const inputTagEnd = afterInput.indexOf('>');
+            const fullInputTag = inputTagEnd !== -1 ? afterInput.substring(0, inputTagEnd + 1) : inputMatch[0];
+            
+            // Check for id (including React props)
+            const hasId = /id=["']([^"']+)["']|id=\{/.test(fullInputTag);
+            // Check for aria-label (including React props)
+            const hasAriaLabel = /aria-label=["']|ariaLabel=|aria-label=\{/.test(fullInputTag);
+            
+            if (hasId) {
+              const idMatch = fullInputTag.match(/id=["']([^"']+)["']/);
+              if (idMatch) {
+                const id = idMatch[1];
+                // Check if there's a corresponding label
+                const beforeInput = content.substring(Math.max(0, inputMatch.index - 200), inputMatch.index);
+                const hasLabel = new RegExp(`<label[^>]*for=["']${id}["']`, 'i').test(beforeInput);
+                
+                if (!hasLabel && !hasAriaLabel) {
+                  warnings.push({
+                    type: 'missing-input-label',
+                    file: relativePath,
+                    line: getLineNumber(content, inputMatch.index),
+                    message: 'Form input missing associated label',
+                    recommendation: 'Add a <label> element with for attribute matching input id, or use aria-label'
+                  });
+                }
+              }
+            } else if (!hasAriaLabel) {
+              warnings.push({
+                type: 'missing-input-label',
+                file: relativePath,
+                line: getLineNumber(content, inputMatch.index),
+                message: 'Form input missing id and label',
+                recommendation: 'Add id to input and corresponding label, or use aria-label'
+              });
+            }
+          }
+        }
+        
+        // Check for missing focus management in modals/dialogs
+        const dialogPattern = /<Dialog|<dialog/gi;
+        if (dialogPattern.test(content)) {
+          // Skip Dialog.tsx itself - it IS the Dialog component
+          if (normalizedPath.includes('/Dialog/Dialog.tsx') || normalizedPath.includes('/Dialog/Dialog.jsx')) {
+            continue; // Skip the Dialog component file itself
+          }
+          
+          // Check if Dialog from pace-core is used (which handles focus automatically)
+          // Check for both published package import and relative imports (within pace-core repo)
+          const usesPaceCoreDialog = content.includes('from \'@jmruthers/pace-core\'') ||
+                                    content.includes('from "@jmruthers/pace-core"') ||
+                                    content.includes('from \'../Dialog') ||
+                                    content.includes('from "../Dialog') ||
+                                    content.includes('from \'../../Dialog') ||
+                                    content.includes('from "../../Dialog') ||
+                                    content.includes('from \'../../../Dialog') ||
+                                    content.includes('from "../../../Dialog') ||
+                                    content.includes('from \'./Dialog') ||
+                                    content.includes('from "./Dialog');
+          
+          if (!usesPaceCoreDialog) {
+            suggestions.push({
+              type: 'dialog-focus-management',
+              file: relativePath,
+              message: 'Custom dialog implementation detected',
+              recommendation: 'Use Dialog component from @jmruthers/pace-core which handles focus management automatically'
+            });
+          }
+        }
+        
+        // Check for color contrast issues (heuristic - check for color props without sufficient contrast)
+        const colorPattern = /(?:color|bg-|text-)=["']([^"']+)["']/g;
+        // This is a simplified check - full implementation would need color contrast calculation
+        // For now, just suggest using pace-core components which handle contrast
+        
+      } catch (error) {
+        // Skip files with errors
+      }
+    }
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+module.exports = accessibilityCheck;

package/scripts/audit/core/checks/api-usage.cjs

@@ -0,0 +1,191 @@
+#!/usr/bin/env node
+
+/**
+ * API Usage Patterns Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/ApiUsage
+ * 
+ * Checks for:
+ * - Incorrect usage of pace-core hooks
+ * - Missing loading states
+ * - Missing error states
+ * - Race conditions in async operations
+ */
+
+const fs = require('fs');
+const { getRelativePath, getLineNumber } = require('../utils.cjs');
+
+const apiUsageCheck = {
+  name: 'api-usage',
+  description: 'API usage patterns (hook usage, loading/error states)',
+  severity: 'warning',
+  
+  async run(context) {
+    const { projectRoot, files } = context;
+    const issues = [];
+    const warnings = [];
+    const suggestions = [];
+    
+    if (!files || files.length === 0) {
+      return { issues, warnings, suggestions };
+    }
+    
+    // pace-core hooks that return loading/error states
+    const asyncHooks = {
+      'useUnifiedAuth': ['loading', 'error'],
+      'useOrganisations': ['isLoading', 'error'],
+      'useEvents': ['isLoading', 'error'],
+      'useSecureSupabase': [],
+      'useFileReference': ['isLoading', 'error'],
+      'useRBAC': ['isLoading', 'error']
+    };
+    
+    for (const filePath of files) {
+      try {
+        // Only check React component files
+        if (!filePath.match(/\.(tsx|jsx)$/)) {
+          continue;
+        }
+        
+        const content = fs.readFileSync(filePath, 'utf8');
+        const relativePath = getRelativePath(filePath, projectRoot);
+        const normalizedPath = relativePath.replace(/\\/g, '/');
+        
+        // Skip pace-core package files - api-usage check is for consuming applications, not the library itself
+        // Note: Library components may intentionally not check loading/error states in all cases
+        // (e.g., internal components that assume context is already set up)
+        const isPaceCorePackage = normalizedPath.includes('packages/core/') || normalizedPath.startsWith('packages/core/');
+        if (isPaceCorePackage) {
+          continue; // Skip library files (including examples)
+        }
+        
+        // Skip root-level src directory - in pace-core repository, this is a demo/showcase app
+        const isRootSrc = normalizedPath.startsWith('src/') && !normalizedPath.includes('packages/');
+        if (isRootSrc) {
+          continue; // Skip demo app files
+        }
+        
+        // Skip scripts directory - utility scripts don't need API usage validation
+        const isScript = normalizedPath.startsWith('scripts/') || normalizedPath.includes('/scripts/');
+        if (isScript) {
+          continue; // Skip script files
+        }
+        
+        // Check each async hook
+        Object.entries(asyncHooks).forEach(([hookName, expectedStates]) => {
+          if (!content.includes(hookName)) {
+            return;
+          }
+          
+          const hookPattern = new RegExp(`const\\s+[^=]+=\\s+${hookName}\\s*\\(`, 'g');
+          let hookMatch;
+          while ((hookMatch = hookPattern.exec(content)) !== null) {
+            // Check the entire component, not just 300 chars after hook
+            // React's Rules of Hooks require all hooks to be called before conditional returns,
+            // so state checks may occur later in the component
+            const hookLine = getLineNumber(content, hookMatch.index);
+            const lines = content.split('\n');
+            const hookLineIndex = hookLine - 1;
+            
+            // Get the rest of the component after this hook
+            const afterHookContent = lines.slice(hookLineIndex).join('\n');
+            
+            // Check if loading state is used
+            if (expectedStates.includes('loading') || expectedStates.includes('isLoading')) {
+              const loadingState = expectedStates.includes('loading') ? 'loading' : 'isLoading';
+              // Check for loading state usage in the entire component
+              // Also check for common patterns: isLoading, authLoading, etc.
+              const loadingPattern = new RegExp(`\\b(${loadingState}|authLoading|rbacLoading|orgLoading)\\b`);
+              if (!loadingPattern.test(afterHookContent)) {
+                warnings.push({
+                  type: 'missing-loading-state',
+                  file: relativePath,
+                  line: hookLine,
+                  message: `${hookName} returns loading state but it's not being checked`,
+                  recommendation: `Check ${loadingState} state and show loading UI while data is fetching. You can check loading state after all hooks are called (required by React's Rules of Hooks).`
+                });
+              }
+            }
+            
+            // Check if error state is used
+            if (expectedStates.includes('error')) {
+              // Check for error state usage in the entire component
+              // Also check for common patterns: error, authError, orgError, rbacError
+              // Also check for null checks for useSecureSupabase
+              const errorPattern = /\b(error|authError|orgError|rbacError)\b/;
+              const hasNullCheck = hookName === 'useSecureSupabase' && /secureSupabase\s*===?\s*null|!secureSupabase/.test(afterHookContent);
+              
+              if (!errorPattern.test(afterHookContent) && !hasNullCheck) {
+                warnings.push({
+                  type: 'missing-error-state',
+                  file: relativePath,
+                  line: hookLine,
+                  message: `${hookName} returns error state but it's not being checked`,
+                  recommendation: 'Check error state and handle errors appropriately. You can check error state after all hooks are called (required by React\'s Rules of Hooks), or handle errors via useEffect hooks. For useSecureSupabase, null checks are also valid error handling.'
+                });
+              }
+            }
+          }
+        });
+        
+        // Check for race conditions in async operations
+        const asyncOperationPattern = /(?:const|let)\s+(\w+)\s*=\s*(?:await\s+)?(\w+)\.(from|rpc|select)/g;
+        let asyncMatch;
+        while ((asyncMatch = asyncOperationPattern.exec(content)) !== null) {
+          const varName = asyncMatch[1];
+          const operation = asyncMatch[0];
+          
+          // Check if this is in a useEffect without cleanup
+          const beforeMatch = content.substring(Math.max(0, asyncMatch.index - 500), asyncMatch.index);
+          const isInUseEffect = /useEffect\s*\(/.test(beforeMatch);
+          
+          if (isInUseEffect) {
+            // Check if there's cleanup/abort
+            const afterMatch = content.substring(asyncMatch.index, Math.min(content.length, asyncMatch.index + 500));
+            const hasCleanup = /return\s+\(\)\s*=>|AbortController|signal/.test(afterMatch);
+            
+            if (!hasCleanup) {
+              suggestions.push({
+                type: 'potential-race-condition',
+                file: relativePath,
+                line: getLineNumber(content, asyncMatch.index),
+                message: 'Async operation in useEffect without cleanup - potential race condition',
+                recommendation: 'Add cleanup function to cancel requests when component unmounts or dependencies change'
+              });
+            }
+          }
+        }
+        
+        // Check for missing request cancellation
+        const fetchPattern = /fetch\s*\(|axios\.(get|post|put|delete)\s*\(/g;
+        let fetchMatch;
+        while ((fetchMatch = fetchPattern.exec(content)) !== null) {
+          const beforeMatch = content.substring(Math.max(0, fetchMatch.index - 200), fetchMatch.index);
+          const isInUseEffect = /useEffect\s*\(/.test(beforeMatch);
+          
+          if (isInUseEffect) {
+            const afterMatch = content.substring(fetchMatch.index, Math.min(content.length, fetchMatch.index + 500));
+            const hasAbort = /AbortController|signal|abort/.test(afterMatch);
+            
+            if (!hasAbort) {
+              suggestions.push({
+                type: 'missing-abort',
+                file: relativePath,
+                line: getLineNumber(content, fetchMatch.index),
+                message: 'Fetch/axios request without abort signal',
+                recommendation: 'Use AbortController to cancel requests when component unmounts'
+              });
+            }
+          }
+        }
+        
+      } catch (error) {
+        // Skip files with errors
+      }
+    }
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+module.exports = apiUsageCheck;

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

@@ -0,0 +1,142 @@
+#!/usr/bin/env node
+
+/**
+ * Bundle Analysis Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Bundle
+ * 
+ * Checks for:
+ * - Large bundle sizes
+ * - Duplicate dependencies
+ * - Unused code imports
+ * - Missing code splitting opportunities
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getRelativePath } = require('../utils.cjs');
+
+const bundleCheck = {
+  name: 'bundle',
+  description: 'Bundle analysis (size, duplicates, code splitting)',
+  severity: 'suggestion',
+  
+  async run(context) {
+    const { projectRoot } = context;
+    const issues = [];
+    const warnings = [];
+    const suggestions = [];
+    
+    // Skip if this is the pace-core repository itself
+    // Detect pace-core repository by checking if packages/core exists
+    // Bundle analysis is more relevant for consuming applications, not the library itself
+    const packagesCorePath = path.join(projectRoot, 'packages', 'core');
+    const isPaceCoreRepository = fs.existsSync(packagesCorePath);
+    
+    // Check for bundle analysis reports
+    const bundleReportPaths = [
+      path.join(projectRoot, 'dist', 'stats.html'),
+      path.join(projectRoot, 'dist', 'bundle-analysis.json'),
+      path.join(projectRoot, '.vite', 'dist', 'stats.html')
+    ];
+    
+    let hasBundleReport = false;
+    for (const reportPath of bundleReportPaths) {
+      if (fs.existsSync(reportPath)) {
+        hasBundleReport = true;
+        break;
+      }
+    }
+    
+    // Skip bundle analysis suggestion if this is the pace-core repository
+    // The library itself doesn't need bundle analysis in the same way as consuming apps
+    if (!hasBundleReport && !isPaceCoreRepository) {
+      suggestions.push({
+        type: 'missing-bundle-analysis',
+        file: 'package.json',
+        message: 'No bundle analysis report found',
+        recommendation: 'Run bundle analysis to identify optimization opportunities: npm run build -- --analyze or use vite-bundle-visualizer'
+      });
+      return { issues, warnings, suggestions };
+    }
+    
+    // Check dist folder size
+    const distPath = path.join(projectRoot, 'dist');
+    if (fs.existsSync(distPath)) {
+      try {
+        const distSize = getDirectorySize(distPath);
+        const sizeMB = distSize / (1024 * 1024);
+        
+        if (sizeMB > 5) {
+          warnings.push({
+            type: 'large-bundle',
+            file: 'dist/',
+            message: `Bundle size is ${sizeMB.toFixed(2)}MB, which is quite large`,
+            recommendation: 'Consider code splitting, lazy loading, and removing unused dependencies'
+          });
+        }
+      } catch (error) {
+        // Skip if can't calculate size
+      }
+    }
+    
+    // Check for duplicate imports (same package imported multiple ways)
+    // This is a simplified check - full implementation would analyze actual bundle
+    const packageJsonPath = path.join(projectRoot, 'package.json');
+    if (fs.existsSync(packageJsonPath)) {
+      try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+        const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+        
+        // Check for potential duplicates (e.g., lodash and lodash-es)
+        // Note: '@supabase/supabase-js' (client library) and 'supabase' (CLI tool) are NOT duplicates
+        // - '@supabase/supabase-js' is the JavaScript client library (runtime dependency)
+        // - 'supabase' is the Supabase CLI tool (dev dependency for migrations, local dev)
+        // The CLI tool is not bundled in the application, so having both is correct
+        const duplicatePatterns = [
+          ['lodash', 'lodash-es'],
+          ['date-fns', 'date-fns-tz']
+        ];
+        
+        duplicatePatterns.forEach(([dep1, dep2]) => {
+          if (allDeps[dep1] && allDeps[dep2]) {
+            warnings.push({
+              type: 'duplicate-dependency',
+              file: 'package.json',
+              message: `Both '${dep1}' and '${dep2}' are installed - may cause duplicate code in bundle`,
+              recommendation: `Remove one and use pace-core alternatives if available, or ensure only one is bundled`
+            });
+          }
+        });
+      } catch (error) {
+        // Skip if can't parse package.json
+      }
+    }
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+/**
+ * Calculate directory size recursively
+ */
+function getDirectorySize(dirPath) {
+  let size = 0;
+  try {
+    const items = fs.readdirSync(dirPath);
+    items.forEach(item => {
+      const itemPath = path.join(dirPath, item);
+      const stat = fs.statSync(itemPath);
+      if (stat.isDirectory()) {
+        size += getDirectorySize(itemPath);
+      } else {
+        size += stat.size;
+      }
+    });
+  } catch (error) {
+    // Skip if can't read
+  }
+  return size;
+}
+
+module.exports = bundleCheck;