baseguard 1.0.0 → 1.0.2

package/src/core/baseguard.ts

@@ -16,11 +16,11 @@ import chalk from 'chalk';
  */
 export class BaseGuard {
   private config: Configuration;
-  private parserManager: ParserManager;
-  private baselineChecker: BaselineChecker;
-  private fileProcessor: FileProcessor;
-  private directoryFilter: DirectoryFilter;
-  private cacheManager: CacheManager;
+  private parserManager!: ParserManager;
+  private baselineChecker!: BaselineChecker;
+  private fileProcessor!: FileProcessor;
+  private directoryFilter!: DirectoryFilter;
+  private cacheManager!: CacheManager;
   private categoryLogger: ReturnType<typeof logger.createCategoryLogger>;
   private initialized = false;
 
@@ -28,8 +28,10 @@ export class BaseGuard {
     this.config = config;
     this.categoryLogger = logger.createCategoryLogger('baseguard');
     
-    // Initialize with error handling
-    this.initializeComponents();
+    // Initialize with error handling (async initialization)
+    this.initializeComponents().catch(error => {
+      this.categoryLogger.error('Failed to initialize BaseGuard', { error });
+    });
   }
 
   /**
@@ -43,9 +45,9 @@ export class BaseGuard {
       await GracefulDegradationManager.initialize();
       
       // Initialize components with error handling
-      await SystemErrorHandler.handleGracefully(
+      this.cacheManager = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.cacheManager = new CacheManager({
+          return new CacheManager({
             maxCacheSize: parseInt(process.env.BASEGUARD_CACHE_SIZE || '2000'),
             cacheValidityMs: 10 * 60 * 1000 // 10 minutes
           });
@@ -54,17 +56,17 @@ export class BaseGuard {
         { operation: 'cache_manager_init' }
       );
 
-      await SystemErrorHandler.handleGracefully(
+      this.parserManager = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.parserManager = new ParserManager();
+          return new ParserManager();
         },
         new ParserManager(),
         { operation: 'parser_manager_init' }
       );
 
-      await SystemErrorHandler.handleGracefully(
+      this.baselineChecker = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.baselineChecker = new BaselineChecker();
+          return new BaselineChecker();
         },
         new BaselineChecker(),
         { operation: 'baseline_checker_init' }
@@ -73,9 +75,9 @@ export class BaseGuard {
       const maxWorkers = parseInt(process.env.BASEGUARD_MAX_WORKERS || '8');
       const maxFiles = parseInt(process.env.BASEGUARD_MAX_FILES || '5000');
 
-      await SystemErrorHandler.handleGracefully(
+      this.fileProcessor = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.fileProcessor = new FileProcessor({
+          return new FileProcessor({
             maxWorkers,
             cacheManager: this.cacheManager
           });
@@ -84,9 +86,9 @@ export class BaseGuard {
         { operation: 'file_processor_init' }
       );
 
-      await SystemErrorHandler.handleGracefully(
+      this.directoryFilter = await SystemErrorHandler.handleGracefully(
         async () => {
-          this.directoryFilter = new DirectoryFilter({
+          return new DirectoryFilter({
             maxDepth: 8,
             maxFiles
           });
@@ -167,7 +169,7 @@ export class BaseGuard {
         try {
           const compatibilityResult = await SystemErrorHandler.handleGracefully(
             () => this.baselineChecker.checkCompatibility(feature, this.config.targets),
-            { violations: [] }, // fallback result
+            { violations: [], featureData: null }, // fallback result
             { 
               operation: 'check_compatibility', 
               file: feature.file,
@@ -340,7 +342,10 @@ export class BaseGuard {
     try {
       // Cleanup file processor
       await SystemErrorHandler.handleGracefully(
-        () => this.fileProcessor.cleanup(),
+        async () => {
+          await this.fileProcessor.cleanup();
+          return undefined;
+        },
         undefined,
         { operation: 'file_processor_cleanup' },
         { logError: false, showWarning: false }
@@ -348,7 +353,10 @@ export class BaseGuard {
       
       // Clear caches
       await SystemErrorHandler.handleGracefully(
-        () => this.cacheManager.clearAll(),
+        async () => {
+          this.cacheManager.clearAll();
+          return undefined;
+        },
         undefined,
         { operation: 'cache_cleanup' },
         { logError: false, showWarning: false }
@@ -356,7 +364,10 @@ export class BaseGuard {
       
       // Cleanup graceful degradation manager
       await SystemErrorHandler.handleGracefully(
-        () => GracefulDegradationManager.cleanupCache(),
+        async () => {
+          await GracefulDegradationManager.cleanupCache();
+          return undefined;
+        },
         undefined,
         { operation: 'degradation_cleanup' },
         { logError: false, showWarning: false }
@@ -364,7 +375,10 @@ export class BaseGuard {
       
       // Cleanup old logs
       await SystemErrorHandler.handleGracefully(
-        () => logger.cleanupOldLogs(),
+        async () => {
+          await logger.cleanupOldLogs();
+          return undefined;
+        },
         undefined,
         { operation: 'log_cleanup' },
         { logError: false, showWarning: false }

package/src/core/cache-manager.ts

@@ -28,8 +28,10 @@ export class LRUCache<K, V> {
       this.cache.delete(key);
     } else if (this.cache.size >= this.maxSize) {
       // Remove least recently used (first item)
-      const firstKey = this.cache.keys().next().value;
-      this.cache.delete(firstKey);
+      const firstKey = this.cache.keys().next().value as K;
+      if (firstKey !== undefined) {
+        this.cache.delete(firstKey);
+      }
     }
     this.cache.set(key, value);
   }

package/src/core/configuration-recovery.ts

@@ -131,9 +131,8 @@ export class ConfigurationRecovery {
       // Step 6: Final validation and save
       if (currentConfig) {
         try {
-          const finalConfig = ConfigurationManager.validateAndMigrate ? 
-            ConfigurationManager.validateAndMigrate(currentConfig) : 
-            currentConfig as Configuration;
+          // Use the public migrateConfiguration method instead
+          const finalConfig = ConfigurationManager.migrateConfiguration(currentConfig);
           
           await ConfigurationManager.save(finalConfig);
           result.config = finalConfig;
@@ -454,9 +453,7 @@ export class ConfigurationRecovery {
     }
 
     // Perform migration
-    const migratedConfig = ConfigurationManager.migrateConfiguration ? 
-      ConfigurationManager.migrateConfiguration(config) : 
-      config;
+    const migratedConfig = ConfigurationManager.migrateConfiguration(config);
 
     return {
       migrated: true,

package/src/core/configuration.ts

@@ -77,6 +77,10 @@ export class ConfigurationManager {
         jules: null,
         gemini: null
       },
+      codingAgent: {
+        primary: 'gemini', // 'jules' or 'gemini'
+        fallback: 'gemini' // fallback when primary fails
+      },
       automation: {
         enabled: false,
         trigger: 'pre-commit',
@@ -119,6 +123,10 @@ export class ConfigurationManager {
         jules: config.apiKeys?.jules || null,
         gemini: config.apiKeys?.gemini || null
       },
+      codingAgent: {
+        primary: this.validateCodingAgent(config.codingAgent?.primary) || defaultConfig.codingAgent.primary,
+        fallback: this.validateCodingAgent(config.codingAgent?.fallback) || defaultConfig.codingAgent.fallback
+      },
       automation: {
         enabled: config.automation?.enabled ?? defaultConfig.automation.enabled,
         trigger: this.validateTrigger(config.automation?.trigger) || defaultConfig.automation.trigger,
@@ -194,6 +202,16 @@ export class ConfigurationManager {
     return null;
   }
 
+  /**
+   * Validate coding agent selection
+   */
+  private static validateCodingAgent(agent: any): 'jules' | 'gemini' | null {
+    if (agent === 'jules' || agent === 'gemini') {
+      return agent;
+    }
+    return null;
+  }
+
   /**
    * Parse browser target string (e.g., "chrome 100", "safari baseline")
    */
@@ -437,6 +455,18 @@ export class ConfigurationManager {
       }
     }
 
+    // Validate coding agent
+    if (!config.codingAgent || typeof config.codingAgent !== 'object') {
+      errors.push('Coding agent configuration must be an object');
+    } else {
+      if (config.codingAgent.primary !== 'jules' && config.codingAgent.primary !== 'gemini') {
+        errors.push('Primary coding agent must be "jules" or "gemini"');
+      }
+      if (config.codingAgent.fallback !== 'jules' && config.codingAgent.fallback !== 'gemini') {
+        errors.push('Fallback coding agent must be "jules" or "gemini"');
+      }
+    }
+
     // Validate automation
     if (!config.automation || typeof config.automation !== 'object') {
       errors.push('Automation configuration must be an object');
@@ -481,6 +511,13 @@ export class ConfigurationManager {
         migratedConfig.apiKeys.gemini = config.apiKeys.gemini || null;
       }
       
+      if (config.codingAgent) {
+        migratedConfig.codingAgent = {
+          primary: this.validateCodingAgent(config.codingAgent.primary) || 'gemini',
+          fallback: this.validateCodingAgent(config.codingAgent.fallback) || 'gemini'
+        };
+      }
+      
       if (config.automation) {
         migratedConfig.automation = {
           ...migratedConfig.automation,

package/src/core/debug-logger.ts

@@ -130,8 +130,8 @@ export class DebugLogger {
     }
 
     this.currentSession.endTime = new Date();
-    this.currentSession.summary.totalDuration = 
-      this.currentSession.endTime.getTime() - this.currentSession.startTime.getTime();
+    const duration = this.currentSession.endTime.getTime() - this.currentSession.startTime.getTime();
+    this.currentSession.summary.performance.totalDuration = duration;
 
     this.info('session', `Debug session ended: ${this.currentSession.id}`);
     

package/src/core/file-processor.ts

@@ -103,12 +103,15 @@ export class FileProcessor {
       );
 
       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(batch[index].filePath, result.value);
+          this.cacheManager.setCachedParseResult(task.filePath, result.value);
         } else {
-          console.warn(`Failed to process ${batch[index].filePath}: ${result.reason}`);
+          console.warn(`Failed to process ${task.filePath}: ${result.reason}`);
         }
       });
 
@@ -222,7 +225,11 @@ export class FileProcessor {
   /**
    * Assign task to worker
    */
-  private async assignTaskToWorker(worker: Worker, task: WorkerTask): Promise<void> {
+  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`);

package/src/core/index.ts

@@ -10,4 +10,8 @@ export { FileProcessor } from './file-processor.js';
 export { DirectoryFilter } from './directory-filter.js';
 export { LazyLoader } from './lazy-loader.js';
 export { MemoryManager } from './memory-manager.js';
-export { StartupOptimizer } from './startup-optimizer.js';
+export { StartupOptimizer } from './startup-optimizer.js';
+export { SystemErrorHandler } from './system-error-handler.js';
+export { GracefulDegradationManager } from './graceful-degradation-manager.js';
+export { ConfigurationRecovery } from './configuration-recovery.js';
+export { logger, DebugLogger } from './debug-logger.js';

package/src/core/memory-manager.ts

@@ -1,9 +1,9 @@
 import { createReadStream } from 'fs';
 import { createInterface } from 'readline';
 
-// Add global type declaration for gc
+// Use Node.js built-in gc type
 declare global {
-  var gc: (() => void) | undefined;
+  var gc: NodeJS.GCFunction | undefined;
 }
 
 /**
@@ -291,4 +291,5 @@ class ViolationTracker {
     this.violations.clear();
     this.fileIndex.clear();
     this.nextFileId = 0;
-  }
+  }
+}

package/src/core/startup-optimizer.ts

@@ -170,4 +170,74 @@ export class StartupOptimizer {
       recommendations
     };
   }
+
+  /**
+   * Optimize memory usage by reducing object overhead
+   */
+  static optimizeMemoryUsage(): void {
+    // Enable V8 memory optimizations if available
+    if (process.env.NODE_ENV !== 'development') {
+      // Set V8 flags for better memory management
+      process.env.NODE_OPTIONS = (process.env.NODE_OPTIONS || '') + ' --max-old-space-size=512 --optimize-for-size';
+    }
+
+    // Setup memory monitoring
+    if (global.gc) {
+      setInterval(() => {
+        const usage = process.memoryUsage();
+        const heapUsedMB = usage.heapUsed / 1024 / 1024;
+        
+        // Force GC if memory usage is high
+        if (heapUsedMB > 100 && global.gc) {
+          global.gc();
+        }
+      }, 30000);
+    }
+  }
+
+  /**
+   * Reduce startup time by deferring non-critical operations
+   */
+  static async deferNonCriticalOperations(): Promise<void> {
+    // Defer heavy operations until after startup
+    setTimeout(async () => {
+      try {
+        // Preload remaining dependencies
+        const { LazyLoader } = await import('./lazy-loader.js');
+        LazyLoader.preloadCommon();
+        
+        // Initialize caches
+        const { CacheManager } = await import('./cache-manager.js');
+        // Cache initialization would happen here
+        
+        // Cleanup old logs
+        const { logger } = await import('./debug-logger.js');
+        logger.cleanupOldLogs().catch(() => {});
+      } catch (error) {
+        // Ignore errors in deferred operations
+      }
+    }, 100); // Defer by 100ms
+  }
+
+  /**
+   * Optimize startup by preloading critical dependencies
+   */
+  static async optimizeStartup(): Promise<void> {
+    // Start loading critical dependencies in background
+    const { LazyLoader } = await import('./lazy-loader.js');
+    
+    const criticalLoads = [
+      LazyLoader.getWebFeatures().catch(() => {}),
+      LazyLoader.getBabelParser().catch(() => {})
+    ];
+
+    // Don't wait for all to complete, just start the process
+    Promise.all(criticalLoads);
+    
+    // Setup memory optimizations
+    this.optimizeMemoryUsage();
+    
+    // Defer non-critical operations
+    this.deferNonCriticalOperations();
+  }
 }

package/src/core/system-error-handler.ts

@@ -30,8 +30,12 @@ export class SystemError extends Error {
     super(message);
     this.name = 'SystemError';
     this.context = {
-      ...context,
-      timestamp: new Date()
+      operation: context?.operation || 'unknown',
+      file: context?.file,
+      line: context?.line,
+      details: context?.details,
+      timestamp: new Date(),
+      userId: context?.userId
     };
   }
 }
@@ -110,7 +114,7 @@ export class SystemErrorHandler {
       }
 
       if (showWarning) {
-        console.warn(chalk.yellow(`⚠️ ${context.operation} failed: ${error.message}`));
+        console.warn(chalk.yellow(`⚠️ ${context.operation} failed: ${error instanceof Error ? error.message : 'Unknown error'}`));
       }
 
       // Attempt recovery if enabled
@@ -254,7 +258,7 @@ export class SystemErrorHandler {
           return true;
         }
       } catch (recoveryError) {
-        console.log(chalk.dim(`   Recovery failed: ${recoveryError.message}`));
+        console.log(chalk.dim(`   Recovery failed: ${recoveryError instanceof Error ? recoveryError.message : 'Unknown error'}`));
       }
     }
 
@@ -414,7 +418,7 @@ export class SystemErrorHandler {
       await fs.writeFile(logPath, JSON.stringify(logData, null, 2));
       console.log(chalk.dim(`Error log saved to: ${logPath}`));
     } catch (writeError) {
-      console.warn(chalk.yellow(`Failed to save error log: ${writeError.message}`));
+      console.warn(chalk.yellow(`Failed to save error log: ${writeError instanceof Error ? writeError.message : 'Unknown error'}`));
     }
   }
 

package/src/git/github-manager.ts

@@ -2,44 +2,21 @@ import { execSync } from 'child_process';
 import { existsSync } from 'fs';
 import { join } from 'path';
 import chalk from 'chalk';
-import open from 'open';
+
 
 /**
  * GitHub repository manager for Jules integration
+ * Note: GitHub app installation should be done on the Jules dashboard, not here
  */
 export class GitHubManager {
   private repoOwner: string | null = null;
   private repoName: string | null = null;
   private sourceIdentifier: string | null = null;
 
-  /**
-   * Guide user through Jules GitHub app installation
-   */
-  async setupJulesGitHubIntegration(): Promise<string> {
-    console.log(chalk.cyan('\n🔗 Setting up Jules GitHub Integration\n'));
-    
-    // Step 1: Check if we're in a git repository
-    if (!this.isGitRepository()) {
-      throw new Error('Not in a git repository. Please run this command from within a git repository.');
-    }
-
-    // Step 2: Get repository information
-    await this.detectRepositoryInfo();
-    
-    // Step 3: Guide user through GitHub app installation
-    await this.guideGitHubAppInstallation();
-    
-    // Step 4: Verify connection and get source identifier
-    const sourceId = await this.getSourceIdentifier();
-    
-    console.log(chalk.green('✅ Jules GitHub integration setup complete!'));
-    return sourceId;
-  }
-
   /**
    * Check if current directory is a git repository
    */
-  private isGitRepository(): boolean {
+  isGitRepository(): boolean {
     try {
       execSync('git rev-parse --git-dir', { stdio: 'ignore' });
       return true;
@@ -51,7 +28,7 @@ export class GitHubManager {
   /**
    * Detect repository owner and name from git remote
    */
-  private async detectRepositoryInfo(): Promise<void> {
+  async detectRepositoryInfo(): Promise<void> {
     try {
       const remoteUrl = execSync('git config --get remote.origin.url', { encoding: 'utf8' }).trim();
       
@@ -71,59 +48,16 @@ export class GitHubManager {
     }
   }
 
-  /**
-   * Guide user through GitHub app installation process
-   */
-  private async guideGitHubAppInstallation(): Promise<void> {
-    console.log(chalk.yellow('\n📋 Jules GitHub App Installation Steps:\n'));
-    
-    console.log('1. Opening Jules GitHub app installation page...');
-    
-    // Open Jules GitHub app installation URL
-    const installUrl = 'https://github.com/apps/jules-ai';
-    await open(installUrl);
-    
-    console.log(chalk.dim(`   ${installUrl}`));
-    
-    console.log('\n2. Follow these steps in your browser:');
-    console.log('   • Click "Install" on the Jules app page');
-    console.log('   • Select your repository or organization');
-    console.log(`   • Grant access to ${this.repoOwner}/${this.repoName}`);
-    console.log('   • Complete the installation process');
-    
-    console.log('\n3. After installation:');
-    console.log('   • Return to this terminal');
-    console.log('   • The setup will continue automatically');
-    
-    // Wait for user confirmation
-    await this.waitForUserConfirmation();
-  }
 
-  /**
-   * Wait for user to confirm GitHub app installation
-   */
-  private async waitForUserConfirmation(): Promise<void> {
-    const { default: inquirer } = await import('inquirer');
-    
-    const { confirmed } = await inquirer.prompt([
-      {
-        type: 'confirm',
-        name: 'confirmed',
-        message: 'Have you completed the Jules GitHub app installation?',
-        default: false
-      }
-    ]);
-    
-    if (!confirmed) {
-      console.log(chalk.yellow('\nPlease complete the GitHub app installation and run this command again.'));
-      process.exit(0);
-    }
-  }
 
   /**
    * Get source identifier for Jules API
    */
-  private async getSourceIdentifier(): Promise<string> {
+  async getSourceIdentifier(): Promise<string> {
+    if (!this.repoOwner || !this.repoName) {
+      await this.detectRepositoryInfo();
+    }
+    
     if (!this.repoOwner || !this.repoName) {
       throw new Error('Repository information not available');
     }
@@ -131,8 +65,6 @@ export class GitHubManager {
     // Generate source identifier in the format expected by Jules
     this.sourceIdentifier = `sources/github/${this.repoOwner}/${this.repoName}`;
     
-    console.log(chalk.blue(`🔗 Source identifier: ${this.sourceIdentifier}`));
-    
     return this.sourceIdentifier;
   }
 
@@ -174,7 +106,7 @@ export class GitHubManager {
   }
 
   /**
-   * Check if Jules GitHub integration is set up
+   * Check if we can detect repository information (GitHub integration is handled on Jules dashboard)
    */
   async isJulesIntegrationSetup(): Promise<boolean> {
     try {
@@ -183,7 +115,7 @@ export class GitHubManager {
       }
       
       await this.detectRepositoryInfo();
-      return await this.verifyGitHubConnection();
+      return this.repoOwner !== null && this.repoName !== null;
     } catch {
       return false;
     }

package/src/parsers/react-parser.ts

@@ -278,7 +278,7 @@ export class ReactParser extends Parser {
     const features: DetectedFeature[] = [];
     
     // Check if this is likely a style object (has CSS-like properties)
-    const hasStyleProps = node.properties.some(prop => {
+    const hasStyleProps = node.properties.some((prop: any) => {
       if (t.isObjectProperty(prop) && (t.isIdentifier(prop.key) || t.isStringLiteral(prop.key))) {
         const key = t.isIdentifier(prop.key) ? prop.key.name : prop.key.value;
         return this.CSS_PROPERTIES.has(key) || key.includes('-') || key.startsWith('--');
@@ -290,7 +290,7 @@ export class ReactParser extends Parser {
       return features;
     }
 
-    node.properties.forEach(prop => {
+    node.properties.forEach((prop: any) => {
       if (t.isObjectProperty(prop)) {
         let key = '';
         if (t.isIdentifier(prop.key)) {