codesummary 1.0.0

package/src/scanner.js

@@ -0,0 +1,330 @@
+import fs from 'fs-extra';
+import path from 'path';
+import chalk from 'chalk';
+import ErrorHandler from './errorHandler.js';
+
+/**
+ * File Scanner for CodeSummary
+ * Handles recursive directory traversal and file filtering
+ */
+export class Scanner {
+  constructor(config) {
+    this.config = config;
+    this.allowedExtensions = new Set(config.allowedExtensions.map(ext => ext.toLowerCase()));
+    this.excludeDirs = new Set(config.excludeDirs);
+  }
+
+  /**
+   * Scan a directory recursively and return files grouped by extension
+   * @param {string} rootPath - Root directory to scan
+   * @returns {Promise<object>} Object with extensions as keys and file arrays as values
+   */
+  async scanDirectory(rootPath) {
+    try {
+      // Validate and sanitize input path
+      const sanitizedPath = ErrorHandler.sanitizeInput(rootPath);
+      ErrorHandler.validatePath(sanitizedPath, { mustExist: true, preventTraversal: true });
+      
+      const resolvedRoot = path.resolve(sanitizedPath);
+      const stats = await fs.stat(resolvedRoot);
+      
+      if (!stats.isDirectory()) {
+        throw new Error(`Path is not a directory: ${resolvedRoot}`);
+      }
+
+      console.log(chalk.gray(`Scanning directory: ${resolvedRoot}`));
+
+      const filesByExtension = {};
+      const scannedFiles = new Set(); // Prevent duplicates
+
+      await this.walkDirectory(resolvedRoot, resolvedRoot, filesByExtension, scannedFiles);
+
+      // Sort files within each extension group
+      Object.keys(filesByExtension).forEach(ext => {
+        filesByExtension[ext].sort((a, b) => a.relativePath.localeCompare(b.relativePath));
+      });
+
+      return filesByExtension;
+    } catch (error) {
+      if (error.code === 'ENOENT') {
+        throw new Error(`Directory does not exist: ${rootPath}`);
+      } else if (error.code === 'EACCES') {
+        throw new Error(`Permission denied accessing directory: ${rootPath}`);
+      }
+      throw error;
+    }
+  }
+
+  /**
+   * Recursively walk through directory structure
+   * @param {string} currentPath - Current directory being processed
+   * @param {string} rootPath - Original root path for relative path calculation
+   * @param {object} filesByExtension - Accumulator object for results
+   * @param {Set} scannedFiles - Set to track processed files and avoid duplicates
+   */
+  async walkDirectory(currentPath, rootPath, filesByExtension, scannedFiles) {
+    try {
+      const entries = await fs.readdir(currentPath, { withFileTypes: true });
+
+      for (const entry of entries) {
+        const fullPath = path.join(currentPath, entry.name);
+        const relativePath = path.relative(rootPath, fullPath);
+
+        if (entry.isDirectory()) {
+          // Skip excluded directories and hidden directories (unless explicitly allowed)
+          if (this.shouldSkipDirectory(entry.name, relativePath)) {
+            continue;
+          }
+
+          // Recursively scan subdirectory
+          await this.walkDirectory(fullPath, rootPath, filesByExtension, scannedFiles);
+        } else if (entry.isFile()) {
+          // Process file if it matches criteria
+          await this.processFile(fullPath, rootPath, filesByExtension, scannedFiles);
+        }
+        // Skip symbolic links, special files, etc.
+      }
+    } catch (error) {
+      // Handle different types of file system errors appropriately
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        console.warn(chalk.yellow(`WARNING: Permission denied: ${currentPath}`));
+      } else if (error.code === 'ENOENT') {
+        console.warn(chalk.yellow(`WARNING: Directory no longer exists: ${currentPath}`));
+      } else {
+        console.warn(chalk.yellow(`WARNING: Cannot read directory ${currentPath}: ${error.message}`));
+      }
+    }
+  }
+
+  /**
+   * Process a single file and add it to results if it matches criteria
+   * @param {string} fullPath - Absolute path to the file
+   * @param {string} rootPath - Root path for relative calculation
+   * @param {object} filesByExtension - Results accumulator
+   * @param {Set} scannedFiles - Set of already processed files
+   */
+  async processFile(fullPath, rootPath, filesByExtension, scannedFiles) {
+    try {
+      const relativePath = path.relative(rootPath, fullPath);
+      
+      // Avoid processing the same file twice (in case of symlinks)
+      if (scannedFiles.has(fullPath)) {
+        return;
+      }
+      scannedFiles.add(fullPath);
+
+      const extension = path.extname(relativePath).toLowerCase();
+
+      // Skip files without extensions or not in allowed list
+      if (!extension || !this.allowedExtensions.has(extension)) {
+        return;
+      }
+
+      // Skip hidden files (starting with .) unless explicitly needed
+      const fileName = path.basename(relativePath);
+      if (fileName.startsWith('.') && !this.isAllowedHiddenFile(fileName)) {
+        return;
+      }
+
+      // Verify file is readable
+      const stats = await fs.stat(fullPath);
+      if (!stats.isFile()) {
+        return;
+      }
+
+      // Add to results
+      if (!filesByExtension[extension]) {
+        filesByExtension[extension] = [];
+      }
+
+      filesByExtension[extension].push({
+        relativePath: relativePath.replace(/\\/g, '/'), // Normalize path separators
+        absolutePath: fullPath,
+        size: stats.size,
+        modified: stats.mtime
+      });
+
+    } catch (error) {
+      // Handle file processing errors with appropriate context
+      if (error.code === 'EACCES' || error.code === 'EPERM') {
+        console.warn(chalk.yellow(`WARNING: Permission denied: ${relativePath}`));
+      } else if (error.code === 'ENOENT') {
+        // File might have been deleted during scan
+        console.warn(chalk.yellow(`WARNING: File no longer exists: ${relativePath}`));
+      } else {
+        console.warn(chalk.yellow(`WARNING: Cannot process file ${relativePath}: ${error.message}`));
+      }
+    }
+  }
+
+  /**
+   * Determine if a directory should be skipped
+   * @param {string} dirName - Directory name
+   * @param {string} relativePath - Relative path from root
+   * @returns {boolean} True if directory should be skipped
+   */
+  shouldSkipDirectory(dirName, relativePath) {
+    // Skip directories in exclude list
+    if (this.excludeDirs.has(dirName)) {
+      return true;
+    }
+
+    // Skip hidden directories (starting with .) unless explicitly allowed
+    if (dirName.startsWith('.') && !this.isAllowedHiddenDirectory(dirName)) {
+      return true;
+    }
+
+    // Skip common build/cache directories that might not be in exclude list
+    const commonSkipDirs = new Set([
+      'tmp', 'temp', 'cache', '.cache', 'logs', '.logs',
+      'bower_components', 'vendor', '.vendor'
+    ]);
+
+    if (commonSkipDirs.has(dirName.toLowerCase())) {
+      return true;
+    }
+
+    return false;
+  }
+
+  /**
+   * Check if a hidden file should be included
+   * @param {string} fileName - File name
+   * @returns {boolean} True if file should be included
+   */
+  isAllowedHiddenFile(fileName) {
+    const allowedHiddenFiles = new Set([
+      '.gitignore', '.gitattributes', '.editorconfig',
+      '.eslintrc.js', '.eslintrc.json', '.prettierrc',
+      '.env.example', '.htaccess'
+    ]);
+
+    return allowedHiddenFiles.has(fileName);
+  }
+
+  /**
+   * Check if a hidden directory should be included
+   * @param {string} dirName - Directory name
+   * @returns {boolean} True if directory should be included
+   */
+  isAllowedHiddenDirectory(dirName) {
+    const allowedHiddenDirs = new Set([
+      '.github', '.gitlab', '.circleci'
+    ]);
+
+    return allowedHiddenDirs.has(dirName);
+  }
+
+  /**
+   * Get file extension descriptions for user display
+   * @param {object} filesByExtension - Files grouped by extension
+   * @returns {Array} Array of extension info objects
+   */
+  getExtensionInfo(filesByExtension) {
+    const extensionDescriptions = {
+      '.js': 'JavaScript',
+      '.ts': 'TypeScript',
+      '.jsx': 'React JSX',
+      '.tsx': 'TypeScript JSX',
+      '.json': 'JSON',
+      '.xml': 'XML',
+      '.html': 'HTML',
+      '.css': 'CSS',
+      '.scss': 'SCSS',
+      '.sass': 'Sass',
+      '.md': 'Markdown',
+      '.txt': 'Text',
+      '.py': 'Python',
+      '.java': 'Java',
+      '.cs': 'C#',
+      '.cpp': 'C++',
+      '.c': 'C',
+      '.h': 'Header',
+      '.yaml': 'YAML',
+      '.yml': 'YAML',
+      '.sh': 'Shell Script',
+      '.bat': 'Batch File',
+      '.ps1': 'PowerShell',
+      '.php': 'PHP',
+      '.rb': 'Ruby',
+      '.go': 'Go',
+      '.rs': 'Rust',
+      '.swift': 'Swift',
+      '.kt': 'Kotlin',
+      '.scala': 'Scala',
+      '.vue': 'Vue.js',
+      '.svelte': 'Svelte',
+      '.dockerfile': 'Dockerfile',
+      '.sql': 'SQL',
+      '.graphql': 'GraphQL'
+    };
+
+    return Object.keys(filesByExtension)
+      .sort()
+      .map(ext => ({
+        extension: ext,
+        description: extensionDescriptions[ext] || 'Unknown',
+        count: filesByExtension[ext].length,
+        files: filesByExtension[ext]
+      }));
+  }
+
+  /**
+   * Calculate total statistics for scanned files
+   * @param {object} filesByExtension - Files grouped by extension
+   * @returns {object} Statistics object
+   */
+  calculateStatistics(filesByExtension) {
+    let totalFiles = 0;
+    let totalSize = 0;
+    const extensionCount = Object.keys(filesByExtension).length;
+
+    Object.values(filesByExtension).forEach(files => {
+      totalFiles += files.length;
+      totalSize += files.reduce((sum, file) => sum + file.size, 0);
+    });
+
+    return {
+      totalFiles,
+      totalSize,
+      extensionCount,
+      averageFileSize: totalFiles > 0 ? Math.round(totalSize / totalFiles) : 0,
+      totalSizeFormatted: this.formatFileSize(totalSize)
+    };
+  }
+
+  /**
+   * Format file size in human readable format
+   * @param {number} bytes - Size in bytes
+   * @returns {string} Formatted size string
+   */
+  formatFileSize(bytes) {
+    const units = ['B', 'KB', 'MB', 'GB'];
+    let size = bytes;
+    let unitIndex = 0;
+
+    while (size >= 1024 && unitIndex < units.length - 1) {
+      size /= 1024;
+      unitIndex++;
+    }
+
+    return `${size.toFixed(1)} ${units[unitIndex]}`;
+  }
+
+  /**
+   * Display scan results summary
+   * @param {object} filesByExtension - Files grouped by extension
+   */
+  displayScanSummary(filesByExtension) {
+    const stats = this.calculateStatistics(filesByExtension);
+    const extensions = Object.keys(filesByExtension).sort();
+
+    console.log(chalk.cyan('\nScan Summary:'));
+    console.log(chalk.gray(`   Extensions found: ${extensions.join(', ')}`));
+    console.log(chalk.gray(`   Total files: ${stats.totalFiles}`));
+    console.log(chalk.gray(`   Total size: ${stats.totalSizeFormatted}`));
+    console.log();
+  }
+}
+
+export default Scanner;