baseguard 1.0.0

package/src/commands/init.ts

@@ -0,0 +1,142 @@
+import { UIComponents, Prompts } from '../ui/index.js';
+import { ConfigurationManager, BROWSER_TARGET_PRESETS, type PresetName } from '../core/index.js';
+import { ErrorHandler } from '../core/error-handler.js';
+
+/**
+ * Initialize BaseGuard in a project
+ */
+export async function init(options: {
+  preset?: string;
+  skipHooks?: boolean;
+  skipApiKeys?: boolean;
+}): Promise<void> {
+  try {
+    UIComponents.showHeader();
+    
+    // Check if already initialized
+    const configExists = await ConfigurationManager.exists();
+    if (configExists) {
+      const { default: inquirer } = await import('inquirer');
+      const { overwrite } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'overwrite',
+          message: 'BaseGuard is already initialized. Overwrite existing configuration?',
+          default: false
+        }
+      ]);
+      
+      if (!overwrite) {
+        UIComponents.showInfoBox('Initialization cancelled. Use "base config" to modify settings.');
+        return;
+      }
+    }
+    
+    const spinner = UIComponents.createSpinner('Setting up BaseGuard configuration...');
+    spinner.start();
+    
+    // Create configuration based on options or run setup wizard
+    let config;
+    
+    if (options.preset && options.preset !== 'custom') {
+      // Use preset configuration
+      const presetName = options.preset as PresetName;
+      if (BROWSER_TARGET_PRESETS[presetName]) {
+        config = ConfigurationManager.createWithPreset(presetName);
+        spinner.text = `Using ${presetName} preset...`;
+      } else {
+        spinner.fail(`Invalid preset: ${options.preset}`);
+        UIComponents.showErrorBox(`Available presets: ${Object.keys(BROWSER_TARGET_PRESETS).join(', ')}`);
+        return;
+      }
+    } else {
+      // Run interactive setup wizard
+      spinner.stop();
+      const setupResult = await Prompts.setupWizard();
+      spinner.start();
+      
+      config = ConfigurationManager.createWithCustomTargets(setupResult.targets);
+      
+      // Set up automation if requested and not skipped
+      if (setupResult.installHooks && !options.skipHooks) {
+        config.automation = {
+          enabled: true,
+          trigger: setupResult.hookTrigger,
+          autoAnalyze: true,
+          autoFix: false,
+          blockCommit: true
+        };
+      }
+    }
+    
+    // Set up API keys if not skipped
+    if (!options.skipApiKeys) {
+      spinner.stop();
+      const apiKeys = await Prompts.setupApiKeys();
+      spinner.start();
+      
+      if (apiKeys.julesApiKey) {
+        config.apiKeys.jules = apiKeys.julesApiKey;
+      }
+      if (apiKeys.geminiApiKey) {
+        config.apiKeys.gemini = apiKeys.geminiApiKey;
+      }
+    }
+    
+    await ConfigurationManager.save(config);
+    spinner.succeed('BaseGuard configuration created');
+    
+    UIComponents.showSuccessBox('BaseGuard has been successfully initialized!');
+    
+    // Show configuration summary
+    console.log('\n📋 Configuration Summary:');
+    UIComponents.showList([
+      `Browser targets: ${config.targets.map(t => `${t.browser} ${t.minVersion}`).join(', ')}`,
+      `API keys: ${config.apiKeys.jules ? '✅' : '❌'} Jules, ${config.apiKeys.gemini ? '✅' : '❌'} Gemini`,
+      `Automation: ${config.automation.enabled ? '✅ Enabled' : '❌ Disabled'}`
+    ]);
+    
+    console.log('\n🚀 Next steps:');
+    const nextSteps = ['Run `base check` to scan for compatibility issues'];
+    
+    if (config.apiKeys.jules && config.apiKeys.gemini) {
+      nextSteps.push('Run `base fix` to automatically fix issues with AI');
+    } else {
+      nextSteps.push('Run `base config set-keys` to configure AI services');
+    }
+    
+    if (!config.automation.enabled) {
+      nextSteps.push('Run `base automation enable` to set up git hooks');
+    }
+    
+    UIComponents.showList(nextSteps);
+    
+  } catch (error) {
+    const apiError = ErrorHandler.handleAPIError(error);
+    ErrorHandler.displayError(apiError);
+    
+    // Provide specific help for common init issues
+    console.log('\n💡 Common solutions:');
+    if (apiError.type === 'network') {
+      UIComponents.showList([
+        'Check your internet connection',
+        'Try running init again with --skip-api-keys to set up offline',
+        'Configure API keys later with "base config set-keys"'
+      ]);
+    } else if (apiError.type === 'configuration') {
+      UIComponents.showList([
+        'Delete .baseguardrc.json and try again',
+        'Check file permissions in the current directory',
+        'Run "base config validate" to check for issues'
+      ]);
+    } else {
+      UIComponents.showList([
+        'Try running "base init --skip-api-keys" for offline setup',
+        'Check the documentation at https://github.com/baseguard/baseguard#readme',
+        'Report this issue if it persists'
+      ]);
+    }
+    
+    process.exit(1);
+  }
+}

package/src/core/api-key-manager.ts

@@ -0,0 +1,298 @@
+import { ConfigurationManager } from './configuration.js';
+import { UIComponents } from '../ui/components.js';
+
+/**
+ * API key validation patterns and utilities
+ */
+export class ApiKeyManager {
+  /**
+   * Validate Jules API key format
+   */
+  static validateJulesApiKey(apiKey: string): { valid: boolean; error?: string } {
+    if (!apiKey || typeof apiKey !== 'string') {
+      return { valid: false, error: 'API key is required' };
+    }
+
+    const trimmed = apiKey.trim();
+    
+    if (trimmed.length < 10) {
+      return { valid: false, error: 'API key seems too short' };
+    }
+
+    if (trimmed.length > 200) {
+      return { valid: false, error: 'API key seems too long' };
+    }
+
+    // Basic format validation - Jules keys might have specific patterns
+    if (!/^[A-Za-z0-9_\-\.]+$/.test(trimmed)) {
+      return { valid: false, error: 'API key contains invalid characters' };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Validate Gemini API key format
+   */
+  static validateGeminiApiKey(apiKey: string): { valid: boolean; error?: string } {
+    if (!apiKey || typeof apiKey !== 'string') {
+      return { valid: false, error: 'API key is required' };
+    }
+
+    const trimmed = apiKey.trim();
+    
+    if (trimmed.length < 30) {
+      return { valid: false, error: 'Gemini API key seems too short' };
+    }
+
+    if (trimmed.length > 100) {
+      return { valid: false, error: 'Gemini API key seems too long' };
+    }
+
+    // Gemini API keys typically start with "AIza"
+    if (!trimmed.startsWith('AIza')) {
+      return { valid: false, error: 'Gemini API keys typically start with "AIza"' };
+    }
+
+    // Basic format validation
+    if (!/^[A-Za-z0-9_\-]+$/.test(trimmed)) {
+      return { valid: false, error: 'API key contains invalid characters' };
+    }
+
+    return { valid: true };
+  }
+
+  /**
+   * Test Jules API key connectivity
+   */
+  static async testJulesApiKey(apiKey: string): Promise<{ success: boolean; error?: string }> {
+    try {
+      // Validate format first
+      const validation = this.validateJulesApiKey(apiKey);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+
+      // Test connectivity with a simple API call
+      const response = await fetch('https://jules.googleapis.com/v1alpha/sessions', {
+        method: 'GET',
+        headers: {
+          'X-Goog-Api-Key': apiKey.trim(),
+          'Content-Type': 'application/json'
+        }
+      });
+
+      if (response.status === 401) {
+        return { success: false, error: 'Invalid API key or insufficient permissions' };
+      }
+
+      if (response.status === 403) {
+        return { success: false, error: 'API key does not have required permissions' };
+      }
+
+      if (response.status === 429) {
+        return { success: false, error: 'Rate limit exceeded. Please try again later' };
+      }
+
+      if (!response.ok && response.status !== 404) {
+        return { success: false, error: `API error: ${response.status} ${response.statusText}` };
+      }
+
+      // 404 is acceptable for a test call to sessions endpoint
+      return { success: true };
+
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes('fetch')) {
+          return { success: false, error: 'Network error. Please check your internet connection' };
+        }
+        return { success: false, error: error.message };
+      }
+      return { success: false, error: 'Unknown error occurred during API test' };
+    }
+  }
+
+  /**
+   * Test Gemini API key connectivity
+   */
+  static async testGeminiApiKey(apiKey: string): Promise<{ success: boolean; error?: string }> {
+    try {
+      // Validate format first
+      const validation = this.validateGeminiApiKey(apiKey);
+      if (!validation.valid) {
+        return { success: false, error: validation.error };
+      }
+
+      // Test connectivity with a simple API call
+      const response = await fetch('https://generativelanguage.googleapis.com/v1beta/models', {
+        method: 'GET',
+        headers: {
+          'x-goog-api-key': apiKey.trim()
+        }
+      });
+
+      if (response.status === 401) {
+        return { success: false, error: 'Invalid API key' };
+      }
+
+      if (response.status === 403) {
+        return { success: false, error: 'API key does not have required permissions' };
+      }
+
+      if (response.status === 429) {
+        return { success: false, error: 'Rate limit exceeded. Please try again later' };
+      }
+
+      if (!response.ok) {
+        return { success: false, error: `API error: ${response.status} ${response.statusText}` };
+      }
+
+      // Verify we can parse the response
+      const data = await response.json();
+      if (!data.models || !Array.isArray(data.models)) {
+        return { success: false, error: 'Unexpected API response format' };
+      }
+
+      return { success: true };
+
+    } catch (error) {
+      if (error instanceof Error) {
+        if (error.message.includes('fetch')) {
+          return { success: false, error: 'Network error. Please check your internet connection' };
+        }
+        return { success: false, error: error.message };
+      }
+      return { success: false, error: 'Unknown error occurred during API test' };
+    }
+  }
+
+  /**
+   * Store API keys securely in configuration
+   */
+  static async storeApiKeys(keys: { jules?: string; gemini?: string }): Promise<void> {
+    const config = await ConfigurationManager.load();
+    
+    if (keys.jules) {
+      config.apiKeys.jules = keys.jules.trim();
+    }
+    
+    if (keys.gemini) {
+      config.apiKeys.gemini = keys.gemini.trim();
+    }
+    
+    await ConfigurationManager.save(config);
+  }
+
+  /**
+   * Get stored API keys
+   */
+  static async getStoredApiKeys(): Promise<{ jules: string | null; gemini: string | null }> {
+    const config = await ConfigurationManager.load();
+    return {
+      jules: config.apiKeys.jules,
+      gemini: config.apiKeys.gemini
+    };
+  }
+
+  /**
+   * Check if API keys are configured
+   */
+  static async hasApiKeys(): Promise<{ jules: boolean; gemini: boolean }> {
+    const keys = await this.getStoredApiKeys();
+    return {
+      jules: !!keys.jules,
+      gemini: !!keys.gemini
+    };
+  }
+
+  /**
+   * Clear stored API keys
+   */
+  static async clearApiKeys(): Promise<void> {
+    const config = await ConfigurationManager.load();
+    config.apiKeys.jules = null;
+    config.apiKeys.gemini = null;
+    await ConfigurationManager.save(config);
+  }
+
+  /**
+   * Validate and test all stored API keys
+   */
+  static async validateStoredKeys(): Promise<{
+    jules: { valid: boolean; error?: string };
+    gemini: { valid: boolean; error?: string };
+  }> {
+    const keys = await this.getStoredApiKeys();
+    
+    const results = {
+      jules: { valid: false, error: 'No API key configured' },
+      gemini: { valid: false, error: 'No API key configured' }
+    };
+
+    if (keys.jules) {
+      const julesResult = await this.testJulesApiKey(keys.jules);
+      results.jules = { valid: julesResult.success, error: julesResult.error || '' };
+    }
+
+    if (keys.gemini) {
+      const geminiResult = await this.testGeminiApiKey(keys.gemini);
+      results.gemini = { valid: geminiResult.success, error: geminiResult.error || '' };
+    }
+
+    return results;
+  }
+
+  /**
+   * Get API key status for display
+   */
+  static async getApiKeyStatus(): Promise<{
+    jules: 'configured' | 'missing' | 'invalid';
+    gemini: 'configured' | 'missing' | 'invalid';
+  }> {
+    const keys = await this.getStoredApiKeys();
+    const status: {
+      jules: 'configured' | 'missing' | 'invalid';
+      gemini: 'configured' | 'missing' | 'invalid';
+    } = {
+      jules: 'missing',
+      gemini: 'missing'
+    };
+
+    if (keys.jules) {
+      const validation = this.validateJulesApiKey(keys.jules);
+      status.jules = validation.valid ? 'configured' : 'invalid';
+    }
+
+    if (keys.gemini) {
+      const validation = this.validateGeminiApiKey(keys.gemini);
+      status.gemini = validation.valid ? 'configured' : 'invalid';
+    }
+
+    return status;
+  }
+
+  /**
+   * Show helpful error messages for API failures
+   */
+  static showApiErrorHelp(service: 'jules' | 'gemini', error: string): void {
+    UIComponents.showErrorBox(`${service.toUpperCase()} API Error: ${error}`);
+    
+    console.log('\nTroubleshooting steps:');
+    
+    if (service === 'jules') {
+      UIComponents.showList([
+        'Verify your Jules API key at https://jules.google.com',
+        'Check that the Jules GitHub app is installed on your repository',
+        'Ensure your API key has the required permissions',
+        'Try regenerating your API key if the issue persists'
+      ]);
+    } else {
+      UIComponents.showList([
+        'Verify your Gemini API key at https://aistudio.google.com/app/apikey',
+        'Check that the Gemini API is enabled in your Google Cloud project',
+        'Ensure you have sufficient quota remaining',
+        'Try regenerating your API key if the issue persists'
+      ]);
+    }
+  }
+}