@jmruthers/pace-core 0.5.193 → 0.6.2

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

@@ -0,0 +1,54 @@
+#!/usr/bin/env node
+
+/**
+ * Config Files Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Config
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const configCheck = {
+  name: 'config',
+  description: 'Config file checks (package.json, tsconfig.json, vite.config.ts, etc.)',
+  severity: 'error',
+  
+  async run(context) {
+    const { projectRoot } = context;
+    const issues = [];
+    const warnings = [];
+    
+    const requiredConfigs = [
+      { file: 'package.json', severity: 'error' },
+      { file: 'tsconfig.json', severity: 'error' },
+      { file: 'vite.config.ts', severity: 'warning' },
+      { file: 'vitest.config.ts', severity: 'warning' }
+    ];
+    
+    requiredConfigs.forEach(({ file, severity }) => {
+      const filePath = path.join(projectRoot, file);
+      if (!fs.existsSync(filePath)) {
+        if (severity === 'error') {
+          issues.push({
+            type: 'missing-config',
+            file,
+            message: `Required config file '${file}' is missing`,
+            recommendation: `Create '${file}' file`
+          });
+        } else {
+          warnings.push({
+            type: 'missing-config',
+            file,
+            message: `Recommended config file '${file}' is missing`,
+            recommendation: `Consider creating '${file}' file`
+          });
+        }
+      }
+    });
+    
+    return { issues, warnings, suggestions: [] };
+  }
+};
+
+module.exports = configCheck;

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

@@ -0,0 +1,84 @@
+#!/usr/bin/env node
+
+/**
+ * Test Coverage Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Coverage
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const coverageCheck = {
+  name: 'coverage',
+  description: 'Test coverage checks',
+  severity: 'warning',
+  
+  async run(context) {
+    const { projectRoot } = context;
+    const issues = [];
+    const warnings = [];
+    
+    // Try to find coverage report
+    const coveragePaths = [
+      path.join(projectRoot, 'coverage', 'coverage-summary.json'),
+      path.join(projectRoot, 'coverage', 'coverage-final.json')
+    ];
+    
+    let coverageData = null;
+    for (const coveragePath of coveragePaths) {
+      if (fs.existsSync(coveragePath)) {
+        try {
+          coverageData = JSON.parse(fs.readFileSync(coveragePath, 'utf8'));
+          break;
+        } catch (error) {
+          // Continue to next path
+        }
+      }
+    }
+    
+    if (!coverageData) {
+      warnings.push({
+        type: 'coverage',
+        file: 'coverage/',
+        message: 'No coverage report found. Run tests with coverage to get accurate metrics.',
+        recommendation: 'Run tests with coverage: npm run test:coverage'
+      });
+      return { issues, warnings, suggestions: [], metrics: null };
+    }
+    
+    // Check coverage thresholds
+    const total = coverageData.total || {};
+    const lines = total.lines?.pct || 0;
+    const functions = total.functions?.pct || 0;
+    const branches = total.branches?.pct || 0;
+    const statements = total.statements?.pct || 0;
+    
+    if (lines < 70) {
+      warnings.push({
+        type: 'coverage',
+        file: 'coverage/',
+        message: `Line coverage is ${lines.toFixed(1)}%, below recommended 70%`,
+        recommendation: 'Increase test coverage to meet the 70% threshold'
+      });
+    }
+    
+    if (functions < 70) {
+      warnings.push({
+        type: 'coverage',
+        file: 'coverage/',
+        message: `Function coverage is ${functions.toFixed(1)}%, below recommended 70%`,
+        recommendation: 'Increase test coverage to meet the 70% threshold'
+      });
+    }
+    
+    return {
+      issues,
+      warnings,
+      suggestions: [],
+      metrics: { lines, functions, branches, statements }
+    };
+  }
+};
+
+module.exports = coverageCheck;

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

@@ -0,0 +1,454 @@
+#!/usr/bin/env node
+
+/**
+ * Dependencies Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Dependencies
+ * 
+ * Checks for:
+ * - Outdated pace-core version
+ * - Security vulnerabilities
+ * - Unused dependencies
+ * - Missing peer dependencies
+ * - Version mismatches
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getPackageInfo, findSourceFiles } = require('../utils.cjs');
+
+/**
+ * Extract package name from import/require path
+ */
+function extractPackageName(modulePath) {
+  if (modulePath.startsWith('@')) {
+    const parts = modulePath.split('/');
+    if (parts.length >= 2) {
+      return `${parts[0]}/${parts[1]}`;
+    }
+  } else {
+    return modulePath.split('/')[0];
+  }
+  return null;
+}
+
+/**
+ * Find all config files in the project
+ */
+function findConfigFiles(projectRoot) {
+  const configFiles = [];
+  const configPatterns = [
+    'vite.config.{ts,js,mjs,cjs}',
+    'vitest.config.{ts,js,mjs,cjs}',
+    'tsconfig.json',
+    '.eslintrc.{js,json,cjs}',
+    'eslint.config.{js,mjs,cjs}',
+    'tailwind.config.{ts,js}',
+    'postcss.config.{js,cjs}',
+    'babel.config.{js,json}',
+    'jest.config.{js,ts}',
+    'webpack.config.{js,ts}',
+    'rollup.config.{js,ts}',
+    'next.config.{js,mjs}',
+    'remix.config.{js,ts}',
+  ];
+  
+  // Check root directory
+  const rootFiles = fs.readdirSync(projectRoot);
+  rootFiles.forEach(file => {
+    configPatterns.forEach(pattern => {
+      const regex = new RegExp('^' + pattern.replace(/\{.*?\}/g, '.*') + '$');
+      if (regex.test(file)) {
+        const fullPath = path.join(projectRoot, file);
+        if (fs.existsSync(fullPath)) {
+          configFiles.push(fullPath);
+        }
+      }
+    });
+  });
+  
+  return configFiles;
+}
+
+/**
+ * Get pace-core peer dependencies
+ */
+function getPaceCorePeerDeps(projectRoot) {
+  try {
+    // Try to find pace-core in node_modules
+    const paceCorePath = path.join(projectRoot, 'node_modules', '@jmruthers', 'pace-core', 'package.json');
+    if (fs.existsSync(paceCorePath)) {
+      const paceCorePkg = JSON.parse(fs.readFileSync(paceCorePath, 'utf8'));
+      return paceCorePkg.peerDependencies || {};
+    }
+  } catch (error) {
+    // If we can't find it, return empty object
+  }
+  return {};
+}
+
+/**
+ * Check if a dependency is used in config files
+ */
+function checkConfigFiles(configFiles, depName) {
+  for (const configFile of configFiles) {
+    try {
+      const content = fs.readFileSync(configFile, 'utf8');
+      
+      // Check for direct imports/requires
+      const importPatterns = [
+        /from\s+['"]([^'"]+)['"]/g,
+        /require\(['"]([^'"]+)['"]\)/g,
+        /import\(['"]([^'"]+)['"]\)/g,
+      ];
+      
+      for (const pattern of importPatterns) {
+        let match;
+        while ((match = pattern.exec(content)) !== null) {
+          const modulePath = match[1];
+          const pkgName = extractPackageName(modulePath);
+          if (pkgName === depName) {
+            return true;
+          }
+        }
+      }
+      
+      // Check for string references (e.g., in optimizeDeps, plugins, etc.)
+      // This is a heuristic - check if the package name appears as a string
+      const depNameEscaped = depName.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+      const stringRefPattern = new RegExp(`['"]${depNameEscaped}['"]`, 'g');
+      if (stringRefPattern.test(content)) {
+        return true;
+      }
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if a dependency is used in CSS or other non-JS files
+ */
+function checkNonJsFiles(projectRoot, depName) {
+  const cssFiles = [];
+  const cssExtensions = ['.css', '.scss', '.sass', '.less', '.styl'];
+  
+  try {
+    const srcPath = path.join(projectRoot, 'src');
+    if (fs.existsSync(srcPath)) {
+      const walkDir = (dir) => {
+        const files = fs.readdirSync(dir);
+        files.forEach(file => {
+          const fullPath = path.join(dir, file);
+          const stat = fs.statSync(fullPath);
+          if (stat.isDirectory() && !file.startsWith('.') && file !== 'node_modules') {
+            walkDir(fullPath);
+          } else if (stat.isFile()) {
+            const ext = path.extname(file);
+            if (cssExtensions.includes(ext)) {
+              cssFiles.push(fullPath);
+            }
+          }
+        });
+      };
+      walkDir(srcPath);
+    }
+  } catch (error) {
+    // Skip if can't read
+  }
+  
+  // Check CSS files for @import statements
+  for (const cssFile of cssFiles) {
+    try {
+      const content = fs.readFileSync(cssFile, 'utf8');
+      // Check for @import statements that might reference packages
+      const importPattern = /@import\s+['"]([^'"]+)['"]/g;
+      let match;
+      while ((match = importPattern.exec(content)) !== null) {
+        const modulePath = match[1];
+        const pkgName = extractPackageName(modulePath);
+        if (pkgName === depName) {
+          return true;
+        }
+      }
+    } catch (error) {
+      // Skip files we can't read
+    }
+  }
+  
+  return false;
+}
+
+const dependenciesCheck = {
+  name: 'dependencies',
+  description: 'Dependency analysis (outdated versions, security, unused deps)',
+  severity: 'warning',
+  
+  async run(context) {
+    const { projectRoot } = context;
+    const issues = [];
+    const warnings = [];
+    const suggestions = [];
+    
+    const packageJson = getPackageInfo(projectRoot);
+    if (!packageJson) {
+      return { issues, warnings, suggestions };
+    }
+    
+    // Skip dependency checks if this is the pace-core repository itself
+    // Detect pace-core repository by checking if packages/core exists
+    const packagesCorePath = path.join(projectRoot, 'packages', 'core');
+    const isPaceCoreRepository = fs.existsSync(packagesCorePath);
+    
+    const allDeps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+    const devDeps = packageJson.devDependencies || {};
+    
+    // Get pace-core peer dependencies
+    const paceCorePeerDeps = getPaceCorePeerDeps(projectRoot);
+    
+    // Check pace-core version (skip if this is the pace-core repository itself)
+    if (!isPaceCoreRepository) {
+      const paceCoreVersion = allDeps['@jmruthers/pace-core'];
+      if (paceCoreVersion) {
+        // Check if version is outdated (simplified - would need to check npm registry)
+        if (paceCoreVersion.startsWith('^') || paceCoreVersion.startsWith('~')) {
+          // Version range - this is fine
+        } else if (paceCoreVersion.match(/^\d+\.\d+\.\d+$/)) {
+          // Exact version - suggest using range
+          suggestions.push({
+            type: 'exact-version',
+            file: 'package.json',
+            message: `pace-core is pinned to exact version ${paceCoreVersion}`,
+            recommendation: 'Consider using a version range (^ or ~) to receive patch/minor updates automatically'
+          });
+        }
+      } else {
+        issues.push({
+          type: 'missing-pace-core',
+          file: 'package.json',
+          message: '@jmruthers/pace-core is not in dependencies',
+          recommendation: 'Add @jmruthers/pace-core to your dependencies'
+        });
+      }
+    }
+    
+    // Collect all files to scan
+    // Skip unused dependency checks if this is the pace-core repository itself
+    // The library's dependencies are used in packages/core/src/, not in the root src/
+    const sourceFiles = [];
+    if (!isPaceCoreRepository) {
+      try {
+        const srcPath = path.join(projectRoot, 'src');
+        if (fs.existsSync(srcPath)) {
+          sourceFiles.push(...findSourceFiles(srcPath));
+        }
+      } catch (error) {
+        // Skip if can't read source files
+      }
+    }
+    
+    // Also scan config files
+    const configFiles = findConfigFiles(projectRoot);
+    
+    // Build set of imported packages from source files
+    const importedPackages = new Set();
+    
+    // Scan source files
+    sourceFiles.forEach(filePath => {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        // Check for ES6 imports
+        const importPattern = /from\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importPattern.exec(content)) !== null) {
+          const modulePath = match[1];
+          const pkgName = extractPackageName(modulePath);
+          if (pkgName) {
+            importedPackages.add(pkgName);
+          }
+        }
+        // Check for require() statements
+        const requirePattern = /require\(['"]([^'"]+)['"]\)/g;
+        while ((match = requirePattern.exec(content)) !== null) {
+          const modulePath = match[1];
+          const pkgName = extractPackageName(modulePath);
+          if (pkgName) {
+            importedPackages.add(pkgName);
+          }
+        }
+      } catch (error) {
+        // Skip files with errors
+      }
+    });
+    
+    // Scan config files for imports
+    configFiles.forEach(filePath => {
+      try {
+        const content = fs.readFileSync(filePath, 'utf8');
+        const importPattern = /from\s+['"]([^'"]+)['"]/g;
+        let match;
+        while ((match = importPattern.exec(content)) !== null) {
+          const modulePath = match[1];
+          const pkgName = extractPackageName(modulePath);
+          if (pkgName) {
+            importedPackages.add(pkgName);
+          }
+        }
+        const requirePattern = /require\(['"]([^'"]+)['"]\)/g;
+        while ((match = requirePattern.exec(content)) !== null) {
+          const modulePath = match[1];
+          const pkgName = extractPackageName(modulePath);
+          if (pkgName) {
+            importedPackages.add(pkgName);
+          }
+        }
+      } catch (error) {
+        // Skip files with errors
+      }
+    });
+    
+    // Known build tools and dev dependencies that are commonly used but not directly imported
+    const knownBuildTools = [
+      'vite',
+      'typescript',
+      'eslint',
+      'prettier',
+      'vitest',
+      '@types',
+      '@vitejs',
+      '@testing-library',
+      'jsdom',
+      'globals',
+      'tailwindcss',
+      '@tailwindcss',
+      'postcss',
+      'autoprefixer',
+      'babel',
+      'webpack',
+      'rollup',
+      'tsup',
+      'esbuild',
+      'lovable-tagger',
+      'babel-plugin-react-compiler',
+    ];
+    
+    // Check for potentially unused dependencies
+    // Skip this check if running on the pace-core repository itself
+    // The library's dependencies are used in packages/core/src/, not in the root src/ (demo app)
+    if (!isPaceCoreRepository) {
+      Object.keys(allDeps).forEach(dep => {
+        // Skip if it's a known build tool
+        if (knownBuildTools.some(tool => dep.includes(tool) || dep.startsWith(tool))) {
+          return;
+        }
+        
+        // Skip if it's a peer dependency of pace-core
+        if (paceCorePeerDeps[dep]) {
+          return;
+        }
+        
+        // Skip if it's pace-core itself
+        if (dep === '@jmruthers/pace-core') {
+          return;
+        }
+      
+      // Check if package is imported in source files
+      if (importedPackages.has(dep)) {
+        return;
+      }
+      
+      // Check if it's used in config files
+      if (checkConfigFiles(configFiles, dep)) {
+        return;
+      }
+      
+      // Check if it's used in CSS or other non-JS files
+      if (checkNonJsFiles(projectRoot, dep)) {
+        return;
+      }
+      
+      // For dev dependencies, provide more context
+      const isDevDep = dep in devDeps;
+      const context = [];
+      
+      if (isDevDep) {
+        context.push('This is a dev dependency and may be used by build tools or test frameworks');
+      }
+      
+      // Check if it might be a transitive dependency needed by pace-core
+      if (paceCoreVersion) {
+        context.push('This may be required by @jmruthers/pace-core as a transitive dependency');
+      }
+      
+      // Only warn if we're reasonably sure it's unused
+      // For runtime dependencies, be more strict
+      if (!isDevDep) {
+        // Check if it's in vite.config.ts optimizeDeps (common for pace-core peer deps)
+        const viteConfigPath = path.join(projectRoot, 'vite.config.ts');
+        const viteConfigJsPath = path.join(projectRoot, 'vite.config.js');
+        let isInViteConfig = false;
+        
+        for (const configPath of [viteConfigPath, viteConfigJsPath]) {
+          if (fs.existsSync(configPath)) {
+            try {
+              const viteContent = fs.readFileSync(configPath, 'utf8');
+              if (viteContent.includes(dep)) {
+                isInViteConfig = true;
+                break;
+              }
+            } catch (error) {
+              // Skip if can't read
+            }
+          }
+        }
+        
+        const recommendation = `Verify if '${dep}' is actually used. ${context.length > 0 ? context.join(' ') : ''}${isInViteConfig ? 'This dependency is referenced in vite.config.ts, which suggests it may be required by pace-core components. ' : ''}If it's a peer dependency of @jmruthers/pace-core (check pace-core's package.json), it's required even if not directly imported. If confirmed unused, remove it to reduce bundle size.`;
+        
+        warnings.push({
+          type: 'unused-dependency',
+          file: 'package.json',
+          message: `Runtime dependency '${dep}' may be unused`,
+          recommendation: recommendation
+        });
+      } else {
+        // For dev dependencies, only suggest (lower severity)
+        suggestions.push({
+          type: 'potentially-unused-dev-dependency',
+          file: 'package.json',
+          message: `Dev dependency '${dep}' may be unused`,
+          recommendation: `Check if '${dep}' is used in build configs, test files, or by pace-core. ${context.join(' ')}If confirmed unused, you can remove it.`
+        });
+      }
+    });
+    }
+    
+    // Check for missing peer dependencies from pace-core
+    Object.keys(paceCorePeerDeps).forEach(peerDep => {
+      if (!allDeps[peerDep]) {
+        warnings.push({
+          type: 'missing-peer-dependency',
+          file: 'package.json',
+          message: `Peer dependency '${peerDep}' is missing but required by @jmruthers/pace-core`,
+          recommendation: `Install '${peerDep}' as it's required by pace-core. Run: npm install ${peerDep}`
+        });
+      }
+    });
+    
+    // Check for version mismatches (e.g., React versions)
+    const reactVersion = allDeps.react;
+    const reactDomVersion = allDeps['react-dom'];
+    if (reactVersion && reactDomVersion && reactVersion !== reactDomVersion) {
+      issues.push({
+        type: 'version-mismatch',
+        file: 'package.json',
+        message: `React version mismatch: react@${reactVersion} vs react-dom@${reactDomVersion}`,
+        recommendation: 'React and react-dom versions must match exactly'
+      });
+    }
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+module.exports = dependenciesCheck;