@jmruthers/pace-core 0.6.6 → 0.6.8

package/audit-tool/utils/code-utils.cjs

@@ -0,0 +1,218 @@
+/**
+ * Code Analysis Utilities for Audit Tool
+ * @package @jmruthers/pace-core
+ * @module Audit/utils/code-utils
+ */
+
+/**
+ * Get line number from index in content
+ * @param {string} content - File content
+ * @param {number} index - Character index
+ * @returns {number} - Line number (1-indexed)
+ */
+function getLineNumber(content, index) {
+  return content.substring(0, index).split('\n').length;
+}
+
+/**
+ * Get code snippet around a match for context
+ * @param {string} content - File content
+ * @param {number} index - Character index
+ * @param {number} before - Characters before index
+ * @param {number} after - Characters after index
+ * @returns {string} - Code snippet
+ */
+function getCodeSnippet(content, index, before = 30, after = 50) {
+  const start = Math.max(0, index - before);
+  const end = Math.min(content.length, index + after);
+  return content.substring(start, end).trim();
+}
+
+/**
+ * Check if content is in a comment or string (for TypeScript/JavaScript)
+ * @param {string} content - File content
+ * @param {number} index - Character index
+ * @returns {boolean} - True if in comment or string
+ */
+function isInCommentOrString(content, index) {
+  const before = content.substring(0, index);
+  
+  // Check for line comments
+  const lastLineComment = before.lastIndexOf('//');
+  const lastNewline = before.lastIndexOf('\n');
+  if (lastLineComment > lastNewline) {
+    return true;
+  }
+  
+  // Check for block comments
+  const lastBlockCommentStart = before.lastIndexOf('/*');
+  const lastBlockCommentEnd = before.lastIndexOf('*/');
+  if (lastBlockCommentStart > lastBlockCommentEnd) {
+    return true;
+  }
+  
+  // Check for string literals (simple check)
+  const singleQuoteMatches = [...before.matchAll(/'/g)];
+  const doubleQuoteMatches = [...before.matchAll(/"/g)];
+  const backtickMatches = [...before.matchAll(/`/g)];
+  
+  // Simple heuristic: if odd number of quotes before, might be in string
+  const inSingleQuote = singleQuoteMatches.length % 2 === 1;
+  const inDoubleQuote = doubleQuoteMatches.length % 2 === 1;
+  const inBacktick = backtickMatches.length % 2 === 1;
+  
+  return inSingleQuote || inDoubleQuote || inBacktick;
+}
+
+/**
+ * Check if content is in a comment or string (for SQL)
+ * @param {string} content - SQL content
+ * @param {number} index - Character index
+ * @returns {boolean} - True if in comment or string
+ */
+function isInCommentOrStringSQL(content, index) {
+  const before = content.substring(0, index);
+  
+  // Check for SQL line comments
+  const lastLineComment = before.lastIndexOf('--');
+  const lastNewline = before.lastIndexOf('\n');
+  if (lastLineComment > lastNewline && !before.substring(lastLineComment, index).includes('\n')) {
+    return true;
+  }
+  
+  // Check for block comments
+  const lastBlockCommentStart = before.lastIndexOf('/*');
+  const lastBlockCommentEnd = before.lastIndexOf('*/');
+  if (lastBlockCommentStart > lastBlockCommentEnd) {
+    return true;
+  }
+  
+  // Check for string literals (SQL uses single quotes)
+  const singleQuoteMatches = [...before.matchAll(/'/g)];
+  const inSingleQuote = singleQuoteMatches.length % 2 === 1;
+  
+  return inSingleQuote;
+}
+
+/**
+ * Extract import statements from content
+ * @param {string} content - File content
+ * @returns {Array} - Array of import objects { source, specifiers, line }
+ */
+function parseImports(content) {
+  const imports = [];
+  const lines = content.split('\n');
+  
+  lines.forEach((line, index) => {
+    // Match various import patterns
+    const importPatterns = [
+      /^import\s+.*\s+from\s+['"]([^'"]+)['"]/,
+      /^import\s+['"]([^'"]+)['"]/,
+    ];
+    
+    for (const pattern of importPatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const source = match[1];
+        const specifiers = [];
+        
+        // Try to extract named imports
+        const namedMatch = line.match(/import\s+{([^}]+)}\s+from/);
+        if (namedMatch) {
+          namedMatch[1].split(',').forEach(spec => {
+            const trimmed = spec.trim();
+            if (trimmed) {
+              specifiers.push(trimmed);
+            }
+          });
+        }
+        
+        // Check for default import
+        const defaultMatch = line.match(/import\s+(\w+)\s+from/);
+        if (defaultMatch && !line.includes('{')) {
+          specifiers.push('default');
+        }
+        
+        imports.push({
+          source,
+          specifiers,
+          line: index + 1,
+          fullLine: line.trim(),
+        });
+        break;
+      }
+    }
+  });
+  
+  return imports;
+}
+
+/**
+ * Extract export statements from content
+ * @param {string} content - File content
+ * @returns {Array} - Array of export objects { name, type, line }
+ */
+function parseExports(content) {
+  const exports = [];
+  const lines = content.split('\n');
+  
+  lines.forEach((line, index) => {
+    // Match export patterns
+    const exportPatterns = [
+      /^export\s+(?:function|const|class|interface|type)\s+(\w+)/,
+      /^export\s+default\s+(?:function\s+)?(\w+)?/,
+      /^export\s+{\s*(\w+)/,
+    ];
+    
+    for (const pattern of exportPatterns) {
+      const match = line.match(pattern);
+      if (match) {
+        const name = match[1] || 'default';
+        const type = line.includes('function') ? 'function' :
+                     line.includes('const') ? 'const' :
+                     line.includes('class') ? 'class' :
+                     line.includes('interface') ? 'interface' :
+                     line.includes('type') ? 'type' :
+                     'other';
+        
+        exports.push({
+          name,
+          type,
+          line: index + 1,
+          fullLine: line.trim(),
+        });
+        break;
+      }
+    }
+  });
+  
+  return exports;
+}
+
+/**
+ * Check if file imports from pace-core
+ * @param {string} content - File content
+ * @param {string} name - Component/hook/util name to check
+ * @returns {boolean} - True if imports from pace-core
+ */
+function importsFromPaceCore(content, name) {
+  const patterns = [
+    new RegExp(`import\\s+.*\\b${name}\\b.*from\\s+['"]@jmruthers/pace-core`),
+    new RegExp(`import\\s+.*\\b${name}\\b.*from\\s+['"]@jmruthers/pace-core/components`),
+    new RegExp(`import\\s+.*\\b${name}\\b.*from\\s+['"]@jmruthers/pace-core/hooks`),
+    new RegExp(`import\\s+.*\\b${name}\\b.*from\\s+['"]@jmruthers/pace-core/utils`),
+    new RegExp(`import\\s+.*\\b${name}\\b.*from\\s+['"]@jmruthers/pace-core/rbac`),
+  ];
+  
+  return patterns.some(pattern => pattern.test(content));
+}
+
+module.exports = {
+  getLineNumber,
+  getCodeSnippet,
+  isInCommentOrString,
+  isInCommentOrStringSQL,
+  parseImports,
+  parseExports,
+  importsFromPaceCore,
+};

package/audit-tool/utils/file-utils.cjs

@@ -0,0 +1,230 @@
+/**
+ * File System Utilities for Audit Tool
+ * @package @jmruthers/pace-core
+ * @module Audit/utils/file-utils
+ */
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Recursively find all source files matching extensions
+ * @param {string} dir - Directory to search
+ * @param {string[]} extensions - File extensions to match (e.g., ['.ts', '.tsx', '.js', '.jsx'])
+ * @param {string[]} fileList - Accumulator for found files
+ * @returns {string[]} - Array of file paths
+ */
+function findSourceFiles(dir, extensions = ['.ts', '.tsx', '.js', '.jsx'], fileList = []) {
+  if (!fs.existsSync(dir)) {
+    return fileList;
+  }
+  
+  const files = fs.readdirSync(dir);
+  
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    
+    if (stat.isDirectory()) {
+      // Skip common build/dependency directories
+      if (!['node_modules', 'dist', 'build', '.git', '.next', '.vite', 'coverage', '.turbo', '.cursor'].includes(file)) {
+        findSourceFiles(filePath, extensions, fileList);
+      }
+    } else {
+      const ext = path.extname(file);
+      if (extensions.includes(ext)) {
+        fileList.push(filePath);
+      }
+    }
+  });
+  
+  return fileList;
+}
+
+/**
+ * Recursively find all SQL files in a directory
+ * @param {string} dir - Directory to search
+ * @param {string[]} fileList - Accumulator for found files
+ * @returns {string[]} - Array of SQL file paths
+ */
+function findSQLFiles(dir, fileList = []) {
+  if (!fs.existsSync(dir)) {
+    return fileList;
+  }
+  
+  const files = fs.readdirSync(dir);
+  
+  files.forEach(file => {
+    const filePath = path.join(dir, file);
+    const stat = fs.statSync(filePath);
+    
+    if (stat.isDirectory()) {
+      // Skip common build/dependency directories
+      if (!['node_modules', 'dist', 'build', '.git', '.next', '.vite', 'coverage', '.turbo'].includes(file)) {
+        findSQLFiles(filePath, fileList);
+      }
+    } else if (/\.sql$/.test(file)) {
+      fileList.push(filePath);
+    }
+  });
+  
+  return fileList;
+}
+
+/**
+ * Find configuration files by name
+ * @param {string} dir - Directory to search
+ * @param {string[]} configNames - Array of config file names to find
+ * @returns {Object} - Object mapping config names to paths (or null if not found)
+ */
+function findConfigFiles(dir, configNames) {
+  const results = {};
+  
+  for (const configName of configNames) {
+    const possiblePaths = [
+      path.join(dir, configName),
+      path.join(dir, `.${configName}`),
+    ];
+    
+    // Also check common variations
+    if (configName.includes('.')) {
+      const [base, ext] = configName.split('.');
+      possiblePaths.push(
+        path.join(dir, `${base}.js`),
+        path.join(dir, `${base}.ts`),
+        path.join(dir, `${base}.cjs`),
+        path.join(dir, `${base}.mjs`),
+        path.join(dir, `.${base}.js`),
+        path.join(dir, `.${base}.ts`),
+        path.join(dir, `.${base}.cjs`),
+        path.join(dir, `.${base}.mjs`)
+      );
+    }
+    
+    let found = null;
+    for (const configPath of possiblePaths) {
+      if (fs.existsSync(configPath)) {
+        found = configPath;
+        break;
+      }
+    }
+    
+    results[configName] = found;
+  }
+  
+  return results;
+}
+
+/**
+ * Safely read a file with error handling
+ * @param {string} filePath - Path to file
+ * @returns {string|null} - File content or null if error
+ */
+function readFileSafe(filePath) {
+  try {
+    if (!fs.existsSync(filePath)) {
+      return null;
+    }
+    return fs.readFileSync(filePath, 'utf8');
+  } catch (error) {
+    return null;
+  }
+}
+
+/**
+ * Get relative path from base path
+ * @param {string} filePath - Absolute file path
+ * @param {string} basePath - Base path to make relative to
+ * @returns {string} - Relative path
+ */
+function getRelativePath(filePath, basePath) {
+  try {
+    return path.relative(basePath, filePath);
+  } catch (error) {
+    return filePath;
+  }
+}
+
+/**
+ * Find pace-core package.json
+ * @param {string} consumingAppPath - Path to consuming app
+ * @returns {string|null} - Path to pace-core package.json or null
+ */
+function findPaceCorePackageJson(consumingAppPath) {
+  const possiblePaths = [
+    path.resolve(__dirname, '../../package.json'), // From packages/core/audit-tool/utils
+    path.resolve(__dirname, '../../../package.json'), // Alternative location (from root)
+    path.join(consumingAppPath, 'node_modules', '@jmruthers', 'pace-core', 'package.json'),
+  ];
+  
+  for (const packagePath of possiblePaths) {
+    if (fs.existsSync(packagePath)) {
+      return packagePath;
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Load core-usage-manifest.json
+ * @param {string} consumingAppPath - Path to consuming app
+ * @returns {Object|null} - Manifest object or null
+ */
+function loadManifest(consumingAppPath) {
+  const possiblePaths = [
+    path.resolve(__dirname, '../../../core-usage-manifest.json'),
+    path.resolve(__dirname, '../../../../core-usage-manifest.json'),
+    path.join(consumingAppPath, 'node_modules', '@jmruthers', 'pace-core', 'core-usage-manifest.json'),
+  ];
+  
+  for (const manifestPath of possiblePaths) {
+    if (fs.existsSync(manifestPath)) {
+      try {
+        return JSON.parse(fs.readFileSync(manifestPath, 'utf8'));
+      } catch (e) {
+        // Continue to next path
+      }
+    }
+  }
+  
+  return null;
+}
+
+/**
+ * Check if a directory exists
+ * @param {string} dirPath - Directory path
+ * @returns {boolean} - True if directory exists
+ */
+function directoryExists(dirPath) {
+  try {
+    return fs.existsSync(dirPath) && fs.statSync(dirPath).isDirectory();
+  } catch (error) {
+    return false;
+  }
+}
+
+/**
+ * Check if a file exists
+ * @param {string} filePath - File path
+ * @returns {boolean} - True if file exists
+ */
+function fileExists(filePath) {
+  try {
+    return fs.existsSync(filePath) && fs.statSync(filePath).isFile();
+  } catch (error) {
+    return false;
+  }
+}
+
+module.exports = {
+  findSourceFiles,
+  findSQLFiles,
+  findConfigFiles,
+  readFileSafe,
+  getRelativePath,
+  findPaceCorePackageJson,
+  loadManifest,
+  directoryExists,
+  fileExists,
+};