@jmruthers/pace-core 0.6.1 → 0.6.2

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

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+
+/**
+ * Testing Patterns Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/Testing
+ * 
+ * Checks for:
+ * - Missing test files for critical components
+ * - Test files without assertions
+ * - Missing integration tests for RBAC flows
+ */
+
+const fs = require('fs');
+const path = require('path');
+const { getRelativePath } = require('../utils.cjs');
+
+const testingCheck = {
+  name: 'testing',
+  description: 'Testing patterns (test coverage, missing tests)',
+  severity: 'suggestion',
+  
+  async run(context) {
+    const { projectRoot, files } = context;
+    const issues = [];
+    const warnings = [];
+    const suggestions = [];
+    
+    if (!files || files.length === 0) {
+      return { issues, warnings, suggestions };
+    }
+    
+    // Find all component files
+    const componentFiles = files.filter(f => f.match(/\.(tsx|jsx)$/) && 
+                                             !f.includes('.test.') && 
+                                             !f.includes('.spec.'));
+    
+    // Find all test files
+    const testFiles = files.filter(f => f.match(/\.(test|spec)\.(ts|tsx|js|jsx)$/));
+    const testFileSet = new Set(testFiles.map(f => {
+      // Get base name without .test/.spec
+      return f.replace(/\.(test|spec)\.(ts|tsx|js|jsx)$/, '');
+    }));
+    
+    // Check for components without tests
+    componentFiles.forEach(componentFile => {
+      const baseName = componentFile.replace(/\.(tsx|jsx)$/, '');
+      const hasTest = testFileSet.has(baseName + '.ts') || 
+                     testFileSet.has(baseName + '.tsx') ||
+                     testFileSet.has(baseName + '.js') ||
+                     testFileSet.has(baseName + '.jsx');
+      
+      if (!hasTest) {
+        const relativePath = getRelativePath(componentFile, projectRoot);
+        
+        // Check if it's a critical component (has RBAC, auth, or is exported)
+        const content = fs.readFileSync(componentFile, 'utf8');
+        const isCritical = content.includes('usePermissions') ||
+                          content.includes('useCan') ||
+                          content.includes('PagePermissionGuard') ||
+                          content.includes('useUnifiedAuth') ||
+                          content.match(/^export\s+(default\s+)?(function|const|class)\s+\w+/m);
+        
+        if (isCritical) {
+          warnings.push({
+            type: 'missing-test',
+            file: relativePath,
+            message: 'Critical component missing test file',
+            recommendation: `Create a test file for this component: ${path.basename(baseName)}.test.tsx`
+          });
+        } else {
+          suggestions.push({
+            type: 'missing-test',
+            file: relativePath,
+            message: 'Component missing test file',
+            recommendation: `Consider adding tests for this component: ${path.basename(baseName)}.test.tsx`
+          });
+        }
+      }
+    });
+    
+    // Check test files for assertions
+    testFiles.forEach(testFile => {
+      try {
+        const content = fs.readFileSync(testFile, 'utf8');
+        const relativePath = getRelativePath(testFile, projectRoot);
+        
+        // Check for test assertions
+        const hasAssertions = /expect\(|assert\(|toBe\(|toEqual\(|toMatch\(/.test(content);
+        
+        if (!hasAssertions) {
+          warnings.push({
+            type: 'test-without-assertions',
+            file: relativePath,
+            message: 'Test file has no assertions',
+            recommendation: 'Add assertions to verify test behavior'
+          });
+        }
+        
+        // Check for RBAC-related tests
+        if (content.includes('usePermissions') || content.includes('useCan') || content.includes('PagePermissionGuard')) {
+          const hasRBACTests = /permission|rbac|access|role/i.test(content);
+          if (!hasRBACTests) {
+            suggestions.push({
+              type: 'missing-rbac-tests',
+              file: relativePath,
+              message: 'Component uses RBAC but tests may not cover permission scenarios',
+              recommendation: 'Add tests for different permission levels and access scenarios'
+            });
+          }
+        }
+        
+      } catch (error) {
+        // Skip files with errors
+      }
+    });
+    
+    return { issues, warnings, suggestions };
+  }
+};
+
+module.exports = testingCheck;

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

@@ -0,0 +1,61 @@
+#!/usr/bin/env node
+
+/**
+ * TypeScript Config Check Module
+ * @package @jmruthers/pace-core
+ * @module Audit/Checks/TypeScript
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+const typescriptCheck = {
+  name: 'typescript',
+  description: 'TypeScript configuration checks (strict mode, etc.)',
+  severity: 'error',
+  
+  async run(context) {
+    const { projectRoot } = context;
+    const issues = [];
+    const warnings = [];
+    
+    const tsconfigPath = path.join(projectRoot, 'tsconfig.json');
+    if (!fs.existsSync(tsconfigPath)) {
+      return { issues, warnings, suggestions: [] };
+    }
+    
+    try {
+      const tsconfig = JSON.parse(fs.readFileSync(tsconfigPath, 'utf8'));
+      const compilerOptions = tsconfig.compilerOptions || {};
+      
+      if (!compilerOptions.strict) {
+        issues.push({
+          type: 'typescript-config',
+          file: 'tsconfig.json',
+          message: 'TypeScript strict mode is not enabled',
+          recommendation: 'Set "strict": true in tsconfig.json'
+        });
+      }
+      
+      if (compilerOptions.noImplicitAny === false) {
+        issues.push({
+          type: 'typescript-config',
+          file: 'tsconfig.json',
+          message: 'noImplicitAny is disabled',
+          recommendation: 'Set "noImplicitAny": true in tsconfig.json'
+        });
+      }
+    } catch (error) {
+      warnings.push({
+        type: 'typescript-config',
+        file: 'tsconfig.json',
+        message: `Could not parse tsconfig.json: ${error.message}`,
+        recommendation: 'Check that tsconfig.json is valid JSON'
+      });
+    }
+    
+    return { issues, warnings, suggestions: [] };
+  }
+};
+
+module.exports = typescriptCheck;

package/scripts/audit/core/scanner.cjs

@@ -0,0 +1,199 @@
+#!/usr/bin/env node
+
+/**
+ * Core scanning engine that orchestrates all checks
+ * @package @jmruthers/pace-core
+ * @module Audit/Scanner
+ */
+
+const { findProjectRoot, findSourceFiles } = require('./utils.cjs');
+
+/**
+ * Scanner class that orchestrates check execution
+ */
+class Scanner {
+  constructor(projectRoot = null) {
+    this.projectRoot = projectRoot || findProjectRoot();
+    this.checks = [];
+    this.context = {
+      projectRoot: this.projectRoot,
+      files: null,
+      packageJson: null,
+      manifest: null
+    };
+  }
+
+  /**
+   * Register a check module
+   * @param {Object} check - Check module with { name, description, run, severity }
+   */
+  registerCheck(check) {
+    if (!check.name || !check.run || typeof check.run !== 'function') {
+      throw new Error('Check must have name and run function');
+    }
+    this.checks.push(check);
+  }
+
+  /**
+   * Register multiple checks
+   * @param {Object[]} checks - Array of check modules
+   */
+  registerChecks(checks) {
+    checks.forEach(check => this.registerCheck(check));
+  }
+
+  /**
+   * Initialize scanner context
+   * @param {Object} options - Options for initialization
+   */
+  async initialize(options = {}) {
+    const { manifest = null, skipFileDiscovery = false } = options;
+    
+    this.context.manifest = manifest;
+    
+    if (!skipFileDiscovery) {
+      this.context.files = findSourceFiles(this.projectRoot);
+    }
+    
+    // Load package.json if needed
+    if (!this.context.packageJson) {
+      const { getPackageInfo } = require('./utils.cjs');
+      this.context.packageJson = getPackageInfo(this.projectRoot);
+    }
+  }
+
+  /**
+   * Run all registered checks
+   * @param {Object} options - Options for running checks
+   * @returns {Promise<Object>} Aggregated results from all checks
+   */
+  async run(options = {}) {
+    const { 
+      checkNames = null, // Run only specific checks
+      excludeChecks = [], // Exclude specific checks
+      parallel = false // Run checks in parallel
+    } = options;
+
+    // Filter checks to run
+    let checksToRun = this.checks;
+    if (checkNames && Array.isArray(checkNames)) {
+      checksToRun = this.checks.filter(check => checkNames.includes(check.name));
+    }
+    if (excludeChecks && Array.isArray(excludeChecks)) {
+      checksToRun = checksToRun.filter(check => !excludeChecks.includes(check.name));
+    }
+
+    const results = {
+      checks: {},
+      summary: {
+        total: 0,
+        errors: 0,
+        warnings: 0,
+        suggestions: 0,
+        passed: 0
+      },
+      metadata: {
+        projectRoot: this.projectRoot,
+        filesScanned: this.context.files?.length || 0,
+        checksRun: checksToRun.length,
+        timestamp: new Date().toISOString()
+      }
+    };
+
+    // Run checks
+    if (parallel) {
+      const checkPromises = checksToRun.map(check => this.runCheck(check));
+      const checkResults = await Promise.all(checkPromises);
+      checkResults.forEach((result, index) => {
+        const check = checksToRun[index];
+        results.checks[check.name] = result;
+        this.updateSummary(results.summary, result);
+      });
+    } else {
+      for (const check of checksToRun) {
+        const result = await this.runCheck(check);
+        results.checks[check.name] = result;
+        this.updateSummary(results.summary, result);
+      }
+    }
+
+    return results;
+  }
+
+  /**
+   * Run a single check
+   * @param {Object} check - Check module to run
+   * @returns {Promise<Object>} Check result
+   */
+  async runCheck(check) {
+    const startTime = Date.now();
+    try {
+      const result = await check.run(this.context);
+      const duration = Date.now() - startTime;
+      
+      return {
+        name: check.name,
+        description: check.description || '',
+        severity: check.severity || 'warning',
+        status: 'completed',
+        duration,
+        ...result
+      };
+    } catch (error) {
+      const duration = Date.now() - startTime;
+      return {
+        name: check.name,
+        description: check.description || '',
+        severity: check.severity || 'warning',
+        status: 'error',
+        error: error.message,
+        duration,
+        issues: [],
+        warnings: [],
+        suggestions: []
+      };
+    }
+  }
+
+  /**
+   * Update summary statistics
+   * @param {Object} summary - Summary object to update
+   * @param {Object} result - Check result
+   */
+  updateSummary(summary, result) {
+    summary.total++;
+    
+    if (result.status === 'error') {
+      summary.errors++;
+      return;
+    }
+
+    const issues = result.issues || [];
+    const warnings = result.warnings || [];
+    const suggestions = result.suggestions || [];
+
+    if (issues.length > 0) {
+      summary.errors += issues.length;
+    }
+    if (warnings.length > 0) {
+      summary.warnings += warnings.length;
+    }
+    if (suggestions.length > 0) {
+      summary.suggestions += suggestions.length;
+    }
+
+    if (issues.length === 0 && warnings.length === 0 && suggestions.length === 0) {
+      summary.passed++;
+    }
+  }
+
+  /**
+   * Get context for checks
+   * @returns {Object} Scanner context
+   */
+  getContext() {
+    return this.context;
+  }
+}
+
+module.exports = Scanner;

package/scripts/audit/core/utils.cjs

@@ -0,0 +1,137 @@
+#!/usr/bin/env node
+
+/**
+ * Shared utilities for audit system
+ * @package @jmruthers/pace-core
+ * @module Audit/Utils
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+// ANSI color codes for terminal output
+const colors = {
+  reset: '\x1b[0m',
+  green: '\x1b[32m',
+  yellow: '\x1b[33m',
+  blue: '\x1b[34m',
+  cyan: '\x1b[36m',
+  bold: '\x1b[1m',
+  red: '\x1b[31m'
+};
+
+/**
+ * Find project root by looking for package.json
+ * @param {string} startDir - Directory to start searching from
+ * @returns {string} Project root directory path
+ */
+function findProjectRoot(startDir = process.cwd()) {
+  let current = path.resolve(startDir);
+  while (current !== path.dirname(current)) {
+    if (fs.existsSync(path.join(current, 'package.json'))) {
+      return current;
+    }
+    current = path.dirname(current);
+  }
+  return startDir;
+}
+
+/**
+ * Recursively find all source files in a directory
+ * @param {string} dir - Directory to search
+ * @param {string[]} fileList - Accumulated file list (for recursion)
+ * @returns {string[]} Array of file paths
+ */
+function findSourceFiles(dir, fileList = []) {
+  const ignoreDirs = ['node_modules', 'dist', 'build', '.next', 'coverage', '__tests__', '__mocks__'];
+  const ignoreFiles = /\.(test|spec)\.(ts|tsx|js|jsx)$/;
+  const sourceExtensions = /\.(ts|tsx|js|jsx)$/;
+  
+  try {
+    const items = fs.readdirSync(dir);
+    
+    items.forEach(item => {
+      const fullPath = path.join(dir, item);
+      const stat = fs.statSync(fullPath);
+      
+      if (stat.isDirectory()) {
+        // Skip Edge Functions directory - they run in Deno, not React
+        if (item === 'functions' && dir.includes('supabase')) {
+          return;
+        }
+        if (!ignoreDirs.includes(item) && !item.startsWith('.')) {
+          findSourceFiles(fullPath, fileList);
+        }
+      } else if (stat.isFile()) {
+        if (sourceExtensions.test(item) && !ignoreFiles.test(item)) {
+          fileList.push(fullPath);
+        }
+      }
+    });
+  } catch (error) {
+    // Skip directories we can't read
+  }
+  
+  return fileList;
+}
+
+/**
+ * Get package.json info
+ * @param {string} projectRoot - Project root directory
+ * @returns {Object|null} Parsed package.json or null
+ */
+function getPackageInfo(projectRoot) {
+  const packagePath = path.join(projectRoot, 'package.json');
+  if (!fs.existsSync(packagePath)) {
+    return null;
+  }
+  try {
+    return JSON.parse(fs.readFileSync(packagePath, 'utf8'));
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Get pace-core version from package.json
+ * @param {Object} packageJson - Parsed package.json
+ * @returns {string} Version string or 'unknown'
+ */
+function getPaceCoreVersion(packageJson) {
+  if (!packageJson) return 'unknown';
+  const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+  return deps['@jmruthers/pace-core'] || 'unknown';
+}
+
+/**
+ * Get line number for a match in content
+ * @param {string} content - File content
+ * @param {string|number} match - Match string or index
+ * @returns {number} Line number (1-indexed)
+ */
+function getLineNumber(content, match) {
+  const index = typeof match === 'string' ? content.indexOf(match) : match;
+  if (index === -1) return 1;
+  const lines = content.substring(0, index).split('\n');
+  return lines.length;
+}
+
+/**
+ * Get relative path from project root
+ * @param {string} filePath - Absolute file path
+ * @param {string} projectRoot - Project root directory
+ * @returns {string} Relative path
+ */
+function getRelativePath(filePath, projectRoot) {
+  return path.relative(projectRoot, filePath);
+}
+
+module.exports = {
+  colors,
+  findProjectRoot,
+  findSourceFiles,
+  getPackageInfo,
+  getPaceCoreVersion,
+  getLineNumber,
+  getRelativePath
+};