@iservu-inc/adf-cli 0.11.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

@@ -6,19 +6,32 @@ const {
   generateAgentsMd,
   generateWindsurf,
   generateCursor,
-  generateVSCode
+  generateVSCode,
+  generateZed,
+  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' },
-  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' }
+  zed: { name: 'Zed Editor', configFile: '.zed/settings.json' },
+  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/' }
 };
 
 /**
@@ -108,6 +121,24 @@ async function deployToTool(tool, options = {}) {
   const spinner = options.silent ? null : ora(`Deploying to ${TOOLS[tool]?.name || tool}...`).start();
 
   try {
+    // Create .context/ directory structure (ANDF standard)
+    if (spinner) spinner.text = 'Creating .context/ structure...';
+
+    try {
+      const contextManager = new ContextManager(cwd);
+      await contextManager.createStructure();
+      await contextManager.generateArchitecture(sessionPath, framework);
+      await contextManager.generateGlossary(sessionPath, framework);
+
+      if (!options.silent && !spinner) {
+        console.log(chalk.green('✓ Created .context/ structure'));
+        console.log(chalk.gray('  - .context/memory/architecture.md'));
+        console.log(chalk.gray('  - .context/memory/glossary.md'));
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`\n⚠️  Warning: Could not create .context/ structure: ${error.message}`));
+    }
+
     // Generate AGENTS.md (universal standard)
     if (!options.silent) {
       if (spinner) spinner.text = 'Generating AGENTS.md...';
@@ -150,6 +181,42 @@ async function deployToTool(tool, options = {}) {
           console.log(chalk.gray(`  - .github/copilot-instructions.md`));
           console.log(chalk.gray(`  - .vscode/settings.json (custom chat modes)`));
         }
+      } else if (tool === 'zed') {
+        generatedFiles = await generateZed(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Zed Editor configurations'));
+          console.log(chalk.gray(`  - .zed/settings.json (MCP servers, agent config)`));
+          console.log(chalk.gray(`  - .zed/keymap.json (agent shortcuts)`));
+          if (generatedFiles.rules) {
+            const linkType = generatedFiles.rules.type === 'symlink' ? 'symlink' : 'copy';
+            console.log(chalk.gray(`  - .zed/rules (${linkType} -> AGENTS.md)`));
+          }
+        }
+      } else if (tool === 'antigravity') {
+        generatedFiles = await generateAntigravity(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          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}`));