@iservu-inc/adf-cli 0.12.0 → 0.12.9

package/lib/ai/ai-config.js

@@ -43,19 +43,18 @@ const AI_PROVIDERS = {
     website: 'https://ai.google.dev/',
     setup: 'Get your API key from https://aistudio.google.com/app/apikey',
     defaultModels: [
-      // Gemini 2.5 Series (Latest - Stable)
-      'gemini-2.5-pro',              // Most advanced for complex reasoning
-      'gemini-2.5-flash',            // Best price-performance
-      'gemini-2.5-flash-lite',       // Fastest and most cost-efficient
-      'gemini-2.5-flash-image',      // Image generation
-      // Gemini 2.0 Series (Stable)
-      'gemini-2.0-flash',
-      'gemini-2.0-flash-lite',
-      // Gemini 1.5 Series (Legacy - still supported)
+      // Gemini 2.0 Series (Latest - Experimental)
+      'gemini-2.0-flash-exp',
+      'gemini-2.0-flash-thinking-exp',
+      // Gemini 1.5 Series (Stable - Recommended)
+      'gemini-1.5-pro',
       'gemini-1.5-pro-latest',
+      'gemini-1.5-flash',
       'gemini-1.5-flash-latest',
-      'gemini-1.5-pro',
-      'gemini-1.5-flash'
+      'gemini-1.5-flash-8b',
+      // Gemini 1.0 Series (Legacy)
+      'gemini-pro',
+      'gemini-pro-vision'
     ]
   },
   OPENROUTER: {
@@ -192,6 +191,67 @@ function loadEnvIntoProcess(envPath) {
   require('dotenv').config({ path: envPath });
 }
 
+/**
+ * Validate API key with provider by making a simple API call
+ */
+async function validateAPIKeyWithProvider(provider, apiKey) {
+  switch (provider.id) {
+    case 'anthropic':
+      const Anthropic = require('@anthropic-ai/sdk');
+      const anthropicClient = new Anthropic({ apiKey });
+      // Make a minimal request to validate the key
+      await anthropicClient.messages.create({
+        model: 'claude-3-haiku-20240307',
+        max_tokens: 10,
+        messages: [{ role: 'user', content: 'test' }]
+      });
+      break;
+
+    case 'openai':
+      const OpenAI = require('openai');
+      const openaiClient = new OpenAI({ apiKey });
+      // List models is a simple GET request that validates the key
+      await openaiClient.models.list();
+      break;
+
+    case 'google':
+      const fetchGoogle = require('node-fetch');
+      // Validate by fetching models list (validates key and shows available models)
+      const googleResponse = await fetchGoogle(
+        `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+      );
+
+      if (!googleResponse.ok) {
+        const errorText = await googleResponse.text();
+        throw new Error(`HTTP ${googleResponse.status}: ${errorText || googleResponse.statusText}`);
+      }
+
+      const googleData = await googleResponse.json();
+      if (!googleData.models || !Array.isArray(googleData.models) || googleData.models.length === 0) {
+        throw new Error('No models available for this API key');
+      }
+      break;
+
+    case 'openrouter':
+      const fetchOR = require('node-fetch');
+      const response = await fetchOR('https://openrouter.ai/api/v1/models', {
+        headers: {
+          'Authorization': `Bearer ${apiKey}`,
+          'Content-Type': 'application/json'
+        }
+      });
+
+      if (!response.ok) {
+        const errorText = await response.text();
+        throw new Error(`HTTP ${response.status}: ${errorText || response.statusText}`);
+      }
+      break;
+
+    default:
+      throw new Error(`Validation not implemented for provider: ${provider.id}`);
+  }
+}
+
 /**
  * Fetch available models from provider API
  */
@@ -202,9 +262,53 @@ async function fetchAvailableModels(provider, apiKey) {
   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;
+        try {
+          const Anthropic = require('@anthropic-ai/sdk');
+          const anthropic = new Anthropic({ apiKey });
+
+          // Try to fetch models from Anthropic API
+          // Note: As of SDK v0.65.0, models endpoint may not be available
+          // If it exists, it would be similar to OpenAI's API
+          try {
+            const response = await anthropic.models.list();
+            const models = response.data
+              .map(m => m.id)
+              .sort();
+
+            if (models.length > 0) {
+              spinner.succeed(`Found ${models.length} Anthropic models`);
+              return models;
+            }
+          } catch (listError) {
+            // Models endpoint not available, use comprehensive default list
+            spinner.warn('Model listing not available, using curated list');
+          }
+
+          // Comprehensive list of known Anthropic models
+          const knownModels = [
+            // Claude 4.5 (Latest)
+            'claude-sonnet-4-5-20250929',
+            'claude-opus-4-5-20251101',
+            // Claude 3.5
+            'claude-3-5-sonnet-20241022',
+            'claude-3-5-sonnet-20240620',
+            'claude-3-5-haiku-20241022',
+            // Claude 3
+            'claude-3-opus-20240229',
+            'claude-3-sonnet-20240229',
+            'claude-3-haiku-20240307',
+            // Claude 2 (Legacy)
+            'claude-2.1',
+            'claude-2.0',
+            'claude-instant-1.2'
+          ];
+
+          return knownModels;
+        } catch (error) {
+          spinner.fail(`Failed to load Anthropic models: ${error.message}`);
+          console.log(chalk.yellow('  Using default model list\n'));
+          return provider.defaultModels;
+        }
 
       case 'openai':
         const OpenAI = require('openai');
@@ -224,33 +328,81 @@ async function fetchAvailableModels(provider, apiKey) {
 
       case 'google':
         try {
-          const { GoogleGenerativeAI } = require('@google/generative-ai');
-          const genAI = new GoogleGenerativeAI(apiKey);
+          const fetch = require('node-fetch');
 
-          // List available models - note: this is currently experimental in SDK
-          // If it fails, we'll fall back to defaults
-          const models = [];
+          // Use Google's REST API to list available models
+          const response = await fetch(
+            `https://generativelanguage.googleapis.com/v1beta/models?key=${apiKey}`
+          );
+
+          if (!response.ok) {
+            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
+          }
 
-          // Try to list models - Google SDK doesn't have a stable listModels yet
-          // So we'll use a curated list based on known available models
-          spinner.succeed('Using known Google Gemini models');
+          const data = await response.json();
+
+          if (data.models && Array.isArray(data.models)) {
+            // Filter for models that support generateContent
+            const availableModels = data.models
+              .filter(m =>
+                m.supportedGenerationMethods &&
+                m.supportedGenerationMethods.includes('generateContent')
+              )
+              .map(m => m.name.replace('models/', ''))
+              .sort();
+
+            if (availableModels.length > 0) {
+              spinner.succeed(`Found ${availableModels.length} Google Gemini models`);
+              return availableModels;
+            }
+          }
+
+          // Fallback to default list
+          spinner.warn('No models found via API, using curated list');
           return provider.defaultModels;
         } catch (error) {
-          spinner.succeed('Using known Google Gemini models');
+          spinner.fail(`Failed to fetch Google models: ${error.message}`);
+          console.log(chalk.yellow('  Using default model list\n'));
           return provider.defaultModels;
         }
 
       case 'openrouter':
-        const fetch = require('node-fetch');
-        const orResponse = await fetch('https://openrouter.ai/api/v1/models', {
-          headers: {
-            'Authorization': `Bearer ${apiKey}`
+        try {
+          const fetch = require('node-fetch');
+          const orResponse = await fetch('https://openrouter.ai/api/v1/models', {
+            headers: {
+              'Authorization': `Bearer ${apiKey}`,
+              'Content-Type': 'application/json'
+            }
+          });
+
+          if (!orResponse.ok) {
+            throw new Error(`HTTP ${orResponse.status}: ${orResponse.statusText}`);
+          }
+
+          const orData = await orResponse.json();
+
+          if (!orData.data || !Array.isArray(orData.data)) {
+            throw new Error('Invalid response format from OpenRouter API');
+          }
+
+          const orModels = orData.data
+            .map(m => m.id)
+            .filter(id => id) // Remove any null/undefined IDs
+            .sort();
+
+          if (orModels.length > 0) {
+            spinner.succeed(`Found ${orModels.length} OpenRouter models`);
+            return orModels;
+          } else {
+            spinner.warn('No models found, using defaults');
+            return provider.defaultModels;
           }
-        });
-        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;
+        } catch (error) {
+          spinner.fail(`Failed to fetch OpenRouter models: ${error.message}`);
+          console.log(chalk.yellow('  Using default model list\n'));
+          return provider.defaultModels;
+        }
 
       default:
         spinner.warn('Model fetching not supported, using defaults');
@@ -416,7 +568,36 @@ async function configureAIProvider(projectPath = process.cwd()) {
     console.log(chalk.green(`\n✓ Using API key from ${keySource}`));
   }
 
-  // Fetch available models
+  // Validate API key by testing basic connectivity
+  const ora = require('ora');
+  const validationSpinner = ora('Validating API key...').start();
+
+  try {
+    await validateAPIKeyWithProvider(selectedProvider, apiKey);
+    validationSpinner.succeed(chalk.green('API key validated successfully'));
+  } catch (error) {
+    validationSpinner.fail(chalk.red('API key validation failed'));
+    console.log(chalk.red(`\nError: ${error.message}\n`));
+    console.log(chalk.yellow('The API key appears to be invalid or has connectivity issues.'));
+    console.log(chalk.gray('Please check your API key and try again.\n'));
+
+    const { retry } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'retry',
+        message: 'Try again with a different API key?',
+        default: true
+      }
+    ]);
+
+    if (retry) {
+      return configureAIProvider(projectPath);
+    } else {
+      process.exit(1);
+    }
+  }
+
+  // Fetch available models (only after successful validation)
   const availableModels = await fetchAvailableModels(selectedProvider, apiKey);
 
   // Show helpful tip about model selection
@@ -454,81 +635,44 @@ async function configureAIProvider(projectPath = process.cwd()) {
     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`));
-
-      // Provide specific guidance for common errors
-      const errorMsg = error.message.toLowerCase();
-
-      if (errorMsg.includes('data policy') || errorMsg.includes('privacy')) {
-        console.log(chalk.yellow('📋 Privacy/Data Policy Issue:\n'));
-        if (selectedProvider.id === 'openrouter') {
-          console.log(chalk.gray('   OpenRouter: Free models require specific privacy settings.'));
-          console.log(chalk.cyan('   Solutions:'));
-          console.log(chalk.gray('   1. Configure privacy: https://openrouter.ai/settings/privacy'));
-          console.log(chalk.gray('   2. Select a paid model instead (recommended)'));
-          console.log(chalk.gray('   3. Enable "Free model publication" in settings\n'));
-        } else {
-          console.log(chalk.gray('   The selected model may require specific account settings.'));
-          console.log(chalk.gray('   Try selecting a different model or check your provider settings.\n'));
-        }
-      } else if (errorMsg.includes('404') || errorMsg.includes('not found') || errorMsg.includes('no endpoints')) {
-        console.log(chalk.yellow('📋 Model Not Available:\n'));
-        console.log(chalk.gray('   The selected model may no longer be available or accessible.'));
-        console.log(chalk.cyan('   Solutions:'));
-        console.log(chalk.gray('   1. Select a different, more widely supported model'));
-        console.log(chalk.gray('   2. Check the provider\'s model availability'));
-        console.log(chalk.gray('   3. Some models require specific API endpoints or settings\n'));
-      } else if (errorMsg.includes('400') || errorMsg.includes('unsupported parameter')) {
-        console.log(chalk.yellow('📋 Model Parameter Incompatibility:\n'));
-        console.log(chalk.gray('   The selected model may use different API parameters.'));
-        console.log(chalk.cyan('   Solutions:'));
-        console.log(chalk.gray('   1. Try a more standard model (e.g., gpt-4-turbo, claude-3-5-sonnet)'));
-        console.log(chalk.gray('   2. Some newer/experimental models may not be fully supported yet\n'));
-      } else if (errorMsg.includes('401') || errorMsg.includes('invalid') || errorMsg.includes('unauthorized')) {
-        console.log(chalk.yellow('📋 Invalid API Key:\n'));
-        console.log(chalk.gray('   Please check that your API key is correct and active.\n'));
-      } else if (errorMsg.includes('429') || errorMsg.includes('rate limit')) {
-        console.log(chalk.yellow('📋 Rate Limit:\n'));
-        console.log(chalk.gray('   You\'ve hit the API rate limit. Please wait a moment and try again.\n'));
-      } else {
-        console.log(chalk.yellow('💡 Tip: Try selecting a more widely supported model\n'));
-      }
+  // Verify the selected model is operational
+  console.log('');
+  const modelTestSpinner = ora(`Testing model ${model}...`).start();
 
-      const { retry } = await inquirer.prompt([
-        {
-          type: 'confirm',
-          name: 'retry',
-          message: 'Try again with different configuration?',
-          default: true
-        }
-      ]);
+  try {
+    const AIClient = require('./ai-client');
+    const testClient = new AIClient({
+      provider: selectedProvider.id,
+      model,
+      apiKey
+    });
 
-      if (retry) {
-        return configureAIProvider(projectPath); // Recursive retry
-      } else {
-        process.exit(1);
+    await testClient.test();
+    modelTestSpinner.succeed(chalk.green(`Model ${model} verified successfully`));
+  } catch (error) {
+    modelTestSpinner.fail(chalk.red(`Model ${model} test failed`));
+    console.log(chalk.red(`\nError: ${error.message}\n`));
+    console.log(chalk.yellow('⚠️  This model appears to be listed but not operational.'));
+    console.log(chalk.gray('Possible reasons:'));
+    console.log(chalk.gray('  • Model requires higher API tier or special access'));
+    console.log(chalk.gray('  • Model is experimental or in preview'));
+    console.log(chalk.gray('  • Model has specific parameter requirements'));
+    console.log(chalk.gray('  • Provider-side issue or rate limiting\n'));
+
+    const { retry } = await inquirer.prompt([
+      {
+        type: 'confirm',
+        name: 'retry',
+        message: 'Try selecting a different model?',
+        default: true
       }
+    ]);
+
+    if (retry) {
+      // Recursively retry model selection (keep same provider)
+      return configureAIProvider(projectPath);
+    } else {
+      process.exit(1);
     }
   }
 

package/lib/commands/deploy.js

@@ -8,22 +8,30 @@ const {
   generateCursor,
   generateVSCode,
   generateZed,
-  generateAntigravity
+  generateAntigravity,
+  generateOpenCode,
+  generateGeminiCLI,
+  generateDeepAgent
 } = require('../generators');
 const ContextManager = require('../utils/context-manager');
 
 const TOOLS = {
+  // IDEs
   windsurf: { name: 'Windsurf', configFile: '.windsurfrules' },
   cursor: { name: 'Cursor', configFile: '.cursorrules' },
   vscode: { name: 'VS Code', configFile: '.vscode/settings.json' },
   'vscode-insider': { name: 'VS Code Insider', configFile: '.vscode-insider/settings.json' },
   zed: { name: 'Zed Editor', configFile: '.zed/settings.json' },
-  kiro: { name: 'Kiro', configFile: '.kiro/config.json' },
-  trae: { name: 'Trae', configFile: '.trae/config.json' },
-  'claude-code': { name: 'Claude Code', configFile: '.claude/config.json' },
-  'gemini-cli': { name: 'Gemini CLI', configFile: '.gemini/config.json' },
-  'codex-cli': { name: 'Codex CLI', configFile: '.codex/config.json' },
-  antigravity: { name: 'Google Antigravity', configFile: '.agent/README.md' }
+  antigravity: { name: 'Google Antigravity', configFile: '.antigravity/agents.yaml' },
+
+  // CLI Tools
+  'claude-code': { name: 'Claude Code', configFile: '.framework/agents/' },
+  'opencode': { name: 'OpenCode CLI', configFile: '.opencode.json' },
+  'gemini-cli': { name: 'Gemini CLI', configFile: 'GEMINI.md' },
+  'deepagent': { name: 'DeepAgent (Abacus.ai)', configFile: '.deepagent/agents/' },
+
+  // Generic
+  generic: { name: 'Generic AI Tools', configFile: '.framework/agents/' }
 };
 
 /**
@@ -190,6 +198,25 @@ async function deployToTool(tool, options = {}) {
           console.log(chalk.green('✓ Generated Antigravity configurations'));
           console.log(chalk.gray(`  - .antigravity/agents.yaml (AGENTS.md mount, .context access)`));
         }
+      } else if (tool === 'opencode') {
+        generatedFiles = await generateOpenCode(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated OpenCode CLI configurations'));
+          console.log(chalk.gray(`  - .opencode.json (project config, agents, MCP servers)`));
+        }
+      } else if (tool === 'gemini-cli') {
+        generatedFiles = await generateGeminiCLI(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Gemini CLI configurations'));
+          console.log(chalk.gray(`  - GEMINI.md (project context and instructions)`));
+        }
+      } else if (tool === 'deepagent') {
+        generatedFiles = await generateDeepAgent(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated DeepAgent configurations'));
+          console.log(chalk.gray(`  - .deepagent/agents/ (agent markdown files)`));
+          console.log(chalk.gray(`  - .deepagent/README.md (project overview)`));
+        }
       }
     } catch (error) {
       console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate ${TOOLS[tool]?.name || tool} configurations: ${error.message}`));

package/lib/generators/deepagent-generator.js

@@ -0,0 +1,144 @@
+const fs = require('fs-extra');
+const path = require('path');
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generator for Abacus.ai DeepAgent configurations
+ * Creates agent markdown files in .deepagent/agents/ directory
+ * Similar to Claude Code but for DeepAgent CLI
+ */
+class DeepAgentGenerator extends ToolConfigGenerator {
+  /**
+   * Generate DeepAgent configuration
+   * @returns {Object} Generated file paths
+   */
+  async generate() {
+    await this.initialize();
+
+    const deepagentDir = path.join(this.projectPath, '.deepagent');
+    const agentsDir = path.join(deepagentDir, 'agents');
+
+    await fs.ensureDir(agentsDir);
+
+    // Copy agent files from session
+    const agentFiles = await this.deployAgentFiles(agentsDir);
+
+    // Create README with project context
+    const readmePath = await this.generateReadme(deepagentDir);
+
+    return {
+      agents: agentFiles,
+      readme: readmePath
+    };
+  }
+
+  /**
+   * Generate README.md with project context
+   */
+  async generateReadme(deepagentDir) {
+    const readmePath = path.join(deepagentDir, 'README.md');
+    const projectContext = await this.getProjectContext();
+
+    const content = `# DeepAgent Configuration
+
+> Generated by ADF CLI v${this.getADFVersion()}
+> Framework: ${this.getFrameworkName()}
+
+## Project Overview
+
+**${projectContext.name || 'Project'}**
+
+${projectContext.overview || 'AI-assisted development project'}
+
+## Agent Files
+
+This directory contains agent definitions for DeepAgent CLI:
+
+${this.getAgentList()}
+
+## Workflow Level
+
+**${this.framework.toUpperCase()}**: ${this.getWorkflowDescription()}
+
+## Quick Commands
+
+\`\`\`bash
+# Build
+${projectContext.buildCommand || 'npm run build'}
+
+# Test
+${projectContext.testCommand || 'npm test'}
+
+# Lint
+${projectContext.lintCommand || 'npm run lint'}
+\`\`\`
+
+## Requirements Location
+
+Complete requirements and documentation:
+- \`.adf/sessions/${this.getSessionId()}/outputs/\`
+
+## Usage
+
+DeepAgent will automatically load agents from this directory.
+Each agent file contains role-specific instructions and context.
+
+---
+
+*Generated by AgentDevFramework (ADF CLI)*
+`;
+
+    await fs.writeFile(readmePath, content, 'utf-8');
+    return readmePath;
+  }
+
+  /**
+   * Get list of agents based on framework
+   */
+  getAgentList() {
+    const agentLists = {
+      'rapid': '- `dev.md` - Developer agent\n- `qa.md` - QA engineer agent',
+      'balanced': '- `analyst.md` - Business analyst agent\n- `pm.md` - Product manager agent\n- `dev.md` - Developer agent\n- `qa.md` - QA engineer agent',
+      'comprehensive': '- `analyst.md` - Business analyst agent\n- `pm.md` - Product manager agent\n- `architect.md` - Solutions architect agent\n- `sm.md` - Scrum master agent\n- `dev.md` - Developer agent\n- `qa.md` - QA engineer agent'
+    };
+    return agentLists[this.framework] || agentLists['balanced'];
+  }
+
+  /**
+   * Get workflow description
+   */
+  getWorkflowDescription() {
+    const descriptions = {
+      'rapid': 'Fast iteration with core features (PRP)',
+      'balanced': 'Specification-driven development (Spec-Kit)',
+      'comprehensive': 'Enterprise-grade with full BMAD documentation'
+    };
+    return descriptions[this.framework] || 'Standard development workflow';
+  }
+
+  /**
+   * Get framework display name
+   */
+  getFrameworkName() {
+    const names = {
+      'rapid': 'Rapid Development (PRP)',
+      'balanced': 'Balanced (Specification-Driven)',
+      'comprehensive': 'BMAD Comprehensive (Enterprise)'
+    };
+    return names[this.framework] || this.framework;
+  }
+
+  /**
+   * Get ADF CLI version
+   */
+  getADFVersion() {
+    try {
+      const packageJson = require('../../package.json');
+      return packageJson.version;
+    } catch (error) {
+      return '0.12.0';
+    }
+  }
+}
+
+module.exports = DeepAgentGenerator;