baseguard 1.0.4 → 1.0.6

package/src/core/file-processor.ts

@@ -1,338 +0,0 @@
-import { Worker } from 'worker_threads';
-import { cpus } from 'os';
-import { join, dirname } from 'path';
-import { fileURLToPath } from 'url';
-import type { DetectedFeature } from '../types/index.js';
-import { CacheManager } from './cache-manager.js';
-
-/**
- * Worker task for file parsing
- */
-interface WorkerTask {
-  id: string;
-  filePath: string;
-  content?: string;
-}
-
-/**
- * Worker result
- */
-interface WorkerResult {
-  id: string;
-  features: DetectedFeature[];
-  error?: string;
-}
-
-/**
- * File processor with concurrent parsing using worker threads
- */
-export class FileProcessor {
-  private readonly maxWorkers: number;
-  private readonly cacheManager: CacheManager;
-  private workers: Worker[] = [];
-  private taskQueue: WorkerTask[] = [];
-  private pendingTasks = new Map<string, {
-    resolve: (features: DetectedFeature[]) => void;
-    reject: (error: Error) => void;
-  }>();
-  private isProcessing = false;
-
-  constructor(options: {
-    maxWorkers?: number;
-    cacheManager?: CacheManager;
-  } = {}) {
-    this.maxWorkers = options.maxWorkers || Math.min(cpus().length, 8);
-    this.cacheManager = options.cacheManager || new CacheManager();
-  }
-
-  /**
-   * Process multiple files concurrently with caching
-   */
-  async processFiles(filePaths: string[]): Promise<DetectedFeature[]> {
-    // Check cache for unchanged files
-    const { changed, unchanged } = await this.cacheManager.getChangedFiles(filePaths);
-    
-    // Get cached results for unchanged files
-    const cachedFeatures: DetectedFeature[] = [];
-    for (const filePath of unchanged) {
-      const cached = await this.cacheManager.getCachedParseResult(filePath);
-      if (cached) {
-        cachedFeatures.push(...cached);
-      } else {
-        // Cache miss, need to process
-        changed.push(filePath);
-      }
-    }
-
-    // Process changed files
-    const newFeatures = changed.length > 0 
-      ? await this.processFilesWithWorkers(changed)
-      : [];
-
-    return [...cachedFeatures, ...newFeatures];
-  }
-
-  /**
-   * Process files using worker threads
-   */
-  private async processFilesWithWorkers(filePaths: string[]): Promise<DetectedFeature[]> {
-    if (filePaths.length === 0) {
-      return [];
-    }
-
-    // Create worker tasks
-    const tasks: WorkerTask[] = filePaths.map((filePath, index) => ({
-      id: `task_${index}_${Date.now()}`,
-      filePath
-    }));
-
-    // Process tasks in batches
-    const batchSize = Math.max(1, Math.ceil(tasks.length / this.maxWorkers));
-    const batches: WorkerTask[][] = [];
-    
-    for (let i = 0; i < tasks.length; i += batchSize) {
-      batches.push(tasks.slice(i, i + batchSize));
-    }
-
-    const allFeatures: DetectedFeature[] = [];
-
-    // Process each batch
-    for (const batch of batches) {
-      const batchResults = await Promise.allSettled(
-        batch.map(task => this.processTask(task))
-      );
-
-      batchResults.forEach((result, index) => {
-        const task = batch[index];
-        if (!task) return;
-        
-        if (result.status === 'fulfilled') {
-          allFeatures.push(...result.value);
-          // Cache the result
-          this.cacheManager.setCachedParseResult(task.filePath, result.value);
-        } else {
-          console.warn(`Failed to process ${task.filePath}: ${result.reason}`);
-        }
-      });
-
-      // Small delay between batches to prevent overwhelming
-      if (batches.length > 1) {
-        await this.sleep(10);
-      }
-    }
-
-    return allFeatures;
-  }
-
-  /**
-   * Process a single task
-   */
-  private async processTask(task: WorkerTask): Promise<DetectedFeature[]> {
-    return new Promise((resolve, reject) => {
-      // Check cache first
-      this.cacheManager.getCachedParseResult(task.filePath)
-        .then(cached => {
-          if (cached) {
-            resolve(cached);
-            return;
-          }
-
-          // Add to pending tasks
-          this.pendingTasks.set(task.id, { resolve, reject });
-          this.taskQueue.push(task);
-          
-          // Start processing if not already running
-          if (!this.isProcessing) {
-            this.startProcessing();
-          }
-        })
-        .catch(reject);
-    });
-  }
-
-  /**
-   * Start worker processing
-   */
-  private async startProcessing(): Promise<void> {
-    if (this.isProcessing) {
-      return;
-    }
-
-    this.isProcessing = true;
-
-    try {
-      // Initialize workers
-      await this.initializeWorkers();
-
-      // Process tasks
-      while (this.taskQueue.length > 0 || this.pendingTasks.size > 0) {
-        await this.processBatch();
-        await this.sleep(10);
-      }
-    } finally {
-      // Cleanup
-      await this.terminateWorkers();
-      this.isProcessing = false;
-    }
-  }
-
-  /**
-   * Initialize worker threads
-   */
-  private async initializeWorkers(): Promise<void> {
-    const workerScript = this.getWorkerScriptPath();
-    const numWorkers = Math.min(this.maxWorkers, this.taskQueue.length);
-
-    for (let i = 0; i < numWorkers; i++) {
-      try {
-        const worker = new Worker(workerScript);
-        
-        worker.on('message', (result: WorkerResult) => {
-          this.handleWorkerResult(result);
-        });
-
-        worker.on('error', (error) => {
-          console.error(`Worker error: ${error.message}`);
-        });
-
-        this.workers.push(worker);
-      } catch (error) {
-        console.warn(`Failed to create worker: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      }
-    }
-  }
-
-  /**
-   * Process a batch of tasks with available workers
-   */
-  private async processBatch(): Promise<void> {
-    const availableWorkers = this.workers.length;
-    const tasksToProcess = this.taskQueue.splice(0, availableWorkers);
-
-    if (tasksToProcess.length === 0) {
-      return;
-    }
-
-    // Assign tasks to workers
-    const promises = tasksToProcess.map((task, index) => {
-      const worker = this.workers[index % this.workers.length];
-      return this.assignTaskToWorker(worker, task);
-    });
-
-    await Promise.allSettled(promises);
-  }
-
-  /**
-   * Assign task to worker
-   */
-  private async assignTaskToWorker(worker: Worker | undefined, task: WorkerTask): Promise<void> {
-    if (!worker) {
-      throw new Error('Worker is not available');
-    }
-    
-    return new Promise((resolve) => {
-      const timeout = setTimeout(() => {
-        console.warn(`Worker task ${task.id} timed out`);
-        this.handleWorkerError(task.id, new Error('Worker timeout'));
-        resolve();
-      }, 30000); // 30 second timeout
-
-      const messageHandler = (result: WorkerResult) => {
-        if (result.id === task.id) {
-          clearTimeout(timeout);
-          worker.off('message', messageHandler);
-          resolve();
-        }
-      };
-
-      worker.on('message', messageHandler);
-      worker.postMessage(task);
-    });
-  }
-
-  /**
-   * Handle worker result
-   */
-  private handleWorkerResult(result: WorkerResult): void {
-    const pending = this.pendingTasks.get(result.id);
-    if (!pending) {
-      return;
-    }
-
-    this.pendingTasks.delete(result.id);
-
-    if (result.error) {
-      pending.reject(new Error(result.error));
-    } else {
-      pending.resolve(result.features);
-    }
-  }
-
-  /**
-   * Handle worker error
-   */
-  private handleWorkerError(taskId: string, error: Error): void {
-    const pending = this.pendingTasks.get(taskId);
-    if (pending) {
-      this.pendingTasks.delete(taskId);
-      pending.reject(error);
-    }
-  }
-
-  /**
-   * Terminate all workers
-   */
-  private async terminateWorkers(): Promise<void> {
-    await Promise.all(
-      this.workers.map(worker => worker.terminate())
-    );
-    this.workers = [];
-  }
-
-  /**
-   * Get worker script path
-   */
-  private getWorkerScriptPath(): string {
-    // For now, we'll use a simple fallback since we don't have worker threads implemented yet
-    // In a real implementation, this would point to a separate worker script
-    const __filename = fileURLToPath(import.meta.url);
-    const __dirname = dirname(__filename);
-    return join(__dirname, 'parser-worker.js');
-  }
-
-  /**
-   * Sleep utility
-   */
-  private sleep(ms: number): Promise<void> {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  /**
-   * Get processing statistics
-   */
-  getStats(): {
-    maxWorkers: number;
-    activeWorkers: number;
-    queuedTasks: number;
-    pendingTasks: number;
-    cacheStats: any;
-  } {
-    return {
-      maxWorkers: this.maxWorkers,
-      activeWorkers: this.workers.length,
-      queuedTasks: this.taskQueue.length,
-      pendingTasks: this.pendingTasks.size,
-      cacheStats: this.cacheManager.getStats()
-    };
-  }
-
-  /**
-   * Cleanup resources
-   */
-  async cleanup(): Promise<void> {
-    await this.terminateWorkers();
-    this.taskQueue = [];
-    this.pendingTasks.clear();
-    this.isProcessing = false;
-  }
-}

package/src/core/gitignore-manager.ts

@@ -1,169 +0,0 @@
-import { readFile, writeFile, access } from 'fs/promises';
-import { constants } from 'fs';
-
-/**
- * Manages .gitignore file to ensure sensitive configuration is not committed
- */
-export class GitignoreManager {
-  private static readonly GITIGNORE_FILE = '.gitignore';
-  private static readonly CONFIG_FILE = '.baseguardrc.json';
-
-  /**
-   * Ensure .baseguardrc.json is in .gitignore for security
-   */
-  static async ensureConfigIgnored(): Promise<boolean> {
-    try {
-      // Check if .gitignore exists
-      const gitignoreExists = await this.fileExists(this.GITIGNORE_FILE);
-      
-      if (!gitignoreExists) {
-        // Create .gitignore with BaseGuard config
-        await this.createGitignore();
-        return true;
-      }
-
-      // Read existing .gitignore
-      const content = await readFile(this.GITIGNORE_FILE, 'utf-8');
-      
-      // Check if our config file is already ignored
-      if (this.isConfigIgnored(content)) {
-        return false; // Already ignored, no changes made
-      }
-
-      // Add our config to .gitignore
-      await this.addConfigToGitignore(content);
-      return true; // Changes made
-
-    } catch (error) {
-      console.warn(`Warning: Could not update .gitignore: ${error instanceof Error ? error.message : 'Unknown error'}`);
-      return false;
-    }
-  }
-
-  /**
-   * Check if a file exists
-   */
-  private static async fileExists(filePath: string): Promise<boolean> {
-    try {
-      await access(filePath, constants.F_OK);
-      return true;
-    } catch {
-      return false;
-    }
-  }
-
-  /**
-   * Create new .gitignore with BaseGuard configuration
-   */
-  private static async createGitignore(): Promise<void> {
-    const content = `# BaseGuard configuration (contains API keys)
-${this.CONFIG_FILE}
-`;
-    await writeFile(this.GITIGNORE_FILE, content, 'utf-8');
-  }
-
-  /**
-   * Check if config file is already ignored
-   */
-  private static isConfigIgnored(gitignoreContent: string): boolean {
-    const lines = gitignoreContent.split('\n').map(line => line.trim());
-    
-    // Check for exact match or pattern that would match our config
-    return lines.some(line => {
-      if (line === this.CONFIG_FILE) return true;
-      if (line === '*.json' && this.CONFIG_FILE.endsWith('.json')) return true;
-      if (line === '.baseguardrc*') return true;
-      
-      // Check for glob patterns that might match
-      if (line.includes('*') && this.matchesPattern(this.CONFIG_FILE, line)) {
-        return true;
-      }
-      
-      return false;
-    });
-  }
-
-  /**
-   * Add config file to existing .gitignore
-   */
-  private static async addConfigToGitignore(existingContent: string): Promise<void> {
-    let content = existingContent;
-    
-    // Ensure content ends with newline
-    if (!content.endsWith('\n')) {
-      content += '\n';
-    }
-
-    // Add BaseGuard section
-    content += `
-# BaseGuard configuration (contains API keys)
-${this.CONFIG_FILE}
-`;
-
-    await writeFile(this.GITIGNORE_FILE, content, 'utf-8');
-  }
-
-  /**
-   * Simple glob pattern matching
-   */
-  private static matchesPattern(filename: string, pattern: string): boolean {
-    // Convert glob pattern to regex
-    const regexPattern = pattern
-      .replace(/\./g, '\\.')
-      .replace(/\*/g, '.*')
-      .replace(/\?/g, '.');
-    
-    const regex = new RegExp(`^${regexPattern}$`);
-    return regex.test(filename);
-  }
-
-  /**
-   * Check if config file is properly ignored
-   */
-  static async isConfigSecure(): Promise<{
-    gitignoreExists: boolean;
-    configIgnored: boolean;
-    recommendations: string[];
-  }> {
-    const recommendations: string[] = [];
-    
-    const gitignoreExists = await this.fileExists(this.GITIGNORE_FILE);
-    let configIgnored = false;
-
-    if (!gitignoreExists) {
-      recommendations.push('Create .gitignore file to protect sensitive configuration');
-    } else {
-      try {
-        const content = await readFile(this.GITIGNORE_FILE, 'utf-8');
-        configIgnored = this.isConfigIgnored(content);
-        
-        if (!configIgnored) {
-          recommendations.push(`Add "${this.CONFIG_FILE}" to .gitignore to prevent committing API keys`);
-        }
-      } catch (error) {
-        recommendations.push('Check .gitignore file permissions and readability');
-      }
-    }
-
-    // Check if config file exists and might be tracked
-    const configExists = await this.fileExists(this.CONFIG_FILE);
-    if (configExists && !configIgnored) {
-      recommendations.push('Remove .baseguardrc.json from git tracking if already committed');
-      recommendations.push('Run: git rm --cached .baseguardrc.json');
-    }
-
-    return {
-      gitignoreExists,
-      configIgnored,
-      recommendations
-    };
-  }
-
-  /**
-   * Get security recommendations for the user
-   */
-  static async getSecurityRecommendations(): Promise<string[]> {
-    const status = await this.isConfigSecure();
-    return status.recommendations;
-  }
-}