baseguard 1.0.2 → 1.0.4

package/src/core/directory-filter.ts

@@ -1,421 +1,421 @@
-import { readdir, stat } from 'fs/promises';
-import { join, basename, extname } from 'path';
-import { glob } from 'glob';
-
-/**
- * Smart directory filtering to skip node_modules and build outputs
- */
-export class DirectoryFilter {
-  private readonly defaultExcludePatterns: string[] = [
-    'node_modules',
-    '.git',
-    '.svn',
-    '.hg',
-    'dist',
-    'build',
-    'out',
-    '.next',
-    '.nuxt',
-    '.output',
-    'coverage',
-    '.nyc_output',
-    '.cache',
-    '.parcel-cache',
-    '.vscode',
-    '.idea',
-    '*.log',
-    '*.tmp',
-    '*.temp',
-    '.DS_Store',
-    'Thumbs.db'
-  ];
-
-  private readonly defaultIncludeExtensions: string[] = [
-    '.js',
-    '.jsx',
-    '.ts',
-    '.tsx',
-    '.vue',
-    '.svelte',
-    '.css',
-    '.scss',
-    '.sass',
-    '.less',
-    '.html',
-    '.htm'
-  ];
-
-  private readonly excludePatterns: Set<string>;
-  private readonly includeExtensions: Set<string>;
-  private readonly maxDepth: number;
-  private readonly maxFiles: number;
-
-  constructor(options: {
-    excludePatterns?: string[];
-    includeExtensions?: string[];
-    maxDepth?: number;
-    maxFiles?: number;
-  } = {}) {
-    this.excludePatterns = new Set([
-      ...this.defaultExcludePatterns,
-      ...(options.excludePatterns || [])
-    ]);
-    
-    this.includeExtensions = new Set(
-      options.includeExtensions || this.defaultIncludeExtensions
-    );
-    
-    this.maxDepth = options.maxDepth || 10;
-    this.maxFiles = options.maxFiles || 10000;
-  }
-
-  /**
-   * Find files recursively with smart filtering
-   */
-  async findFiles(
-    directories: string[],
-    options: {
-      patterns?: string[];
-      excludePatterns?: string[];
-      includeHidden?: boolean;
-    } = {}
-  ): Promise<string[]> {
-    const {
-      patterns = [],
-      excludePatterns = [],
-      includeHidden = false
-    } = options;
-
-    const allExcludePatterns = new Set([
-      ...this.excludePatterns,
-      ...excludePatterns
-    ]);
-
-    const files: string[] = [];
-    const processedDirs = new Set<string>();
-
-    for (const directory of directories) {
-      try {
-        await this.findFilesRecursive(
-          directory,
-          files,
-          allExcludePatterns,
-          patterns,
-          includeHidden,
-          0,
-          processedDirs
-        );
-      } catch (error) {
-        console.warn(`Could not scan directory ${directory}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      }
-
-      // Stop if we've found too many files
-      if (files.length >= this.maxFiles) {
-        console.warn(`Reached maximum file limit (${this.maxFiles}). Some files may be skipped.`);
-        break;
-      }
-    }
-
-    return files.slice(0, this.maxFiles);
-  }
-
-  /**
-   * Find files using glob patterns (faster for specific patterns)
-   */
-  async findFilesWithGlob(
-    patterns: string[],
-    options: {
-      cwd?: string;
-      excludePatterns?: string[];
-    } = {}
-  ): Promise<string[]> {
-    const { cwd = process.cwd(), excludePatterns = [] } = options;
-
-    try {
-      const allFiles = await glob(patterns, {
-        cwd,
-        ignore: [
-          ...Array.from(this.excludePatterns),
-          ...excludePatterns
-        ],
-        absolute: true,
-        nodir: true
-      });
-
-      // Filter by supported extensions
-      return allFiles.filter(file => this.isSupportedFile(file));
-    } catch (error) {
-      console.error(`Glob search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      return [];
-    }
-  }
-
-  /**
-   * Check if a file should be processed
-   */
-  isSupportedFile(filePath: string): boolean {
-    const extension = extname(filePath).toLowerCase();
-    return this.includeExtensions.has(extension);
-  }
-
-  /**
-   * Check if a directory should be excluded
-   */
-  isExcludedDirectory(dirPath: string): boolean {
-    const dirName = basename(dirPath);
-    
-    // Check exact matches
-    if (this.excludePatterns.has(dirName)) {
-      return true;
-    }
-
-    // Check pattern matches
-    for (const pattern of this.excludePatterns) {
-      if (pattern.includes('*') || pattern.includes('?')) {
-        // Simple glob pattern matching
-        const regex = new RegExp(
-          pattern
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.')
-        );
-        if (regex.test(dirName)) {
-          return true;
-        }
-      }
-    }
-
-    return false;
-  }
-
-  /**
-   * Get file statistics for a directory
-   */
-  async getDirectoryStats(directoryPath: string): Promise<{
-    totalFiles: number;
-    supportedFiles: number;
-    directories: number;
-    excludedDirectories: number;
-    largestFiles: Array<{ path: string; size: number }>;
-  }> {
-    const stats = {
-      totalFiles: 0,
-      supportedFiles: 0,
-      directories: 0,
-      excludedDirectories: 0,
-      largestFiles: [] as Array<{ path: string; size: number }>
-    };
-
-    try {
-      await this.collectStats(directoryPath, stats, 0);
-    } catch (error) {
-      console.warn(`Could not collect stats for ${directoryPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-
-    // Sort largest files
-    stats.largestFiles.sort((a, b) => b.size - a.size);
-    stats.largestFiles = stats.largestFiles.slice(0, 10);
-
-    return stats;
-  }
-
-  /**
-   * Recursive file finding with smart filtering
-   */
-  private async findFilesRecursive(
-    currentPath: string,
-    results: string[],
-    excludePatterns: Set<string>,
-    includePatterns: string[],
-    includeHidden: boolean,
-    currentDepth: number,
-    processedDirs: Set<string>
-  ): Promise<void> {
-    // Prevent infinite loops with symlinks
-    if (processedDirs.has(currentPath)) {
-      return;
-    }
-    processedDirs.add(currentPath);
-
-    // Check depth limit
-    if (currentDepth >= this.maxDepth) {
-      return;
-    }
-
-    // Check file limit
-    if (results.length >= this.maxFiles) {
-      return;
-    }
-
-    try {
-      const entries = await readdir(currentPath);
-
-      for (const entry of entries) {
-        // Skip hidden files/directories unless explicitly included
-        if (!includeHidden && entry.startsWith('.')) {
-          continue;
-        }
-
-        const fullPath = join(currentPath, entry);
-
-        try {
-          const stats = await stat(fullPath);
-
-          if (stats.isDirectory()) {
-            // Check if directory should be excluded
-            if (this.isExcludedDirectory(fullPath)) {
-              continue;
-            }
-
-            // Recurse into directory
-            await this.findFilesRecursive(
-              fullPath,
-              results,
-              excludePatterns,
-              includePatterns,
-              includeHidden,
-              currentDepth + 1,
-              processedDirs
-            );
-          } else if (stats.isFile()) {
-            // Check if file matches patterns
-            if (this.shouldIncludeFile(fullPath, includePatterns)) {
-              results.push(fullPath);
-            }
-          }
-        } catch (error) {
-          // Skip files/directories that can't be accessed
-          continue;
-        }
-      }
-    } catch (error) {
-      console.warn(`Could not read directory ${currentPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
-    }
-  }
-
-  /**
-   * Check if file should be included based on patterns
-   */
-  private shouldIncludeFile(filePath: string, includePatterns: string[]): boolean {
-    // If no specific patterns, use extension filtering
-    if (includePatterns.length === 0) {
-      return this.isSupportedFile(filePath);
-    }
-
-    // Check against include patterns
-    const fileName = basename(filePath);
-    return includePatterns.some(pattern => {
-      if (pattern.includes('*') || pattern.includes('?')) {
-        const regex = new RegExp(
-          pattern
-            .replace(/\*/g, '.*')
-            .replace(/\?/g, '.')
-        );
-        return regex.test(fileName);
-      }
-      return fileName === pattern;
-    });
-  }
-
-  /**
-   * Collect directory statistics recursively
-   */
-  private async collectStats(
-    currentPath: string,
-    stats: any,
-    currentDepth: number
-  ): Promise<void> {
-    if (currentDepth >= this.maxDepth) {
-      return;
-    }
-
-    try {
-      const entries = await readdir(currentPath);
-
-      for (const entry of entries) {
-        const fullPath = join(currentPath, entry);
-
-        try {
-          const fileStat = await stat(fullPath);
-
-          if (fileStat.isDirectory()) {
-            stats.directories++;
-            
-            if (this.isExcludedDirectory(fullPath)) {
-              stats.excludedDirectories++;
-              continue;
-            }
-
-            await this.collectStats(fullPath, stats, currentDepth + 1);
-          } else if (fileStat.isFile()) {
-            stats.totalFiles++;
-            
-            if (this.isSupportedFile(fullPath)) {
-              stats.supportedFiles++;
-            }
-
-            // Track largest files
-            if (stats.largestFiles.length < 100) {
-              stats.largestFiles.push({
-                path: fullPath,
-                size: fileStat.size
-              });
-            }
-          }
-        } catch (error) {
-          // Skip files/directories that can't be accessed
-          continue;
-        }
-      }
-    } catch (error) {
-      // Skip directories that can't be read
-    }
-  }
-
-  /**
-   * Get supported extensions
-   */
-  getSupportedExtensions(): string[] {
-    return Array.from(this.includeExtensions);
-  }
-
-  /**
-   * Get exclude patterns
-   */
-  getExcludePatterns(): string[] {
-    return Array.from(this.excludePatterns);
-  }
-
-  /**
-   * Add custom exclude pattern
-   */
-  addExcludePattern(pattern: string): void {
-    this.excludePatterns.add(pattern);
-  }
-
-  /**
-   * Remove exclude pattern
-   */
-  removeExcludePattern(pattern: string): void {
-    this.excludePatterns.delete(pattern);
-  }
-
-  /**
-   * Add supported extension
-   */
-  addSupportedExtension(extension: string): void {
-    if (!extension.startsWith('.')) {
-      extension = '.' + extension;
-    }
-    this.includeExtensions.add(extension.toLowerCase());
-  }
-
-  /**
-   * Remove supported extension
-   */
-  removeSupportedExtension(extension: string): void {
-    if (!extension.startsWith('.')) {
-      extension = '.' + extension;
-    }
-    this.includeExtensions.delete(extension.toLowerCase());
-  }
+import { readdir, stat } from 'fs/promises';
+import { join, basename, extname } from 'path';
+import { glob } from 'glob';
+
+/**
+ * Smart directory filtering to skip node_modules and build outputs
+ */
+export class DirectoryFilter {
+  private readonly defaultExcludePatterns: string[] = [
+    'node_modules',
+    '.git',
+    '.svn',
+    '.hg',
+    'dist',
+    'build',
+    'out',
+    '.next',
+    '.nuxt',
+    '.output',
+    'coverage',
+    '.nyc_output',
+    '.cache',
+    '.parcel-cache',
+    '.vscode',
+    '.idea',
+    '*.log',
+    '*.tmp',
+    '*.temp',
+    '.DS_Store',
+    'Thumbs.db'
+  ];
+
+  private readonly defaultIncludeExtensions: string[] = [
+    '.js',
+    '.jsx',
+    '.ts',
+    '.tsx',
+    '.vue',
+    '.svelte',
+    '.css',
+    '.scss',
+    '.sass',
+    '.less',
+    '.html',
+    '.htm'
+  ];
+
+  private readonly excludePatterns: Set<string>;
+  private readonly includeExtensions: Set<string>;
+  private readonly maxDepth: number;
+  private readonly maxFiles: number;
+
+  constructor(options: {
+    excludePatterns?: string[];
+    includeExtensions?: string[];
+    maxDepth?: number;
+    maxFiles?: number;
+  } = {}) {
+    this.excludePatterns = new Set([
+      ...this.defaultExcludePatterns,
+      ...(options.excludePatterns || [])
+    ]);
+    
+    this.includeExtensions = new Set(
+      options.includeExtensions || this.defaultIncludeExtensions
+    );
+    
+    this.maxDepth = options.maxDepth || 10;
+    this.maxFiles = options.maxFiles || 10000;
+  }
+
+  /**
+   * Find files recursively with smart filtering
+   */
+  async findFiles(
+    directories: string[],
+    options: {
+      patterns?: string[];
+      excludePatterns?: string[];
+      includeHidden?: boolean;
+    } = {}
+  ): Promise<string[]> {
+    const {
+      patterns = [],
+      excludePatterns = [],
+      includeHidden = false
+    } = options;
+
+    const allExcludePatterns = new Set([
+      ...this.excludePatterns,
+      ...excludePatterns
+    ]);
+
+    const files: string[] = [];
+    const processedDirs = new Set<string>();
+
+    for (const directory of directories) {
+      try {
+        await this.findFilesRecursive(
+          directory,
+          files,
+          allExcludePatterns,
+          patterns,
+          includeHidden,
+          0,
+          processedDirs
+        );
+      } catch (error) {
+        console.warn(`Could not scan directory ${directory}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      }
+
+      // Stop if we've found too many files
+      if (files.length >= this.maxFiles) {
+        console.warn(`Reached maximum file limit (${this.maxFiles}). Some files may be skipped.`);
+        break;
+      }
+    }
+
+    return files.slice(0, this.maxFiles);
+  }
+
+  /**
+   * Find files using glob patterns (faster for specific patterns)
+   */
+  async findFilesWithGlob(
+    patterns: string[],
+    options: {
+      cwd?: string;
+      excludePatterns?: string[];
+    } = {}
+  ): Promise<string[]> {
+    const { cwd = process.cwd(), excludePatterns = [] } = options;
+
+    try {
+      const allFiles = await glob(patterns, {
+        cwd,
+        ignore: [
+          ...Array.from(this.excludePatterns),
+          ...excludePatterns
+        ],
+        absolute: true,
+        nodir: true
+      });
+
+      // Filter by supported extensions
+      return allFiles.filter(file => this.isSupportedFile(file));
+    } catch (error) {
+      console.error(`Glob search failed: ${error instanceof Error ? error.message : 'Unknown error'}`);
+      return [];
+    }
+  }
+
+  /**
+   * Check if a file should be processed
+   */
+  isSupportedFile(filePath: string): boolean {
+    const extension = extname(filePath).toLowerCase();
+    return this.includeExtensions.has(extension);
+  }
+
+  /**
+   * Check if a directory should be excluded
+   */
+  isExcludedDirectory(dirPath: string): boolean {
+    const dirName = basename(dirPath);
+    
+    // Check exact matches
+    if (this.excludePatterns.has(dirName)) {
+      return true;
+    }
+
+    // Check pattern matches
+    for (const pattern of this.excludePatterns) {
+      if (pattern.includes('*') || pattern.includes('?')) {
+        // Simple glob pattern matching
+        const regex = new RegExp(
+          pattern
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.')
+        );
+        if (regex.test(dirName)) {
+          return true;
+        }
+      }
+    }
+
+    return false;
+  }
+
+  /**
+   * Get file statistics for a directory
+   */
+  async getDirectoryStats(directoryPath: string): Promise<{
+    totalFiles: number;
+    supportedFiles: number;
+    directories: number;
+    excludedDirectories: number;
+    largestFiles: Array<{ path: string; size: number }>;
+  }> {
+    const stats = {
+      totalFiles: 0,
+      supportedFiles: 0,
+      directories: 0,
+      excludedDirectories: 0,
+      largestFiles: [] as Array<{ path: string; size: number }>
+    };
+
+    try {
+      await this.collectStats(directoryPath, stats, 0);
+    } catch (error) {
+      console.warn(`Could not collect stats for ${directoryPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+
+    // Sort largest files
+    stats.largestFiles.sort((a, b) => b.size - a.size);
+    stats.largestFiles = stats.largestFiles.slice(0, 10);
+
+    return stats;
+  }
+
+  /**
+   * Recursive file finding with smart filtering
+   */
+  private async findFilesRecursive(
+    currentPath: string,
+    results: string[],
+    excludePatterns: Set<string>,
+    includePatterns: string[],
+    includeHidden: boolean,
+    currentDepth: number,
+    processedDirs: Set<string>
+  ): Promise<void> {
+    // Prevent infinite loops with symlinks
+    if (processedDirs.has(currentPath)) {
+      return;
+    }
+    processedDirs.add(currentPath);
+
+    // Check depth limit
+    if (currentDepth >= this.maxDepth) {
+      return;
+    }
+
+    // Check file limit
+    if (results.length >= this.maxFiles) {
+      return;
+    }
+
+    try {
+      const entries = await readdir(currentPath);
+
+      for (const entry of entries) {
+        // Skip hidden files/directories unless explicitly included
+        if (!includeHidden && entry.startsWith('.')) {
+          continue;
+        }
+
+        const fullPath = join(currentPath, entry);
+
+        try {
+          const stats = await stat(fullPath);
+
+          if (stats.isDirectory()) {
+            // Check if directory should be excluded
+            if (this.isExcludedDirectory(fullPath)) {
+              continue;
+            }
+
+            // Recurse into directory
+            await this.findFilesRecursive(
+              fullPath,
+              results,
+              excludePatterns,
+              includePatterns,
+              includeHidden,
+              currentDepth + 1,
+              processedDirs
+            );
+          } else if (stats.isFile()) {
+            // Check if file matches patterns
+            if (this.shouldIncludeFile(fullPath, includePatterns)) {
+              results.push(fullPath);
+            }
+          }
+        } catch (error) {
+          // Skip files/directories that can't be accessed
+          continue;
+        }
+      }
+    } catch (error) {
+      console.warn(`Could not read directory ${currentPath}: ${error instanceof Error ? error.message : 'Unknown error'}`);
+    }
+  }
+
+  /**
+   * Check if file should be included based on patterns
+   */
+  private shouldIncludeFile(filePath: string, includePatterns: string[]): boolean {
+    // If no specific patterns, use extension filtering
+    if (includePatterns.length === 0) {
+      return this.isSupportedFile(filePath);
+    }
+
+    // Check against include patterns
+    const fileName = basename(filePath);
+    return includePatterns.some(pattern => {
+      if (pattern.includes('*') || pattern.includes('?')) {
+        const regex = new RegExp(
+          pattern
+            .replace(/\*/g, '.*')
+            .replace(/\?/g, '.')
+        );
+        return regex.test(fileName);
+      }
+      return fileName === pattern;
+    });
+  }
+
+  /**
+   * Collect directory statistics recursively
+   */
+  private async collectStats(
+    currentPath: string,
+    stats: any,
+    currentDepth: number
+  ): Promise<void> {
+    if (currentDepth >= this.maxDepth) {
+      return;
+    }
+
+    try {
+      const entries = await readdir(currentPath);
+
+      for (const entry of entries) {
+        const fullPath = join(currentPath, entry);
+
+        try {
+          const fileStat = await stat(fullPath);
+
+          if (fileStat.isDirectory()) {
+            stats.directories++;
+            
+            if (this.isExcludedDirectory(fullPath)) {
+              stats.excludedDirectories++;
+              continue;
+            }
+
+            await this.collectStats(fullPath, stats, currentDepth + 1);
+          } else if (fileStat.isFile()) {
+            stats.totalFiles++;
+            
+            if (this.isSupportedFile(fullPath)) {
+              stats.supportedFiles++;
+            }
+
+            // Track largest files
+            if (stats.largestFiles.length < 100) {
+              stats.largestFiles.push({
+                path: fullPath,
+                size: fileStat.size
+              });
+            }
+          }
+        } catch (error) {
+          // Skip files/directories that can't be accessed
+          continue;
+        }
+      }
+    } catch (error) {
+      // Skip directories that can't be read
+    }
+  }
+
+  /**
+   * Get supported extensions
+   */
+  getSupportedExtensions(): string[] {
+    return Array.from(this.includeExtensions);
+  }
+
+  /**
+   * Get exclude patterns
+   */
+  getExcludePatterns(): string[] {
+    return Array.from(this.excludePatterns);
+  }
+
+  /**
+   * Add custom exclude pattern
+   */
+  addExcludePattern(pattern: string): void {
+    this.excludePatterns.add(pattern);
+  }
+
+  /**
+   * Remove exclude pattern
+   */
+  removeExcludePattern(pattern: string): void {
+    this.excludePatterns.delete(pattern);
+  }
+
+  /**
+   * Add supported extension
+   */
+  addSupportedExtension(extension: string): void {
+    if (!extension.startsWith('.')) {
+      extension = '.' + extension;
+    }
+    this.includeExtensions.add(extension.toLowerCase());
+  }
+
+  /**
+   * Remove supported extension
+   */
+  removeSupportedExtension(extension: string): void {
+    if (!extension.startsWith('.')) {
+      extension = '.' + extension;
+    }
+    this.includeExtensions.delete(extension.toLowerCase());
+  }
 }