@iservu-inc/adf-cli 0.3.0 → 0.3.6

package/lib/ai/ai-config.js

@@ -0,0 +1,398 @@
+const inquirer = require('inquirer');
+const autocomplete = require('inquirer-autocomplete-prompt');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const os = require('os');
+
+// Register autocomplete prompt
+inquirer.registerPrompt('autocomplete', autocomplete);
+
+/**
+ * AI Provider Configuration
+ * Handles setup and validation of AI providers for the interview system
+ * - Saves API keys to .env file for persistence
+ * - Fetches available models dynamically from providers
+ * - Autocomplete model selection with filtering
+ */
+
+const AI_PROVIDERS = {
+  ANTHROPIC: {
+    id: 'anthropic',
+    name: 'Anthropic Claude',
+    envVar: 'ANTHROPIC_API_KEY',
+    requiredFormat: 'sk-ant-',
+    website: 'https://console.anthropic.com/',
+    setup: 'Get your API key from https://console.anthropic.com/',
+    defaultModels: ['claude-sonnet-4-5-20250929', 'claude-3-5-sonnet-20241022', 'claude-3-opus-20240229']
+  },
+  OPENAI: {
+    id: 'openai',
+    name: 'OpenAI GPT',
+    envVar: 'OPENAI_API_KEY',
+    requiredFormat: 'sk-',
+    website: 'https://platform.openai.com/',
+    setup: 'Get your API key from https://platform.openai.com/api-keys',
+    defaultModels: ['gpt-4-turbo', 'gpt-4o', 'gpt-4', 'gpt-3.5-turbo']
+  },
+  GOOGLE: {
+    id: 'google',
+    name: 'Google Gemini',
+    envVar: 'GOOGLE_API_KEY',
+    requiredFormat: '',  // Google keys don't have consistent prefix
+    website: 'https://ai.google.dev/',
+    setup: 'Get your API key from https://aistudio.google.com/app/apikey',
+    defaultModels: ['gemini-2.0-flash-exp', 'gemini-1.5-pro', 'gemini-1.5-flash']
+  },
+  OPENROUTER: {
+    id: 'openrouter',
+    name: 'OpenRouter (Multi-Model)',
+    envVar: 'OPENROUTER_API_KEY',
+    requiredFormat: 'sk-or-',
+    website: 'https://openrouter.ai/',
+    setup: 'Get your API key from https://openrouter.ai/keys',
+    defaultModels: [
+      'anthropic/claude-sonnet-4-5',
+      'openai/gpt-4-turbo',
+      'google/gemini-pro-1.5',
+      'meta-llama/llama-3.1-70b-instruct'
+    ]
+  }
+};
+
+/**
+ * Get or create .env file path
+ */
+function getEnvFilePath(projectPath) {
+  const adfDir = path.join(projectPath, '.adf');
+  return path.join(adfDir, '.env');
+}
+
+/**
+ * Load existing .env file
+ */
+async function loadEnvFile(envPath) {
+  if (await fs.pathExists(envPath)) {
+    const content = await fs.readFile(envPath, 'utf-8');
+    const env = {};
+    content.split('\n').forEach(line => {
+      const trimmed = line.trim();
+      if (trimmed && !trimmed.startsWith('#')) {
+        const [key, ...valueParts] = trimmed.split('=');
+        if (key && valueParts.length > 0) {
+          env[key.trim()] = valueParts.join('=').trim().replace(/^["']|["']$/g, '');
+        }
+      }
+    });
+    return env;
+  }
+  return {};
+}
+
+/**
+ * Save API key to .env file
+ */
+async function saveToEnvFile(envPath, key, value) {
+  const env = await loadEnvFile(envPath);
+  env[key] = value;
+
+  const lines = [
+    '# AI Provider API Keys for adf-cli',
+    '# DO NOT commit this file to version control',
+    ''
+  ];
+
+  for (const [k, v] of Object.entries(env)) {
+    lines.push(`${k}="${v}"`);
+  }
+
+  await fs.ensureDir(path.dirname(envPath));
+  await fs.writeFile(envPath, lines.join('\n'), 'utf-8');
+}
+
+/**
+ * Load .env file into process.env
+ */
+function loadEnvIntoProcess(envPath) {
+  require('dotenv').config({ path: envPath });
+}
+
+/**
+ * Fetch available models from provider API
+ */
+async function fetchAvailableModels(provider, apiKey) {
+  const ora = require('ora');
+  const spinner = ora('Fetching available models...').start();
+
+  try {
+    switch (provider.id) {
+      case 'anthropic':
+        // Anthropic doesn't have a models list API, use defaults
+        spinner.succeed('Using known Anthropic models');
+        return provider.defaultModels;
+
+      case 'openai':
+        const OpenAI = require('openai');
+        const openai = new OpenAI({ apiKey });
+        const response = await openai.models.list();
+        const gptModels = response.data
+          .filter(m => m.id.startsWith('gpt-'))
+          .map(m => m.id)
+          .sort();
+        spinner.succeed(`Found ${gptModels.length} OpenAI models`);
+        return gptModels.length > 0 ? gptModels : provider.defaultModels;
+
+      case 'google':
+        // Google doesn't have a public models list API, use defaults
+        spinner.succeed('Using known Google Gemini models');
+        return provider.defaultModels;
+
+      case 'openrouter':
+        const fetch = require('node-fetch');
+        const orResponse = await fetch('https://openrouter.ai/api/v1/models', {
+          headers: {
+            'Authorization': `Bearer ${apiKey}`
+          }
+        });
+        const orData = await orResponse.json();
+        const orModels = orData.data.map(m => m.id).sort();
+        spinner.succeed(`Found ${orModels.length} OpenRouter models`);
+        return orModels.length > 0 ? orModels : provider.defaultModels;
+
+      default:
+        spinner.warn('Model fetching not supported, using defaults');
+        return provider.defaultModels;
+    }
+  } catch (error) {
+    spinner.fail(`Failed to fetch models: ${error.message}`);
+    console.log(chalk.yellow('  Using default model list\n'));
+    return provider.defaultModels;
+  }
+}
+
+/**
+ * Prompt user to select and configure AI provider
+ */
+async function configureAIProvider(projectPath = process.cwd()) {
+  console.log(chalk.cyan.bold('\n🤖 AI Provider Configuration\n'));
+  console.log(chalk.gray('This interview requires an AI assistant to analyze your answers and provide insights.\n'));
+
+  const envPath = getEnvFilePath(projectPath);
+
+  // Load existing .env file
+  const existingEnv = await loadEnvFile(envPath);
+
+  // Check for existing API keys (from process.env or .env file)
+  const availableProviders = [];
+  for (const [key, provider] of Object.entries(AI_PROVIDERS)) {
+    const apiKey = process.env[provider.envVar] || existingEnv[provider.envVar];
+    if (apiKey) {
+      availableProviders.push(provider);
+    }
+  }
+
+  if (availableProviders.length > 0) {
+    console.log(chalk.green('✓ Detected API keys for:'));
+    availableProviders.forEach(p => {
+      console.log(chalk.gray(`  • ${p.name} (${p.envVar})`));
+    });
+    console.log('');
+  }
+
+  // Provider selection
+  const providerChoices = [
+    {
+      name: `${AI_PROVIDERS.ANTHROPIC.name} ${availableProviders.find(p => p.id === 'anthropic') ? chalk.green('✓ Configured') : ''}`,
+      value: 'anthropic',
+      short: 'Anthropic'
+    },
+    {
+      name: `${AI_PROVIDERS.OPENAI.name} ${availableProviders.find(p => p.id === 'openai') ? chalk.green('✓ Configured') : ''}`,
+      value: 'openai',
+      short: 'OpenAI'
+    },
+    {
+      name: `${AI_PROVIDERS.GOOGLE.name} ${availableProviders.find(p => p.id === 'google') ? chalk.green('✓ Configured') : ''}`,
+      value: 'google',
+      short: 'Google'
+    },
+    {
+      name: `${AI_PROVIDERS.OPENROUTER.name} ${availableProviders.find(p => p.id === 'openrouter') ? chalk.green('✓ Configured') : ''}`,
+      value: 'openrouter',
+      short: 'OpenRouter'
+    }
+  ];
+
+  const { provider } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'provider',
+      message: 'Select AI provider:',
+      choices: providerChoices
+    }
+  ]);
+
+  const selectedProvider = AI_PROVIDERS[provider.toUpperCase()];
+
+  // Check if API key exists
+  let apiKey = process.env[selectedProvider.envVar] || existingEnv[selectedProvider.envVar];
+
+  if (!apiKey) {
+    console.log(chalk.yellow(`\n⚠️  ${selectedProvider.envVar} not found\n`));
+    console.log(chalk.gray(`Setup instructions:`));
+    console.log(chalk.gray(`  ${selectedProvider.setup}\n`));
+
+    const { manualKey } = await inquirer.prompt([
+      {
+        type: 'password',
+        name: 'manualKey',
+        message: `Enter your ${selectedProvider.name} API key:`,
+        mask: '*',
+        validate: (input) => {
+          if (!input || input.trim().length === 0) {
+            return 'API key cannot be empty';
+          }
+          if (selectedProvider.requiredFormat && !input.startsWith(selectedProvider.requiredFormat)) {
+            return `API key should start with "${selectedProvider.requiredFormat}"`;
+          }
+          return true;
+        }
+      }
+    ]);
+
+    apiKey = manualKey.trim();
+
+    // Save to .env file
+    await saveToEnvFile(envPath, selectedProvider.envVar, apiKey);
+
+    console.log(chalk.green(`\n✓ API key saved to: ${path.relative(projectPath, envPath)}`));
+    console.log(chalk.gray('  This file is gitignored and will persist across sessions.\n'));
+
+    // Load into current process
+    process.env[selectedProvider.envVar] = apiKey;
+  } else {
+    const keySource = existingEnv[selectedProvider.envVar] ? '.env file' : 'environment';
+    console.log(chalk.green(`\n✓ Using API key from ${keySource}`));
+  }
+
+  // Fetch available models
+  const availableModels = await fetchAvailableModels(selectedProvider, apiKey);
+
+  // Model selection with autocomplete
+  console.log('');
+  const { model } = await inquirer.prompt([
+    {
+      type: 'autocomplete',
+      name: 'model',
+      message: `Select ${selectedProvider.name} model (type to filter):`,
+      source: async (answersSoFar, input) => {
+        const filtered = input
+          ? availableModels.filter(m => m.toLowerCase().includes(input.toLowerCase()))
+          : availableModels;
+        return filtered;
+      },
+      pageSize: 10
+    }
+  ]);
+
+  const config = {
+    provider: selectedProvider.id,
+    providerName: selectedProvider.name,
+    model,
+    apiKey,
+    envVar: selectedProvider.envVar,
+    envPath
+  };
+
+  // Test connection (optional but recommended)
+  const { testConnection } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'testConnection',
+      message: 'Test AI connection before starting?',
+      default: true
+    }
+  ]);
+
+  if (testConnection) {
+    const ora = require('ora');
+    const spinner = ora('Testing AI connection...').start();
+
+    try {
+      const AIClient = require('./ai-client');
+      const client = new AIClient(config);
+      await client.test();
+      spinner.succeed(chalk.green('AI connection successful!'));
+    } catch (error) {
+      spinner.fail(chalk.red('AI connection failed'));
+      console.log(chalk.red(`\nError: ${error.message}\n`));
+
+      const { retry } = await inquirer.prompt([
+        {
+          type: 'confirm',
+          name: 'retry',
+          message: 'Try again with different configuration?',
+          default: true
+        }
+      ]);
+
+      if (retry) {
+        return configureAIProvider(projectPath); // Recursive retry
+      } else {
+        process.exit(1);
+      }
+    }
+  }
+
+  console.log(chalk.gray('\n' + '━'.repeat(60)) + '\n');
+
+  return config;
+}
+
+/**
+ * Detect which providers have API keys in environment or .env file
+ */
+async function detectAvailableProviders(projectPath = process.cwd()) {
+  const envPath = getEnvFilePath(projectPath);
+  const existingEnv = await loadEnvFile(envPath);
+
+  const available = [];
+
+  for (const [key, provider] of Object.entries(AI_PROVIDERS)) {
+    const apiKey = process.env[provider.envVar] || existingEnv[provider.envVar];
+    if (apiKey) {
+      available.push(provider);
+    }
+  }
+
+  return available;
+}
+
+/**
+ * Validate API key format
+ */
+function validateAPIKey(provider, apiKey) {
+  const config = AI_PROVIDERS[provider.toUpperCase()];
+
+  if (!apiKey || apiKey.trim().length === 0) {
+    return { valid: false, error: 'API key cannot be empty' };
+  }
+
+  if (config.requiredFormat && !apiKey.startsWith(config.requiredFormat)) {
+    return {
+      valid: false,
+      error: `API key should start with "${config.requiredFormat}"`
+    };
+  }
+
+  return { valid: true };
+}
+
+module.exports = {
+  configureAIProvider,
+  detectAvailableProviders,
+  validateAPIKey,
+  AI_PROVIDERS,
+  loadEnvIntoProcess,
+  getEnvFilePath
+};

package/lib/commands/config.js

@@ -0,0 +1,154 @@
+const inquirer = require('inquirer');
+const chalk = require('chalk');
+const fs = require('fs-extra');
+const path = require('path');
+const { configureAIProvider, getEnvFilePath, loadEnvFile } = require('../ai/ai-config');
+
+/**
+ * Configuration categories available in ADF CLI
+ */
+const CONFIG_CATEGORIES = {
+  AI_PROVIDER: {
+    name: 'AI Provider Setup',
+    description: 'Configure AI provider (Anthropic, OpenAI, Google Gemini, OpenRouter)',
+    value: 'ai-provider'
+  }
+  // Future config categories can be added here:
+  // PROJECT_SETTINGS: { name: 'Project Settings', description: '...', value: 'project' },
+  // DEPLOYMENT: { name: 'Deployment Preferences', description: '...', value: 'deployment' },
+};
+
+/**
+ * Check if AI provider is already configured
+ */
+async function isAIConfigured(projectPath = process.cwd()) {
+  const envPath = getEnvFilePath(projectPath);
+
+  if (!await fs.pathExists(envPath)) {
+    return { configured: false };
+  }
+
+  const envVars = await loadEnvFile(envPath);
+
+  // Check if any AI provider key exists
+  const aiKeys = [
+    'ANTHROPIC_API_KEY',
+    'OPENAI_API_KEY',
+    'GOOGLE_API_KEY',
+    'OPENROUTER_API_KEY'
+  ];
+
+  for (const key of aiKeys) {
+    if (envVars[key] && envVars[key].length > 0) {
+      return {
+        configured: true,
+        provider: key.replace('_API_KEY', '').toLowerCase()
+      };
+    }
+  }
+
+  return { configured: false };
+}
+
+/**
+ * Display configuration status for AI provider
+ */
+function displayAIStatus(status) {
+  if (status.configured) {
+    const providerName = status.provider.charAt(0).toUpperCase() + status.provider.slice(1);
+    return `${chalk.green('✓ Configured')} ${chalk.gray(`(${providerName})`)}`;
+  } else {
+    return chalk.yellow('○ Not configured');
+  }
+}
+
+/**
+ * Main config command
+ */
+async function config() {
+  console.log(chalk.cyan.bold('\n⚙️  ADF Configuration\n'));
+
+  const cwd = process.cwd();
+
+  // Check AI configuration status
+  const aiStatus = await isAIConfigured(cwd);
+
+  // Build choices with status indicators
+  const choices = [
+    {
+      name: `${CONFIG_CATEGORIES.AI_PROVIDER.name} - ${displayAIStatus(aiStatus)}`,
+      value: CONFIG_CATEGORIES.AI_PROVIDER.value,
+      short: CONFIG_CATEGORIES.AI_PROVIDER.name
+    },
+    new inquirer.Separator(),
+    {
+      name: chalk.gray('← Back'),
+      value: 'back'
+    }
+  ];
+
+  const { category } = await inquirer.prompt([
+    {
+      type: 'list',
+      name: 'category',
+      message: 'Select configuration category:',
+      choices: choices,
+      pageSize: 10
+    }
+  ]);
+
+  if (category === 'back') {
+    console.log(chalk.yellow('\n✋ Configuration cancelled.\n'));
+    return;
+  }
+
+  // Handle selected category
+  switch (category) {
+    case 'ai-provider':
+      await configureAIProviderCategory(cwd, aiStatus);
+      break;
+
+    // Future categories will be handled here
+    default:
+      console.log(chalk.red('\n❌ Configuration category not implemented yet.\n'));
+  }
+}
+
+/**
+ * Configure AI Provider category
+ */
+async function configureAIProviderCategory(cwd, aiStatus) {
+  console.log(chalk.gray('\n' + '─'.repeat(60) + '\n'));
+
+  if (aiStatus.configured) {
+    const providerName = aiStatus.provider.charAt(0).toUpperCase() + aiStatus.provider.slice(1);
+    console.log(chalk.green(`✓ AI Provider already configured: ${providerName}\n`));
+
+    const { reconfigure } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'reconfigure',
+        message: 'Do you want to reconfigure your AI provider?',
+        default: false
+      }
+    ]);
+
+    if (!reconfigure) {
+      console.log(chalk.yellow('\n✋ Configuration unchanged.\n'));
+      return;
+    }
+  }
+
+  // Run AI provider configuration
+  console.log('');
+  const aiConfig = await configureAIProvider(cwd);
+
+  if (aiConfig) {
+    console.log(chalk.green.bold('\n✅ AI Provider configured successfully!\n'));
+    console.log(chalk.gray(`  Provider: ${aiConfig.providerName}`));
+    console.log(chalk.gray(`  Model: ${aiConfig.model}`));
+    console.log(chalk.gray(`  Config saved to: ${getEnvFilePath(cwd)}\n`));
+  }
+}
+
+module.exports = config;

package/lib/commands/init.js

@@ -10,6 +10,7 @@ const {
 const Interviewer = require('../frameworks/interviewer');
 const SessionManager = require('../frameworks/session-manager');
 const { deployToTool } = require('./deploy');
+const { configureAIProvider, loadEnvIntoProcess, getEnvFilePath } = require('../ai/ai-config');
 
 async function init(options) {
   console.log(chalk.cyan.bold('\n🚀 AgentDevFramework - Software Development Requirements\n'));
@@ -17,13 +18,41 @@ async function init(options) {
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
 
+  // Load .env file if it exists (for API keys)
+  const envPath = getEnvFilePath(cwd);
+  if (await fs.pathExists(envPath)) {
+    loadEnvIntoProcess(envPath);
+  }
+
   // Check for resumable sessions FIRST (before asking to overwrite)
   const sessionManager = new SessionManager(cwd);
   const existingSession = await sessionManager.promptToResume();
 
   if (existingSession) {
     // Resume existing session
-    const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession);
+    // Check if session has AI config (from resumed session)
+    let aiConfig = existingSession.progress.aiConfig;
+
+    if (aiConfig) {
+      // We have AI config from session, but need to verify API key exists
+      const apiKey = process.env[aiConfig.envVar];
+      if (!apiKey) {
+        console.log(chalk.yellow(`\n⚠️  Previous session used ${aiConfig.providerName}`));
+        console.log(chalk.yellow(`Please configure API key to resume...\n`));
+        aiConfig = await configureAIProvider(cwd);
+      } else {
+        // Add API key to config (it's not stored in session for security)
+        aiConfig.apiKey = apiKey;
+        console.log(chalk.green(`\n✓ Resuming with ${aiConfig.providerName} (${aiConfig.model})\n`));
+      }
+    } else {
+      // Old session without AI config, configure now
+      console.log(chalk.yellow('\n⚠️  This session was created before AI provider integration.'));
+      console.log(chalk.yellow('Please configure AI provider to continue...\n'));
+      aiConfig = await configureAIProvider(cwd);
+    }
+
+    const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession, aiConfig);
     const sessionPath = await interviewer.start();
 
     console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
@@ -76,17 +105,34 @@ async function init(options) {
   // Create .adf directory
   await fs.ensureDir(adfDir);
 
-  // Start AI-guided interview
+  // Configure AI Provider (OPTIONAL - can be done later with 'adf config')
+  let aiConfig = null;
+
+  const { configureAI } = await inquirer.prompt([
+    {
+      type: 'confirm',
+      name: 'configureAI',
+      message: 'Configure AI provider now? (Enables intelligent follow-up questions)',
+      default: true
+    }
+  ]);
+
+  if (configureAI) {
+    aiConfig = await configureAIProvider(cwd);
+  } else {
+    console.log(chalk.yellow('\n💡 You can configure AI later by running: adf config\n'));
+  }
+
+  // Start interview (with or without AI)
   console.log(chalk.gray('\n' + '━'.repeat(60)) + '\n');
 
-  const interviewer = new Interviewer(workflow, cwd);
+  const interviewer = new Interviewer(workflow, cwd, null, aiConfig);
   const sessionPath = await interviewer.start();
 
-  // Show next steps
-  console.log(chalk.cyan('📋 Next Steps:\n'));
-  console.log(chalk.gray(`  1. Review your requirements: ${sessionPath}/outputs/`));
-  console.log(chalk.gray(`  2. Share the output files with your AI coding assistant`));
-  console.log(chalk.gray(`  3. Start building based on the detailed requirements\n`));
+  // Show completion message
+  console.log(chalk.cyan('📋 Requirements Complete!\n'));
+  console.log(chalk.gray(`  ✓ Files saved to: ${sessionPath}/outputs/`));
+  console.log(chalk.gray(`  ✓ You can review your requirements anytime\n`));
 
   // Optional: Deploy to tool
   if (options.tool) {
@@ -97,8 +143,8 @@ async function init(options) {
       {
         type: 'confirm',
         name: 'deployNow',
-        message: 'Deploy framework to a development tool?',
-        default: false
+        message: 'Automatically deploy to your IDE? (I\'ll configure everything for you)',
+        default: true
       }
     ]);