baseguard 1.0.0

package/src/core/file-processor.ts

@@ -0,0 +1,331 @@
+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) => {
+        if (result.status === 'fulfilled') {
+          allFeatures.push(...result.value);
+          // Cache the result
+          this.cacheManager.setCachedParseResult(batch[index].filePath, result.value);
+        } else {
+          console.warn(`Failed to process ${batch[index].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, task: WorkerTask): Promise<void> {
+    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

@@ -0,0 +1,169 @@
+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;
+  }
+}