@craftpipe/contextpack 1.0.0

package/lib/scanner.js

@@ -0,0 +1,480 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+/**
+ * Default patterns to ignore when scanning
+ */
+const DEFAULT_IGNORE = [
+  'node_modules/**',
+  '.git/**',
+  'dist/**',
+  'build/**',
+  'coverage/**',
+  '.nyc_output/**',
+  '**/*.min.js',
+  '**/*.map',
+  '.DS_Store',
+  'Thumbs.db',
+];
+
+/**
+ * Recursively walk a directory and collect file paths
+ * @param {string} dir - Directory to walk
+ * @param {string} rootDir - Root directory for relative path calculation
+ * @param {string[]} ignorePatterns - Glob-style patterns to ignore
+ * @returns {string[]} Array of absolute file paths
+ */
+function walkDir(dir, rootDir, ignorePatterns) {
+  const results = [];
+
+  let entries;
+  try {
+    entries = fs.readdirSync(dir, { withFileTypes: true });
+  } catch (err) {
+    return results;
+  }
+
+  for (const entry of entries) {
+    const fullPath = path.join(dir, entry.name);
+    const relPath = path.relative(rootDir, fullPath).replace(/\\/g, '/');
+
+    if (shouldIgnore(relPath, entry.name, ignorePatterns)) {
+      continue;
+    }
+
+    if (entry.isDirectory()) {
+      const nested = walkDir(fullPath, rootDir, ignorePatterns);
+      results.push(...nested);
+    } else if (entry.isFile()) {
+      results.push(fullPath);
+    }
+  }
+
+  return results;
+}
+
+/**
+ * Check if a path matches any ignore pattern
+ * @param {string} relPath - Relative path to check
+ * @param {string} name - File/directory name
+ * @param {string[]} patterns - Patterns to check against
+ * @returns {boolean}
+ */
+function shouldIgnore(relPath, name, patterns) {
+  if (!patterns || !Array.isArray(patterns)) return false;
+
+  for (const pattern of patterns) {
+    if (matchGlob(pattern, relPath, name)) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Simple glob pattern matcher supporting * and ** wildcards
+ * @param {string} pattern - Glob pattern
+ * @param {string} relPath - Relative path to test
+ * @param {string} name - File/directory name
+ * @returns {boolean}
+ */
+function matchGlob(pattern, relPath, name) {
+  if (!pattern || typeof pattern !== 'string') return false;
+
+  // Normalize separators
+  const normalizedPattern = pattern.replace(/\\/g, '/');
+  const normalizedPath = relPath.replace(/\\/g, '/');
+
+  // Convert glob pattern to regex
+  const regexStr = normalizedPattern
+    .replace(/[.+^${}()|[\]\\]/g, '\\$&') // escape special regex chars except * and ?
+    .replace(/\*\*\//g, '(?:.+/)?')        // **/ matches zero or more directories
+    .replace(/\*\*/g, '.*')                 // ** matches anything
+    .replace(/\*/g, '[^/]*')               // * matches anything except /
+    .replace(/\?/g, '[^/]');               // ? matches single char except /
+
+  try {
+    const regex = new RegExp(`^${regexStr}$`);
+    if (regex.test(normalizedPath)) return true;
+
+    // Also test just the filename for simple patterns without /
+    if (!normalizedPattern.includes('/') && regex.test(name)) return true;
+
+    // Test if path starts with pattern (for directory patterns like node_modules/**)
+    const prefixRegex = new RegExp(`(^|/)${regexStr}(/|$)`);
+    if (prefixRegex.test(normalizedPath)) return true;
+  } catch (e) {
+    // If regex fails, fall back to simple string comparison
+    return normalizedPath === normalizedPattern || name === normalizedPattern;
+  }
+
+  return false;
+}
+
+/**
+ * Get file metadata for a given path
+ * @param {string} filePath - Absolute path to file
+ * @param {string} rootDir - Root directory for relative path
+ * @returns {object|null} File metadata object or null on error
+ */
+function getFileMetadata(filePath, rootDir) {
+  try {
+    const stats = fs.statSync(filePath);
+    const relPath = path.relative(rootDir, filePath).replace(/\\/g, '/');
+    const ext = path.extname(filePath).toLowerCase();
+    const name = path.basename(filePath);
+
+    return {
+      path: relPath,
+      absolutePath: filePath,
+      name,
+      ext,
+      size: stats.size,
+      sizeKB: Math.round((stats.size / 1024) * 100) / 100,
+      modified: stats.mtime.toISOString(),
+      created: stats.birthtime.toISOString(),
+      type: getFileType(ext),
+      directory: path.dirname(relPath).replace(/\\/g, '/'),
+    };
+  } catch (err) {
+    return null;
+  }
+}
+
+/**
+ * Determine file type category from extension
+ * @param {string} ext - File extension including dot
+ * @returns {string} File type category
+ */
+function getFileType(ext) {
+  const typeMap = {
+    '.js': 'javascript',
+    '.mjs': 'javascript',
+    '.cjs': 'javascript',
+    '.jsx': 'javascript',
+    '.ts': 'typescript',
+    '.tsx': 'typescript',
+    '.json': 'json',
+    '.md': 'markdown',
+    '.mdx': 'markdown',
+    '.html': 'html',
+    '.htm': 'html',
+    '.css': 'css',
+    '.scss': 'css',
+    '.sass': 'css',
+    '.less': 'css',
+    '.py': 'python',
+    '.rb': 'ruby',
+    '.go': 'go',
+    '.rs': 'rust',
+    '.java': 'java',
+    '.c': 'c',
+    '.cpp': 'cpp',
+    '.h': 'c',
+    '.hpp': 'cpp',
+    '.sh': 'shell',
+    '.bash': 'shell',
+    '.zsh': 'shell',
+    '.yaml': 'yaml',
+    '.yml': 'yaml',
+    '.toml': 'toml',
+    '.xml': 'xml',
+    '.svg': 'svg',
+    '.txt': 'text',
+    '.env': 'env',
+    '.gitignore': 'config',
+    '.eslintrc': 'config',
+    '.prettierrc': 'config',
+  };
+
+  return typeMap[ext] || 'other';
+}
+
+/**
+ * Scans a project directory and returns a raw file inventory with paths and metadata.
+ * @param {string} projectDir - Root directory to scan
+ * @param {object} options - Scan options
+ * @param {string[]} [options.ignore] - Additional patterns to ignore
+ * @param {string[]} [options.extensions] - Only include files with these extensions
+ * @param {boolean} [options.includeHidden] - Whether to include hidden files (default: false)
+ * @returns {object} File inventory with files array and summary stats
+ */
+function scanProject(projectDir, options) {
+  const opts = options || {};
+  const rootDir = projectDir || process.cwd();
+
+  // Validate directory exists
+  try {
+    const stat = fs.statSync(rootDir);
+    if (!stat.isDirectory()) {
+      return {
+        success: false,
+        error: `Path is not a directory: ${rootDir}`,
+        files: [],
+        summary: { total: 0, totalSize: 0, byType: {}, byExtension: {} },
+      };
+    }
+  } catch (err) {
+    return {
+      success: false,
+      error: `Cannot access directory: ${rootDir} — ${err.message}`,
+      files: [],
+      summary: { total: 0, totalSize: 0, byType: {}, byExtension: {} },
+    };
+  }
+
+  const ignorePatterns = [...DEFAULT_IGNORE, ...(opts.ignore || [])];
+
+  // Optionally exclude hidden files/dirs
+  if (!opts.includeHidden) {
+    ignorePatterns.push('.*', '.*/**');
+  }
+
+  // Walk the directory
+  const absolutePaths = walkDir(rootDir, rootDir, ignorePatterns);
+
+  // Gather metadata for each file
+  let files = [];
+  for (const absPath of absolutePaths) {
+    const meta = getFileMetadata(absPath, rootDir);
+    if (meta) {
+      files.push(meta);
+    }
+  }
+
+  // Filter by extension if specified
+  if (opts.extensions && Array.isArray(opts.extensions) && opts.extensions.length > 0) {
+    const exts = opts.extensions.map(e => (e.startsWith('.') ? e.toLowerCase() : `.${e.toLowerCase()}`));
+    files = files.filter(f => exts.includes(f.ext));
+  }
+
+  // Build summary stats
+  const summary = buildSummary(files);
+
+  return {
+    success: true,
+    rootDir,
+    files,
+    summary,
+  };
+}
+
+/**
+ * Build summary statistics from file list
+ * @param {object[]} files - Array of file metadata objects
+ * @returns {object} Summary statistics
+ */
+function buildSummary(files) {
+  const byType = {};
+  const byExtension = {};
+  let totalSize = 0;
+
+  for (const file of files) {
+    totalSize += file.size || 0;
+
+    byType[file.type] = (byType[file.type] || 0) + 1;
+
+    const ext = file.ext || '(none)';
+    byExtension[ext] = (byExtension[ext] || 0) + 1;
+  }
+
+  return {
+    total: files.length,
+    totalSize,
+    totalSizeKB: Math.round((totalSize / 1024) * 100) / 100,
+    byType,
+    byExtension,
+  };
+}
+
+/**
+ * Builds a hierarchical file tree structure from a flat list of file metadata.
+ * @param {object[]} files - Array of file metadata objects (from scanProject)
+ * @param {object} options - Options
+ * @param {boolean} [options.includeMetadata] - Include full metadata on leaf nodes (default: true)
+ * @returns {object} Nested tree structure representing the file hierarchy
+ */
+function buildFileTree(files, options) {
+  const opts = options || {};
+  const includeMetadata = opts.includeMetadata !== false;
+
+  if (!files || !Array.isArray(files)) {
+    return { name: '.', type: 'directory', children: {} };
+  }
+
+  const tree = {
+    name: '.',
+    type: 'directory',
+    children: {},
+  };
+
+  for (const file of files) {
+    if (!file || !file.path) continue;
+
+    const parts = file.path.replace(/\\/g, '/').split('/').filter(Boolean);
+    let node = tree;
+
+    // Traverse/create directory nodes
+    for (let i = 0; i < parts.length - 1; i++) {
+      const part = parts[i];
+      if (!node.children[part]) {
+        node.children[part] = {
+          name: part,
+          type: 'directory',
+          path: parts.slice(0, i + 1).join('/'),
+          children: {},
+        };
+      }
+      node = node.children[part];
+    }
+
+    // Add the file leaf node
+    const fileName = parts[parts.length - 1];
+    const leafNode = {
+      name: fileName,
+      type: 'file',
+      path: file.path,
+    };
+
+    if (includeMetadata) {
+      leafNode.size = file.size;
+      leafNode.sizeKB = file.sizeKB;
+      leafNode.ext = file.ext;
+      leafNode.fileType = file.type;
+      leafNode.modified = file.modified;
+    }
+
+    node.children[fileName] = leafNode;
+  }
+
+  return tree;
+}
+
+/**
+ * Filters a file inventory by type, extension, directory, or custom predicate.
+ * @param {object[]|object} filesOrInventory - Array of file metadata objects, or full scanProject result
+ * @param {object} filterOptions - Filter criteria
+ * @param {string|string[]} [filterOptions.types] - File type(s) to include (e.g. 'javascript', 'json')
+ * @param {string|string[]} [filterOptions.extensions] - Extension(s) to include (e.g. '.js', '.ts')
+ * @param {string|string[]} [filterOptions.directories] - Only include files under these directories
+ * @param {string|string[]} [filterOptions.excludeDirectories] - Exclude files under these directories
+ * @param {string|string[]} [filterOptions.excludeTypes] - File type(s) to exclude
+ * @param {string|string[]} [filterOptions.excludeExtensions] - Extension(s) to exclude
+ * @param {number} [filterOptions.maxSize] - Maximum file size in bytes
+ * @param {number} [filterOptions.minSize] - Minimum file size in bytes
+ * @param {Function} [filterOptions.predicate] - Custom filter function (file) => boolean
+ * @returns {object[]} Filtered array of file metadata objects
+ */
+function filterFiles(filesOrInventory, filterOptions) {
+  const opts = filterOptions || {};
+
+  // Accept either a raw array or a scanProject result object
+  let files;
+  if (Array.isArray(filesOrInventory)) {
+    files = filesOrInventory;
+  } else if (filesOrInventory && Array.isArray(filesOrInventory.files)) {
+    files = filesOrInventory.files;
+  } else {
+    return [];
+  }
+
+  // Normalize filter values to arrays
+  const types = normalizeToArray(opts.types);
+  const extensions = normalizeToArray(opts.extensions).map(e =>
+    e.startsWith('.') ? e.toLowerCase() : `.${e.toLowerCase()}`
+  );
+  const directories = normalizeToArray(opts.directories).map(d => d.replace(/\\/g, '/'));
+  const excludeDirectories = normalizeToArray(opts.excludeDirectories).map(d => d.replace(/\\/g, '/'));
+  const excludeTypes = normalizeToArray(opts.excludeTypes);
+  const excludeExtensions = normalizeToArray(opts.excludeExtensions).map(e =>
+    e.startsWith('.') ? e.toLowerCase() : `.${e.toLowerCase()}`
+  );
+
+  return files.filter(file => {
+    if (!file) return false;
+
+    // Include by type
+    if (types.length > 0 && !types.includes(file.type)) {
+      return false;
+    }
+
+    // Include by extension
+    if (extensions.length > 0 && !extensions.includes(file.ext)) {
+      return false;
+    }
+
+    // Include by directory (file must be under one of these dirs)
+    if (directories.length > 0) {
+      const fileDir = (file.directory || '').replace(/\\/g, '/');
+      const filePath = (file.path || '').replace(/\\/g, '/');
+      const inDir = directories.some(dir => {
+        const normalDir = dir.endsWith('/') ? dir : `${dir}/`;
+        return fileDir === dir ||
+          fileDir.startsWith(normalDir) ||
+          filePath.startsWith(normalDir) ||
+          filePath === dir;
+      });
+      if (!inDir) return false;
+    }
+
+    // Exclude by directory
+    if (excludeDirectories.length > 0) {
+      const fileDir = (file.directory || '').replace(/\\/g, '/');
+      const filePath = (file.path || '').replace(/\\/g, '/');
+      const inExcluded = excludeDirectories.some(dir => {
+        const normalDir = dir.endsWith('/') ? dir : `${dir}/`;
+        return fileDir === dir ||
+          fileDir.startsWith(normalDir) ||
+          filePath.startsWith(normalDir);
+      });
+      if (inExcluded) return false;
+    }
+
+    // Exclude by type
+    if (excludeTypes.length > 0 && excludeTypes.includes(file.type)) {
+      return false;
+    }
+
+    // Exclude by extension
+    if (excludeExtensions.length > 0 && excludeExtensions.includes(file.ext)) {
+      return false;
+    }
+
+    // Filter by max size
+    if (opts.maxSize !== undefined && opts.maxSize !== null) {
+      if (file.size > opts.maxSize) return false;
+    }
+
+    // Filter by min size
+    if (opts.minSize !== undefined && opts.minSize !== null) {
+      if (file.size < opts.minSize) return false;
+    }
+
+    // Custom predicate
+    if (typeof opts.predicate === 'function') {
+      try {
+        if (!opts.predicate(file)) return false;
+      } catch (e) {
+        return false;
+      }
+    }
+
+    return true;
+  });
+}
+
+/**
+ * Normalize a value to an array, handling null/undefined/string/array
+ * @param {*} val
+ * @returns {string[]}
+ */
+function normalizeToArray(val) {
+  if (!val) return [];
+  if (Array.isArray(val)) return val.filter(Boolean);
+  if (typeof val === 'string') return [val];
+  return [];
+}
+
+module.exports = { scanProject, buildFileTree, filterFiles };