myaidev-method 0.2.12 → 0.2.16

package/src/lib/visual-config-utils.js

@@ -0,0 +1,424 @@
+/**
+ * Visual Configuration Utilities
+ *
+ * Manages configuration, validation, and environment setup for visual content generation.
+ *
+ * Platform support: Claude Code, Gemini CLI, Codex CLI
+ *
+ * @module visual-config-utils
+ */
+
+import fs from 'fs-extra';
+import path from 'path';
+import dotenv from 'dotenv';
+
+dotenv.config();
+
+/**
+ * Load visual generation configuration from environment
+ *
+ * @returns {Object} Configuration object
+ */
+export function loadVisualConfig() {
+  return {
+    googleApiKey: process.env.GOOGLE_API_KEY || null,
+    openaiApiKey: process.env.OPENAI_API_KEY || null,
+    defaultService: process.env.VISUAL_DEFAULT_SERVICE || 'gemini',
+    defaultQuality: process.env.VISUAL_DEFAULT_QUALITY || 'standard',
+    assetsPath: process.env.VISUAL_ASSETS_PATH || './content-assets',
+    dailyBudget: parseFloat(process.env.VISUAL_DAILY_BUDGET || 5.0),
+    monthlyBudget: parseFloat(process.env.VISUAL_MONTHLY_BUDGET || 50.0),
+    warnThreshold: parseFloat(process.env.VISUAL_WARN_THRESHOLD || 0.8)
+  };
+}
+
+/**
+ * Validate visual generation configuration
+ *
+ * @returns {Object} Validation results
+ */
+export function validateVisualConfig() {
+  const config = loadVisualConfig();
+
+  const validation = {
+    isValid: false,
+    hasGoogle: false,
+    hasOpenAI: false,
+    hasAnyAPIKeys: false,
+    availableServices: [],
+    errors: [],
+    warnings: []
+  };
+
+  // Validate API keys
+  if (config.googleApiKey && config.googleApiKey.length > 20) {
+    validation.hasGoogle = true;
+    validation.availableServices.push('gemini', 'imagen', 'veo');
+  } else if (config.googleApiKey) {
+    validation.errors.push('GOOGLE_API_KEY appears to be invalid (too short)');
+  }
+
+  if (config.openaiApiKey && config.openaiApiKey.length > 20) {
+    validation.hasOpenAI = true;
+    validation.availableServices.push('dalle');
+  } else if (config.openaiApiKey) {
+    validation.errors.push('OPENAI_API_KEY appears to be invalid (too short)');
+  }
+
+  validation.hasAnyAPIKeys = validation.hasGoogle || validation.hasOpenAI;
+
+  // Validate default service
+  if (config.defaultService && !validation.availableServices.includes(config.defaultService)) {
+    validation.warnings.push(`Default service '${config.defaultService}' is not available with current API keys`);
+  }
+
+  // Validate budget values
+  if (config.dailyBudget <= 0) {
+    validation.warnings.push('Daily budget should be greater than 0');
+  }
+
+  if (config.monthlyBudget <= 0) {
+    validation.warnings.push('Monthly budget should be greater than 0');
+  }
+
+  if (config.monthlyBudget < config.dailyBudget) {
+    validation.warnings.push('Monthly budget is less than daily budget');
+  }
+
+  // Configuration is valid if at least one API key is configured
+  validation.isValid = validation.hasAnyAPIKeys && validation.errors.length === 0;
+
+  return validation;
+}
+
+/**
+ * Check if any API keys are configured
+ *
+ * @returns {boolean} True if at least one API key is configured
+ */
+export function hasAnyAPIKeys() {
+  const validation = validateVisualConfig();
+  return validation.hasAnyAPIKeys;
+}
+
+/**
+ * Get available services based on configured API keys
+ *
+ * @returns {Array<string>} List of available service names
+ */
+export function getAvailableServices() {
+  const validation = validateVisualConfig();
+  return validation.availableServices;
+}
+
+/**
+ * Get service display name and information
+ *
+ * @param {string} service - Service identifier
+ * @returns {Object} Service information
+ */
+export function getServiceDisplayInfo(service) {
+  const services = {
+    gemini: {
+      id: 'gemini',
+      name: 'Gemini 2.5 Flash Image',
+      nickname: '"Nano Banana"',
+      provider: 'Google',
+      apiKey: 'GOOGLE_API_KEY',
+      speed: 'Fast ⚡⚡⚡',
+      cost: '$0.02/image',
+      quality: 'Good',
+      bestFor: 'Quick hero images, high volume'
+    },
+    imagen: {
+      id: 'imagen',
+      name: 'Imagen 3',
+      nickname: 'Premium Quality',
+      provider: 'Google',
+      apiKey: 'GOOGLE_API_KEY',
+      speed: 'Medium ⚡⚡',
+      cost: '$0.03/image',
+      quality: 'Excellent',
+      bestFor: 'Premium hero images, photorealistic content'
+    },
+    dalle: {
+      id: 'dalle',
+      name: 'DALL-E 3',
+      nickname: 'Creative AI',
+      provider: 'OpenAI',
+      apiKey: 'OPENAI_API_KEY',
+      speed: 'Medium ⚡⚡',
+      cost: '$0.04-0.12/image',
+      quality: 'Excellent',
+      bestFor: 'Creative illustrations, concept art'
+    },
+    veo: {
+      id: 'veo',
+      name: 'Veo 2',
+      nickname: 'Video Generation',
+      provider: 'Google',
+      apiKey: 'GOOGLE_API_KEY',
+      speed: 'Slow ⚡',
+      cost: '$0.10/video (est.)',
+      quality: 'Good',
+      bestFor: 'Product demos, animated diagrams'
+    }
+  };
+
+  return services[service] || null;
+}
+
+/**
+ * Get configuration status message
+ *
+ * @param {boolean} verbose - Include detailed information
+ * @returns {string} Status message
+ */
+export function getConfigStatusMessage(verbose = false) {
+  const validation = validateVisualConfig();
+  const config = loadVisualConfig();
+
+  if (!validation.hasAnyAPIKeys) {
+    return `⚠️ Visual content generation not configured
+
+No API keys found. To enable image/video generation:
+
+1. Run: /myai-configure visual
+   OR
+2. Add to your .env file:
+   GOOGLE_API_KEY=your_key_here  # For Gemini, Imagen, Veo
+   OPENAI_API_KEY=your_key_here  # For DALL-E
+
+Get API keys:
+• Google: https://ai.google.dev/
+• OpenAI: https://platform.openai.com/api-keys`;
+  }
+
+  let message = `✅ Visual content generation configured\n\n`;
+
+  // Show available services
+  message += `📋 Available Services:\n`;
+  for (const service of validation.availableServices) {
+    const info = getServiceDisplayInfo(service);
+    message += `   • ${info.name} - ${info.cost}\n`;
+  }
+
+  if (verbose) {
+    message += `\n⚙️ Settings:\n`;
+    message += `   Default Service: ${config.defaultService}\n`;
+    message += `   Default Quality: ${config.defaultQuality}\n`;
+    message += `   Assets Path: ${config.assetsPath}\n`;
+    message += `   Daily Budget: $${config.dailyBudget.toFixed(2)}\n`;
+    message += `   Monthly Budget: $${config.monthlyBudget.toFixed(2)}\n`;
+  }
+
+  // Show warnings
+  if (validation.warnings.length > 0) {
+    message += `\n⚠️ Warnings:\n`;
+    for (const warning of validation.warnings) {
+      message += `   • ${warning}\n`;
+    }
+  }
+
+  return message;
+}
+
+/**
+ * Update .env file with new configuration values
+ *
+ * @param {Object} updates - Key-value pairs to update
+ * @returns {Promise<void>}
+ */
+export async function updateEnvFile(updates) {
+  const envPath = path.join(process.cwd(), '.env');
+  let envContent = '';
+
+  // Read existing .env file
+  if (await fs.pathExists(envPath)) {
+    envContent = await fs.readFile(envPath, 'utf-8');
+  }
+
+  // Update or add each key
+  for (const [key, value] of Object.entries(updates)) {
+    const regex = new RegExp(`^${key}=.*$`, 'm');
+    const line = `${key}=${value}`;
+
+    if (regex.test(envContent)) {
+      // Update existing key
+      envContent = envContent.replace(regex, line);
+    } else {
+      // Add new key
+      envContent += `\n${line}`;
+    }
+  }
+
+  // Write back to file
+  await fs.writeFile(envPath, envContent.trim() + '\n');
+
+  // Reload environment variables
+  dotenv.config({ override: true });
+}
+
+/**
+ * Mask API key for display (show first 8 and last 4 characters)
+ *
+ * @param {string} apiKey - API key to mask
+ * @returns {string} Masked API key
+ */
+export function maskAPIKey(apiKey) {
+  if (!apiKey || apiKey.length < 16) {
+    return '****';
+  }
+
+  const start = apiKey.substring(0, 8);
+  const end = apiKey.substring(apiKey.length - 4);
+  const masked = `${start}${'*'.repeat(Math.max(4, apiKey.length - 12))}${end}`;
+
+  return masked;
+}
+
+/**
+ * Test API key validity by making a simple API call
+ *
+ * @param {string} service - Service to test (google, openai)
+ * @returns {Promise<Object>} Test result
+ */
+export async function testAPIKey(service) {
+  const config = loadVisualConfig();
+
+  try {
+    if (service === 'google') {
+      if (!config.googleApiKey) {
+        return { success: false, error: 'GOOGLE_API_KEY not configured' };
+      }
+
+      // Simple test: list models
+      const response = await fetch(
+        `https://generativelanguage.googleapis.com/v1beta/models?key=${config.googleApiKey}`,
+        { method: 'GET' }
+      );
+
+      if (response.ok) {
+        return { success: true, service: 'google' };
+      } else {
+        const error = await response.text();
+        return { success: false, error: `Google API test failed: ${error}` };
+      }
+    }
+
+    if (service === 'openai') {
+      if (!config.openaiApiKey) {
+        return { success: false, error: 'OPENAI_API_KEY not configured' };
+      }
+
+      // Simple test: list models
+      const response = await fetch(
+        'https://api.openai.com/v1/models',
+        {
+          method: 'GET',
+          headers: {
+            'Authorization': `Bearer ${config.openaiApiKey}`
+          }
+        }
+      );
+
+      if (response.ok) {
+        return { success: true, service: 'openai' };
+      } else {
+        const error = await response.text();
+        return { success: false, error: `OpenAI API test failed: ${error}` };
+      }
+    }
+
+    return { success: false, error: `Unknown service: ${service}` };
+
+  } catch (error) {
+    return { success: false, error: error.message };
+  }
+}
+
+/**
+ * Generate configuration summary for display
+ *
+ * @returns {Object} Configuration summary
+ */
+export function getConfigSummary() {
+  const validation = validateVisualConfig();
+  const config = loadVisualConfig();
+
+  return {
+    configured: validation.hasAnyAPIKeys,
+    services: {
+      google: {
+        configured: validation.hasGoogle,
+        available: ['gemini', 'imagen', 'veo'].filter(s =>
+          validation.availableServices.includes(s)
+        )
+      },
+      openai: {
+        configured: validation.hasOpenAI,
+        available: validation.availableServices.includes('dalle') ? ['dalle'] : []
+      }
+    },
+    settings: {
+      defaultService: config.defaultService,
+      defaultQuality: config.defaultQuality,
+      assetsPath: config.assetsPath,
+      budgets: {
+        daily: config.dailyBudget,
+        monthly: config.monthlyBudget,
+        warnThreshold: config.warnThreshold
+      }
+    },
+    validation: {
+      isValid: validation.isValid,
+      errors: validation.errors,
+      warnings: validation.warnings
+    }
+  };
+}
+
+/**
+ * Check if a specific service is available
+ *
+ * @param {string} service - Service name (gemini, imagen, dalle, veo)
+ * @returns {boolean} True if service is available
+ */
+export function isServiceAvailable(service) {
+  const available = getAvailableServices();
+  return available.includes(service);
+}
+
+/**
+ * Get recommended service based on image type
+ *
+ * @param {string} type - Image type (hero, illustration, diagram, screenshot)
+ * @returns {string} Recommended service name
+ */
+export function getRecommendedService(type) {
+  const available = getAvailableServices();
+  const config = loadVisualConfig();
+
+  // Recommendations by type
+  const recommendations = {
+    hero: ['imagen', 'dalle', 'gemini'],       // Premium quality for hero
+    illustration: ['dalle', 'imagen', 'gemini'], // Creative for illustrations
+    diagram: ['gemini', 'dalle', 'imagen'],    // Fast for diagrams
+    screenshot: ['gemini', 'imagen', 'dalle'], // Fast for screenshots
+    video: ['veo']                             // Only Veo for video
+  };
+
+  const preferred = recommendations[type] || recommendations.hero;
+
+  // Return first available from preferred list
+  for (const service of preferred) {
+    if (available.includes(service)) {
+      return service;
+    }
+  }
+
+  // Fallback to default or first available
+  return available.includes(config.defaultService)
+    ? config.defaultService
+    : available[0];
+}