@craftpipe/contextpack 1.0.0

package/lib/analyzer.js

@@ -0,0 +1,547 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Supported source file extensions for symbol extraction
+ */
+const SOURCE_EXTENSIONS = new Set([
+  '.js', '.mjs', '.cjs', '.jsx',
+  '.ts', '.tsx',
+  '.py', '.rb', '.go', '.java', '.cs', '.php', '.swift', '.kt',
+]);
+
+/**
+ * Regex patterns for extracting symbols from JavaScript/TypeScript source
+ */
+const JS_PATTERNS = {
+  functionDecl: /^(?:export\s+)?(?:async\s+)?function\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*\(/gm,
+  arrowFunction: /^(?:export\s+)?(?:const|let|var)\s+([A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*(?:async\s+)?(?:\([^)]*\)|[A-Za-z_$][A-Za-z0-9_$]*)\s*=>/gm,
+  classDecl: /^(?:export\s+)?class\s+([A-Za-z_$][A-Za-z0-9_$]*)(?:\s+extends\s+[A-Za-z_$][A-Za-z0-9_$]*)?\s*\{/gm,
+  moduleExports: /module\.exports\s*=\s*\{([^}]+)\}/gs,
+  moduleExportsSingle: /module\.exports\s*=\s*([A-Za-z_$][A-Za-z0-9_$]*)\s*;/gm,
+  namedExport: /^export\s+(?:const|let|var|function|class|async\s+function)\s+([A-Za-z_$][A-Za-z0-9_$]*)/gm,
+  exportDefault: /^export\s+default\s+(?:class|function)?\s*([A-Za-z_$][A-Za-z0-9_$]*)?/gm,
+  requireImport: /(?:const|let|var)\s+(?:\{[^}]+\}|[A-Za-z_$][A-Za-z0-9_$]*)\s*=\s*require\s*\(\s*['"]([^'"]+)['"]\s*\)/gm,
+  esImport: /^import\s+(?:[^'"]+\s+from\s+)?['"]([^'"]+)['"]/gm,
+  dynamicImport: /import\s*\(\s*['"]([^'"]+)['"]\s*\)/gm,
+};
+
+/**
+ * Determine if a file is a JavaScript/TypeScript file
+ * @param {string} filePath - Path to the file
+ * @returns {boolean}
+ */
+function isJSFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx'].includes(ext);
+}
+
+/**
+ * Determine if a file is a source code file worth analyzing
+ * @param {string} filePath - Path to the file
+ * @returns {boolean}
+ */
+function isSourceFile(filePath) {
+  const ext = path.extname(filePath).toLowerCase();
+  return SOURCE_EXTENSIONS.has(ext);
+}
+
+/**
+ * Read file content safely, returning null on error
+ * @param {string} filePath - Absolute path to file
+ * @returns {string|null}
+ */
+function readFileSafe(filePath) {
+  try {
+    return fs.readFileSync(filePath, 'utf8');
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Extract all unique regex matches for a capture group
+ * @param {string} source - Source text
+ * @param {RegExp} pattern - Regex with at least one capture group
+ * @returns {string[]}
+ */
+function extractMatches(source, pattern) {
+  const results = [];
+  const regex = new RegExp(pattern.source, pattern.flags);
+  let match;
+  while ((match = regex.exec(source)) !== null) {
+    if (match[1] && match[1].trim()) {
+      results.push(match[1].trim());
+    }
+  }
+  return results;
+}
+
+/**
+ * Extract symbols from JavaScript/TypeScript source
+ * @param {string} source - File source code
+ * @returns {{ functions: string[], classes: string[], exports: string[] }}
+ */
+function extractJSSymbols(source) {
+  const functions = new Set();
+  const classes = new Set();
+  const exports = new Set();
+
+  // Named function declarations
+  extractMatches(source, JS_PATTERNS.functionDecl).forEach(name => functions.add(name));
+
+  // Arrow functions assigned to variables
+  extractMatches(source, JS_PATTERNS.arrowFunction).forEach(name => functions.add(name));
+
+  // Class declarations
+  extractMatches(source, JS_PATTERNS.classDecl).forEach(name => classes.add(name));
+
+  // Named ES exports
+  extractMatches(source, JS_PATTERNS.namedExport).forEach(name => exports.add(name));
+
+  // module.exports = { ... }
+  const moduleExportsBlock = new RegExp(JS_PATTERNS.moduleExports.source, JS_PATTERNS.moduleExports.flags);
+  let blockMatch;
+  while ((blockMatch = moduleExportsBlock.exec(source)) !== null) {
+    const block = blockMatch[1];
+    const keys = block.match(/([A-Za-z_$][A-Za-z0-9_$]*)\s*(?::|,|\n)/g) || [];
+    keys.forEach(k => {
+      const name = k.replace(/[\s:,\n]/g, '');
+      if (name) exports.add(name);
+    });
+  }
+
+  // module.exports = singleName
+  extractMatches(source, JS_PATTERNS.moduleExportsSingle).forEach(name => exports.add(name));
+
+  // export default
+  extractMatches(source, JS_PATTERNS.exportDefault).forEach(name => {
+    if (name) exports.add(name);
+  });
+
+  return {
+    functions: Array.from(functions),
+    classes: Array.from(classes),
+    exports: Array.from(exports),
+  };
+}
+
+/**
+ * Extract import/dependency paths from JavaScript/TypeScript source
+ * @param {string} source - File source code
+ * @param {string} filePath - Path of the file being analyzed (for resolving relative imports)
+ * @returns {{ imports: string[], localDeps: string[], externalDeps: string[] }}
+ */
+function extractJSDependencies(source, filePath) {
+  const allImports = new Set();
+
+  extractMatches(source, JS_PATTERNS.requireImport).forEach(dep => allImports.add(dep));
+  extractMatches(source, JS_PATTERNS.esImport).forEach(dep => allImports.add(dep));
+  extractMatches(source, JS_PATTERNS.dynamicImport).forEach(dep => allImports.add(dep));
+
+  const localDeps = [];
+  const externalDeps = [];
+
+  for (const imp of allImports) {
+    if (imp.startsWith('.') || imp.startsWith('/')) {
+      localDeps.push(imp);
+    } else {
+      // Extract package name (handle scoped packages)
+      const parts = imp.split('/');
+      const pkgName = imp.startsWith('@') ? parts.slice(0, 2).join('/') : parts[0];
+      if (!externalDeps.includes(pkgName)) {
+        externalDeps.push(pkgName);
+      }
+    }
+  }
+
+  return {
+    imports: Array.from(allImports),
+    localDeps,
+    externalDeps,
+  };
+}
+
+/**
+ * Generate a brief summary of a file based on its content and symbols
+ * @param {string} filePath - Path to the file
+ * @param {string} source - File source code
+ * @param {object} symbols - Extracted symbols
+ * @returns {string}
+ */
+function generateSummary(filePath, source, symbols) {
+  const ext = path.extname(filePath).toLowerCase();
+  const lines = source.split('\n').length;
+  const parts = [];
+
+  parts.push(`${lines} lines`);
+
+  if (symbols.classes && symbols.classes.length > 0) {
+    parts.push(`classes: ${symbols.classes.join(', ')}`);
+  }
+  if (symbols.functions && symbols.functions.length > 0) {
+    const shown = symbols.functions.slice(0, 5);
+    const extra = symbols.functions.length - shown.length;
+    parts.push(`functions: ${shown.join(', ')}${extra > 0 ? ` +${extra} more` : ''}`);
+  }
+  if (symbols.exports && symbols.exports.length > 0) {
+    parts.push(`exports: ${symbols.exports.join(', ')}`);
+  }
+
+  // Try to extract first JSDoc or block comment as description
+  const docMatch = source.match(/\/\*\*\s*([\s\S]*?)\s*\*\//);
+  if (docMatch) {
+    const docText = docMatch[1]
+      .replace(/\s*\*\s*/g, ' ')
+      .replace(/@\w+[^\n]*/g, '')
+      .trim()
+      .slice(0, 120);
+    if (docText) parts.unshift(docText);
+  }
+
+  return parts.join('; ');
+}
+
+/**
+ * Resolve a local import path relative to the importing file
+ * @param {string} importingFile - Absolute path of the file doing the import
+ * @param {string} importPath - The import string (e.g. './utils')
+ * @param {string} projectRoot - Root directory of the project
+ * @returns {string|null} Resolved relative path from project root, or null
+ */
+function resolveLocalImport(importingFile, importPath, projectRoot) {
+  try {
+    const dir = path.dirname(importingFile);
+    let resolved = path.resolve(dir, importPath);
+
+    // Try exact path first
+    if (fs.existsSync(resolved) && fs.statSync(resolved).isFile()) {
+      return path.relative(projectRoot, resolved).replace(/\\/g, '/');
+    }
+
+    // Try adding common extensions
+    const extensions = ['.js', '.mjs', '.cjs', '.jsx', '.ts', '.tsx', '.json'];
+    for (const ext of extensions) {
+      const candidate = resolved + ext;
+      if (fs.existsSync(candidate)) {
+        return path.relative(projectRoot, candidate).replace(/\\/g, '/');
+      }
+    }
+
+    // Try index files
+    for (const ext of extensions) {
+      const candidate = path.join(resolved, 'index' + ext);
+      if (fs.existsSync(candidate)) {
+        return path.relative(projectRoot, candidate).replace(/\\/g, '/');
+      }
+    }
+
+    return null;
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Analyzes a single file and returns its symbol map, dependencies, and summary.
+ * @param {string} filePath - Absolute or relative path to the file
+ * @param {object} [options] - Optional configuration
+ * @param {string} [options.projectRoot] - Root directory for resolving relative paths
+ * @returns {{
+ *   filePath: string,
+ *   relativePath: string,
+ *   extension: string,
+ *   lines: number,
+ *   symbols: { functions: string[], classes: string[], exports: string[] },
+ *   dependencies: { imports: string[], localDeps: string[], externalDeps: string[] },
+ *   summary: string,
+ *   error: string|null
+ * }}
+ */
+function analyzeFile(filePath, options) {
+  const opts = options || {};
+  const projectRoot = opts.projectRoot || process.cwd();
+
+  if (!filePath || typeof filePath !== 'string') {
+    return {
+      filePath: '',
+      relativePath: '',
+      extension: '',
+      lines: 0,
+      symbols: { functions: [], classes: [], exports: [] },
+      dependencies: { imports: [], localDeps: [], externalDeps: [] },
+      summary: 'Invalid file path provided',
+      error: 'Invalid file path',
+    };
+  }
+
+  const absolutePath = path.isAbsolute(filePath)
+    ? filePath
+    : path.resolve(projectRoot, filePath);
+
+  const relativePath = path.relative(projectRoot, absolutePath).replace(/\\/g, '/');
+  const extension = path.extname(absolutePath).toLowerCase();
+
+  const source = readFileSafe(absolutePath);
+
+  if (source === null) {
+    return {
+      filePath: absolutePath,
+      relativePath,
+      extension,
+      lines: 0,
+      symbols: { functions: [], classes: [], exports: [] },
+      dependencies: { imports: [], localDeps: [], externalDeps: [] },
+      summary: 'Could not read file',
+      error: 'File read error',
+    };
+  }
+
+  const lines = source.split('\n').length;
+  let symbols = { functions: [], classes: [], exports: [] };
+  let dependencies = { imports: [], localDeps: [], externalDeps: [] };
+
+  if (isJSFile(absolutePath)) {
+    symbols = extractJSSymbols(source);
+    dependencies = extractJSDependencies(source, absolutePath);
+  }
+
+  const summary = generateSummary(absolutePath, source, symbols);
+
+  return {
+    filePath: absolutePath,
+    relativePath,
+    extension,
+    lines,
+    symbols,
+    dependencies,
+    summary,
+    error: null,
+  };
+}
+
+/**
+ * Analyzes all files in a project and returns a structured symbol map and dependency graph.
+ * @param {string[]} filePaths - Array of absolute file paths to analyze
+ * @param {object} [options] - Optional configuration
+ * @param {string} [options.projectRoot] - Root directory of the project
+ * @param {boolean} [options.sourceOnly] - If true, skip non-source files
+ * @returns {{
+ *   files: object,
+ *   symbolMap: object,
+ *   dependencyGraph: object,
+ *   stats: { totalFiles: number, analyzedFiles: number, totalSymbols: number, errors: number }
+ * }}
+ */
+function analyzeProject(filePaths, options) {
+  const opts = options || {};
+  const projectRoot = opts.projectRoot || process.cwd();
+  const sourceOnly = opts.sourceOnly !== false;
+
+  if (!filePaths || !Array.isArray(filePaths)) {
+    return {
+      files: {},
+      symbolMap: {},
+      dependencyGraph: {},
+      stats: { totalFiles: 0, analyzedFiles: 0, totalSymbols: 0, errors: 0 },
+    };
+  }
+
+  const files = {};
+  const symbolMap = {};
+  let errors = 0;
+
+  const filteredPaths = sourceOnly
+    ? filePaths.filter(fp => isSourceFile(fp))
+    : filePaths;
+
+  for (const fp of filteredPaths) {
+    const result = analyzeFile(fp, { projectRoot });
+
+    files[result.relativePath] = result;
+
+    if (result.error) {
+      errors++;
+    } else {
+      // Build symbol map: symbol name -> list of files that define it
+      const allSymbols = [
+        ...result.symbols.functions,
+        ...result.symbols.classes,
+        ...result.symbols.exports,
+      ];
+
+      for (const sym of allSymbols) {
+        if (!symbolMap[sym]) {
+          symbolMap[sym] = [];
+        }
+        if (!symbolMap[sym].includes(result.relativePath)) {
+          symbolMap[sym].push(result.relativePath);
+        }
+      }
+    }
+  }
+
+  const dependencyGraph = buildDependencyGraph(files, { projectRoot });
+
+  const totalSymbols = Object.keys(symbolMap).length;
+
+  return {
+    files,
+    symbolMap,
+    dependencyGraph,
+    stats: {
+      totalFiles: filePaths.length,
+      analyzedFiles: filteredPaths.length,
+      totalSymbols,
+      errors,
+    },
+  };
+}
+
+/**
+ * Extracts symbols (functions, classes, exports) from a source string or file path.
+ * @param {string} input - Either source code string or a file path
+ * @param {object} [options] - Options
+ * @param {boolean} [options.isPath] - If true, treat input as a file path and read it
+ * @param {string} [options.language] - Language hint ('js', 'ts', etc.)
+ * @returns {{ functions: string[], classes: string[], exports: string[] }}
+ */
+function extractSymbols(input, options) {
+  const opts = options || {};
+
+  if (!input || typeof input !== 'string') {
+    return { functions: [], classes: [], exports: [] };
+  }
+
+  let source = input;
+  let filePath = '';
+
+  if (opts.isPath) {
+    filePath = input;
+    source = readFileSafe(input);
+    if (source === null) {
+      return { functions: [], classes: [], exports: [] };
+    }
+  }
+
+  const language = opts.language || (filePath ? path.extname(filePath).toLowerCase().replace('.', '') : 'js');
+  const jsLangs = new Set(['js', 'mjs', 'cjs', 'jsx', 'ts', 'tsx']);
+
+  if (jsLangs.has(language)) {
+    return extractJSSymbols(source);
+  }
+
+  // For other languages, do a best-effort extraction using common patterns
+  const functions = [];
+  const classes = [];
+  const exports = [];
+
+  // Generic function-like patterns
+  const genericFn = /(?:def|func|function|fn|sub|method)\s+([A-Za-z_][A-Za-z0-9_]*)\s*\(/gm;
+  let m;
+  while ((m = genericFn.exec(source)) !== null) {
+    if (m[1]) functions.push(m[1]);
+  }
+
+  // Generic class patterns
+  const genericClass = /class\s+([A-Za-z_][A-Za-z0-9_]*)/gm;
+  while ((m = genericClass.exec(source)) !== null) {
+    if (m[1]) classes.push(m[1]);
+  }
+
+  return { functions, classes, exports };
+}
+
+/**
+ * Builds a dependency graph from analyzed file results.
+ * @param {object} files - Map of relativePath -> analyzeFile result
+ * @param {object} [options] - Options
+ * @param {string} [options.projectRoot] - Project root for resolving paths
+ * @returns {{
+ *   nodes: string[],
+ *   edges: Array<{ from: string, to: string, type: string }>,
+ *   adjacency: object,
+ *   reverseAdjacency: object
+ * }}
+ */
+function buildDependencyGraph(files, options) {
+  const opts = options || {};
+  const projectRoot = opts.projectRoot || process.cwd();
+
+  if (!files || typeof files !== 'object') {
+    return {
+      nodes: [],
+      edges: [],
+      adjacency: {},
+      reverseAdjacency: {},
+    };
+  }
+
+  const nodes = Object.keys(files);
+  const edges = [];
+  const adjacency = {};
+  const reverseAdjacency = {};
+
+  // Initialize adjacency maps
+  for (const node of nodes) {
+    adjacency[node] = [];
+    reverseAdjacency[node] = [];
+  }
+
+  for (const [relPath, fileResult] of Object.entries(files)) {
+    if (!fileResult || !fileResult.dependencies) continue;
+
+    const { localDeps } = fileResult.dependencies;
+    if (!Array.isArray(localDeps)) continue;
+
+    const absoluteImportingFile = fileResult.filePath || path.resolve(projectRoot, relPath);
+
+    for (const dep of localDeps) {
+      const resolvedRel = resolveLocalImport(absoluteImportingFile, dep, projectRoot);
+
+      if (resolvedRel && files[resolvedRel]) {
+        // Avoid duplicate edges
+        const exists = edges.some(e => e.from === relPath && e.to === resolvedRel);
+        if (!exists) {
+          edges.push({ from: relPath, to: resolvedRel, type: 'local' });
+
+          if (!adjacency[relPath]) adjacency[relPath] = [];
+          if (!adjacency[relPath].includes(resolvedRel)) {
+            adjacency[relPath].push(resolvedRel);
+          }
+
+          if (!reverseAdjacency[resolvedRel]) reverseAdjacency[resolvedRel] = [];
+          if (!reverseAdjacency[resolvedRel].includes(relPath)) {
+            reverseAdjacency[resolvedRel].push(relPath);
+          }
+        }
+      } else if (resolvedRel) {
+        // Dependency exists on disk but wasn't in the analyzed set
+        const exists = edges.some(e => e.from === relPath && e.to === resolvedRel);
+        if (!exists) {
+          edges.push({ from: relPath, to: resolvedRel, type: 'external-local' });
+          if (!adjacency[relPath]) adjacency[relPath] = [];
+          if (!adjacency[relPath].includes(resolvedRel)) {
+            adjacency[relPath].push(resolvedRel);
+          }
+        }
+      }
+    }
+  }
+
+  return {
+    nodes,
+    edges,
+    adjacency,
+    reverseAdjacency,
+  };
+}
+
+module.exports = {
+  analyzeFile,
+  analyzeProject,
+  extractSymbols,
+  buildDependencyGraph,
+};