@iservu-inc/adf-cli 0.12.0 → 0.12.10

package/.claude/settings.local.json

@@ -2,17 +2,23 @@
   "permissions": {
     "allow": [
       "Bash(npm test:*)",
-      "Bash(git commit -m \"$(cat <<''EOF''\ndocs: Update documentation for v0.10.0 release\n\n- Updated CHANGELOG.md with comprehensive v0.10.0 entry\n  * Pattern Decay Algorithm documentation\n  * Technical implementation details\n  * Use cases and examples\n  * Test coverage information\n  \n- Updated README.md version history\n  * Added v0.10.0 as latest release\n  * Pattern decay feature highlights\n  \n- Updated SESSION-STATUS.md\n  * Current version: v0.10.0\n  * Latest achievements and test coverage\n  * Phase 6 status\n  \n- Fixed test export issues in pattern-detector.js\n  * Added standalone function exports for testing\n  * Fixed applyDecayToStoredPatterns return value\n  \n- Fixed decay-manager.js config handling\n  * Use default config when decayConfig not initialized\n  * Prevents null reference errors in tests\n\nTest Status: 231/239 passing (96.7%)\n- Core decay functionality fully working\n- 8 edge case failures in Date mocking (to fix in v0.10.1)\n\n🤖 Generated with [Claude Code](https://claude.com/claude-code)\n\nCo-Authored-By: Claude <noreply@anthropic.com>\nEOF\n)\")",
-      "Bash(npm publish)",
-      "mcp__archon__find_projects",
-      "mcp__archon__find_tasks",
+      "Bash(npm publish:*)",
       "Bash(npm view:*)",
+      "Bash(npm config:*)",
       "Bash(git add:*)",
       "Bash(git commit:*)",
       "Bash(git tag:*)",
       "Bash(git push:*)",
-      "Bash(npm publish:*)",
-      "Bash(npm config set:*)"
+      "mcp__archon__find_projects",
+      "mcp__archon__find_tasks",
+      "Bash(adf doctor:*)",
+      "Bash(adf --help:*)",
+      "Bash(claude doctor)",
+      "WebFetch(domain:openrouter.ai)",
+      "WebFetch(domain:github.com)",
+      "WebFetch(domain:antigravity.google)",
+      "WebSearch",
+      "Bash(node -c:*)"
     ],
     "deny": [],
     "ask": []

package/CHANGELOG.md

@@ -5,6 +5,115 @@ All notable changes to `@iservu-inc/adf-cli` will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.12.9] - 2025-12-23
+
+### 🚀 Multi-Tool Expansion & AI Provider Robustness
+
+**MAJOR ENHANCEMENTS:** Expanded deployment support to 4 additional CLI tools and significantly improved AI provider reliability with comprehensive model verification and parameter compatibility fixes.
+
+#### What's New
+
+**New CLI Tool Support:**
+- **OpenCode CLI** - Complete generator with JSON configuration
+  - Output: `.opencode.json` with project config, agents, and MCP servers
+  - Model selection: Anthropic Claude models based on framework complexity
+  - MCP integration: Filesystem server for project access
+  - Auto-compacting and debug configuration
+
+- **Google Gemini CLI** - Markdown-based project context
+  - Output: `GEMINI.md` with structured project information
+  - Role-specific agent guidance
+  - Build/test/lint command reference
+  - Development guidelines and security standards
+
+- **DeepAgent (Abacus.ai)** - Agent markdown deployment
+  - Output: `.deepagent/agents/*.md` + `.deepagent/README.md`
+  - Similar to Claude Code but for DeepAgent CLI
+  - Project overview and workflow documentation
+  - Per-agent markdown files with role-specific instructions
+
+- **Zed Editor Support Verified** - Confirmed full 253-line generator integration
+  - MCP server configuration (project_context, archon)
+  - AGENTS.md symlink support (`.zed/rules -> ../AGENTS.md`)
+  - Agent-specific keymap configuration
+  - Model selection based on framework complexity
+
+**AI Provider Improvements:**
+
+**Model Verification System:**
+- ✅ **Test Before Save** - All models now tested with actual API request before configuration
+- ✅ **Clear Error Messages** - Detailed failure reasons when models don't work
+- ✅ **Retry Option** - Easy retry with different model on failure
+- ✅ **Operational Status** - Distinguishes between "listed" and "operational" models
+
+**Google Gemini Fixes:**
+- 🔧 Fixed API key validation (`genAI.listModels is not a function` error)
+- 🔧 Implemented dynamic model fetching via REST API (`/v1beta/models` endpoint)
+- 🔧 Updated validation model from deprecated `gemini-pro` to `gemini-1.5-flash`
+- 🔧 Filters models by `generateContent` support capability
+
+**Anthropic Model Expansion:**
+- 📊 Expanded from 3 to 11 models with comprehensive coverage
+- 📊 Added Claude 4.5 series (Sonnet, Opus)
+- 📊 Added Claude 3.5 series (Sonnet variants, Haiku)
+- 📊 Added Claude 3 series (Opus, Sonnet, Haiku)
+- 📊 Added Claude 2 series (2.1, 2.0, Instant)
+- 📊 Attempts dynamic fetch from API with fallback to curated list
+
+**OpenAI & OpenRouter Parameter Compatibility:**
+- 🔧 Fixed parameter compatibility for newer models (GPT-5, o-series)
+- 🔧 Updated regex pattern from `/^(o\d|gpt-5)/` to `/^(o1|o3|gpt-5)/i`
+- 🔧 Uses `max_completion_tokens` for reasoning models instead of `max_tokens`
+- 🔧 Automatic retry with fallback parameters on 400 errors
+- ✅ Confirmed working with `gpt-5.2-chat-latest` and other GPT-5 models
+
+**Enhanced Help System:**
+- 📚 Comprehensive `--help` documentation for all commands
+- 📚 Quick Start section with step-by-step workflow
+- 📚 Detailed command breakdowns (init, deploy, config, update)
+- 📚 Tool-by-tool deployment guide with output locations
+- 📚 Performance mode explanations (Fast/Balanced/Comprehensive)
+- 📚 AI provider setup instructions with API key links
+- 📚 Configuration categories with feature descriptions
+- 📚 Examples for common workflows
+
+#### Technical Details
+
+**New Files:**
+- `lib/generators/opencode-generator.js` - OpenCode CLI configuration generator (120+ lines)
+- `lib/generators/gemini-cli-generator.js` - Gemini CLI markdown generator (150+ lines)
+- `lib/generators/deepagent-generator.js` - DeepAgent configuration generator (145+ lines)
+
+**Modified Files:**
+- `lib/ai/ai-client.js` - Parameter compatibility fixes for newer models
+- `lib/ai/ai-config.js` - Model verification, Google Gemini fixes, Anthropic expansion
+- `bin/adf.js` - Comprehensive help system enhancements (300+ lines of documentation)
+- `lib/commands/deploy.js` - Added new tool registrations and deployment cases
+- `lib/generators/index.js` - Export new generators
+
+**Deployment Support Summary:**
+- **IDEs (6):** Windsurf, Cursor, VS Code, Zed, Antigravity, VS Code Insider
+- **CLI Tools (5):** Claude Code, OpenCode, Gemini CLI, DeepAgent, Generic
+- **Total Tools:** 11 deployment targets
+
+#### Bug Fixes
+- Fixed: OpenRouter models listed but not operational (added verification)
+- Fixed: OpenAI GPT-5 models parameter incompatibility (`max_tokens` vs `max_completion_tokens`)
+- Fixed: Google Gemini API validation failure (`listModels` method error)
+- Fixed: Anthropic incomplete model listing (3 models → 11 models)
+- Fixed: Model testing skipped during configuration process
+
+#### Keywords Added
+- `opencode` - OpenCode CLI support
+- `gemini-cli` - Google Gemini CLI support
+- `deepagent` - Abacus.ai DeepAgent support
+
+#### Backward Compatibility
+- ✅ **100% Backward Compatible** - All changes are additive
+- ✅ All existing deployments continue to work
+- ✅ No breaking changes to API or CLI commands
+- ✅ Existing configurations automatically benefit from improved verification
+
 ## [0.12.0] - 2025-12-22
 
 ### 🎯 Agent-Native Development Framework (ANDF) Standard Implementation

package/README.md

@@ -98,15 +98,21 @@ adf deploy --list
 ```
 
 **Supported Tools:**
-- windsurf
-- cursor
-- vscode
-- vscode-insider
-- kiro
-- trae
-- claude-code
-- gemini-cli
-- codex-cli
+
+**IDEs:**
+- windsurf - Codeium Windsurf IDE
+- cursor - Cursor AI IDE
+- vscode - Visual Studio Code
+- vscode-insider - VS Code Insider
+- zed - Zed Editor
+- antigravity - Google Antigravity
+
+**CLI Tools:**
+- claude-code - Anthropic Claude Code CLI
+- opencode - OpenCode CLI
+- gemini-cli - Google Gemini CLI
+- deepagent - Abacus.ai DeepAgent
+- generic - Generic AI tools
 
 ### Update CLI
 
@@ -495,16 +501,29 @@ When we release updates to the framework:
 
 See [CHANGELOG.md](./CHANGELOG.md) for detailed version history.
 
-**Latest:** v0.10.0 (2025-10-27)
-- **Pattern Decay Algorithm (v0.10.0)** - Phase 6: Advanced Learning Features
+**Latest:** v0.12.9 (2025-12-23)
+- **Multi-Tool Expansion & AI Provider Robustness (v0.12.9)**
+  - Added 4 new CLI tools: OpenCode, Gemini CLI, DeepAgent, verified Zed support
+  - Comprehensive AI provider improvements with model verification
+  - Fixed Google Gemini API integration and expanded Anthropic models (3 → 11)
+  - Enhanced help system with detailed documentation
+  - OpenAI/OpenRouter parameter compatibility for GPT-5 and o-series models
+  - All models now tested before configuration save
+
+**Previous Releases:**
+- **v0.12.0 (2025-12-22)** - ANDF Standard Implementation
+  - Complete AGENTS.md standard compliance with YAML frontmatter
+  - .context/ directory support with architecture and glossary generation
+  - Zed Editor and Google Antigravity full generator support
+  - MCP integration and agent configuration
+
+- **v0.10.0 (2025-10-27)** - Pattern Decay Algorithm
   - Time-based exponential decay for inactive patterns
   - Confidence-based decay rates (high/medium/low)
   - Automatic pattern cleanup and renewal system
   - 40+ comprehensive tests for decay functionality
-  - Pattern metadata tracking (timestamps, renewal counts)
-  - Removal history and analytics
 
-**Previous Release:** v0.9.1 (2025-10-05)
+- **v0.9.1 (2025-10-05)** - AI Analysis Settings
 - **AI Analysis Settings (v0.9.0)** - Performance modes and configurable AI features
   - Three performance modes: Fast, Balanced, Comprehensive
   - Five individually configurable AI features

package/bin/adf.js

@@ -29,7 +29,68 @@ program
   .addHelpText('before', () => {
     const adfInstallPath = path.resolve(__dirname, '..');
     return `\n${chalk.cyan.bold('ADF CLI')} ${chalk.gray(`v${packageJson.version}`)}\n${chalk.gray('Install Path:')} ${chalk.white(adfInstallPath)}\n`;
-  });
+  })
+  .addHelpText('after', `
+${chalk.cyan.bold('Quick Start:')}
+  ${chalk.gray('1. Configure your AI provider')}
+  $ adf config
+
+  ${chalk.gray('2. Initialize a project with AI-guided interview')}
+  $ adf init
+
+  ${chalk.gray('3. Deploy to your AI coding assistant')}
+  $ adf deploy
+
+${chalk.cyan.bold('What is ADF?')}
+  AgentDevFramework (ADF) is an AI-assisted development framework that helps
+  you gather requirements through intelligent AI-guided interviews. It supports
+  multiple AI providers and workflow levels, from rapid prototyping to
+  comprehensive enterprise documentation.
+
+${chalk.cyan.bold('Key Features:')}
+  • ${chalk.yellow('Multi-Provider AI')} - Anthropic, OpenAI, Google, OpenRouter
+  • ${chalk.yellow('3 Workflow Levels')} - Rapid (PRP), Balanced (Spec-Kit), Comprehensive (BMAD)
+  • ${chalk.yellow('Smart Filtering')} - AI-powered question filtering based on context
+  • ${chalk.yellow('Learning System')} - Adapts to your preferences over time
+  • ${chalk.yellow('Session Resume')} - Pause and resume interviews anytime
+  • ${chalk.yellow('Multi-Tool Deploy')} - 10+ IDEs and CLI tools supported
+    ${chalk.gray('IDEs:')} Windsurf, Cursor, VS Code, Zed, Antigravity
+    ${chalk.gray('CLI:')} Claude Code, OpenCode, Gemini CLI, DeepAgent
+
+${chalk.cyan.bold('Getting Help:')}
+  ${chalk.gray('# Detailed help for specific commands')}
+  $ adf init --help
+  $ adf deploy --help
+  $ adf config --help
+  $ adf update --help
+
+  ${chalk.gray('# Check version and install path')}
+  $ adf --version
+
+${chalk.cyan.bold('Common Workflows:')}
+  ${chalk.yellow('Quick Prototype:')}
+    $ adf init --rapid --tool windsurf
+
+  ${chalk.yellow('Standard Project:')}
+    $ adf config              ${chalk.gray('# Configure AI provider once')}
+    $ adf init --balanced     ${chalk.gray('# Run interview')}
+    $ adf deploy cursor       ${chalk.gray('# Deploy to Cursor')}
+
+  ${chalk.yellow('Enterprise Project:')}
+    $ adf config              ${chalk.gray('# Configure with comprehensive mode')}
+    $ adf init --comprehensive
+    $ adf deploy vscode       ${chalk.gray('# Deploy to multiple tools')}
+    $ adf deploy claude-code
+
+${chalk.cyan.bold('Documentation & Support:')}
+  • GitHub: https://github.com/iservu/adf-cli
+  • Issues: https://github.com/iservu/adf-cli/issues
+  • Docs:   https://github.com/iservu/adf-cli#readme
+
+${chalk.cyan.bold('Learn More:')}
+  Run any command with ${chalk.white('--help')} for detailed information:
+  ${chalk.gray('$ adf <command> --help')}
+`);
 
 // adf init
 program
@@ -39,6 +100,51 @@ program
   .option('--balanced', 'Skip questions, use Level 2 (Balanced)')
   .option('--comprehensive', 'Skip questions, use Level 3 (Comprehensive)')
   .option('--tool <tool>', 'Specify deployment tool (windsurf, cursor, etc.)')
+  .addHelpText('after', `
+${chalk.cyan.bold('Description:')}
+  Start an interactive AI-guided interview to gather project requirements.
+  The interview uses AI to analyze your answers and generate comprehensive
+  documentation based on your chosen workflow level.
+
+${chalk.cyan.bold('Workflow Levels:')}
+  ${chalk.yellow('Rapid (PRP)')}          - 20 core questions, fast setup
+                        Agents: dev, qa
+                        Output: prp.md
+                        Best for: Quick prototypes, MVPs
+
+  ${chalk.yellow('Balanced (Spec-Kit)')}  - 30+ questions, detailed specs
+                        Agents: analyst, pm, dev, qa
+                        Output: constitution.md, specification.md, plan.md, tasks.md
+                        Best for: Standard projects with clear requirements
+
+  ${chalk.yellow('Comprehensive (BMAD)')} - 40+ questions, full documentation
+                        Agents: analyst, pm, architect, sm, dev, qa
+                        Output: prd.md, architecture.md, stories.md
+                        Best for: Enterprise projects, complex systems
+
+${chalk.cyan.bold('Examples:')}
+  ${chalk.gray('# Interactive mode - choose workflow interactively')}
+  $ adf init
+
+  ${chalk.gray('# Quick start with Rapid workflow')}
+  $ adf init --rapid
+
+  ${chalk.gray('# Balanced workflow deployed to Windsurf')}
+  $ adf init --balanced --tool windsurf
+
+  ${chalk.gray('# Comprehensive workflow for enterprise project')}
+  $ adf init --comprehensive
+
+${chalk.cyan.bold('Features:')}
+  • AI-powered question filtering based on project context
+  • Answer quality analysis and suggestions
+  • Session resume capability (Ctrl+C to pause)
+  • Learning system that adapts to your preferences
+  • Multi-provider AI support (Anthropic, OpenAI, Google, OpenRouter)
+
+${chalk.cyan.bold('Output Directory:')}
+  All outputs saved to: ${chalk.white('.adf/sessions/{timestamp}_{workflow}/')}
+`)
   .action(initCommand);
 
 // adf deploy
@@ -46,6 +152,96 @@ program
   .command('deploy [tool]')
   .description('Deploy framework to specified tool')
   .option('-l, --list', 'List available deployment tools')
+  .addHelpText('after', `
+${chalk.cyan.bold('Description:')}
+  Deploy ADF framework outputs to your AI coding assistant or IDE.
+  Converts session outputs (PRD, specs, stories) into tool-specific
+  configuration files and agent definitions.
+
+${chalk.cyan.bold('Command Syntax:')}
+  ${chalk.white('adf deploy [tool]')}
+
+  ${chalk.yellow('[tool]')} - (Optional) Target tool name
+              If omitted, you'll be prompted to select interactively
+              Supported: windsurf, cursor, vscode, claude-code, zed, generic
+
+${chalk.cyan.bold('Supported Tools:')}
+  ${chalk.white.bold('IDEs:')}
+  ${chalk.yellow('windsurf')}      - Codeium Windsurf IDE
+                   Output: .windsurfrules
+
+  ${chalk.yellow('cursor')}        - Cursor AI IDE
+                   Output: .cursorrules
+
+  ${chalk.yellow('vscode')}        - Visual Studio Code
+                   Output: .vscode/settings.json, .github/copilot-instructions.md
+
+  ${chalk.yellow('zed')}           - Zed Editor
+                   Output: .zed/settings.json, .zed/rules (symlink to AGENTS.md)
+
+  ${chalk.yellow('antigravity')}   - Google Antigravity IDE
+                   Output: .antigravity/agents.yaml
+
+  ${chalk.white.bold('CLI Tools:')}
+  ${chalk.yellow('claude-code')}   - Anthropic Claude Code CLI
+                   Output: .framework/agents/*.md
+
+  ${chalk.yellow('opencode')}      - OpenCode CLI
+                   Output: .opencode.json (JSON config with agents & MCP)
+
+  ${chalk.yellow('gemini-cli')}    - Google Gemini CLI
+                   Output: GEMINI.md (project context markdown)
+
+  ${chalk.yellow('deepagent')}     - Abacus.ai DeepAgent CLI
+                   Output: .deepagent/agents/*.md, .deepagent/README.md
+
+  ${chalk.white.bold('Generic:')}
+  ${chalk.yellow('generic')}       - Generic AI tools (agent markdown files)
+                   Output: .framework/agents/*.md
+
+${chalk.cyan.bold('Examples:')}
+  ${chalk.gray('# List available tools')}
+  $ adf deploy --list
+
+  ${chalk.gray('# Interactive tool selection')}
+  $ adf deploy
+
+  ${chalk.gray('# Deploy to specific tool')}
+  $ adf deploy windsurf
+
+  ${chalk.gray('# Deploy to multiple tools (run multiple times)')}
+  $ adf deploy cursor
+  $ adf deploy vscode
+
+${chalk.cyan.bold('How It Works:')}
+  1. Finds latest completed interview session
+  2. Loads session outputs (PRD, architecture, stories, etc.)
+  3. Transforms outputs into tool-specific format
+  4. Writes configuration files to project root
+  5. Deploys agent definitions (if applicable)
+
+${chalk.cyan.bold('Requirements:')}
+  • Must have completed at least one 'adf init' session
+  • Session must have generated outputs
+  • Outputs located in: .adf/sessions/{timestamp}_{workflow}/outputs/
+
+${chalk.cyan.bold('Output Files by Tool:')}
+  ${chalk.white.bold('IDEs:')}
+  Windsurf:      ${chalk.white('.windsurfrules')}
+  Cursor:        ${chalk.white('.cursorrules')}
+  VS Code:       ${chalk.white('.vscode/settings.json + .github/copilot-instructions.md')}
+  Zed:           ${chalk.white('.zed/settings.json + .zed/rules')}
+  Antigravity:   ${chalk.white('.antigravity/agents.yaml')}
+
+  ${chalk.white.bold('CLI Tools:')}
+  Claude Code:   ${chalk.white('.framework/agents/*.md')}
+  OpenCode:      ${chalk.white('.opencode.json')}
+  Gemini CLI:    ${chalk.white('GEMINI.md')}
+  DeepAgent:     ${chalk.white('.deepagent/agents/*.md + .deepagent/README.md')}
+
+  ${chalk.white.bold('Generic:')}
+  Generic:       ${chalk.white('.framework/agents/*.md')}
+`)
   .action(deployCommand);
 
 // adf update
@@ -53,12 +249,154 @@ program
   .command('update')
   .description('Check for CLI updates and update to latest version')
   .option('--check', 'Only check for updates, don\'t install')
+  .addHelpText('after', `
+${chalk.cyan.bold('Description:')}
+  Check for new versions of ADF CLI and update to the latest release.
+  Compares your current version with the latest published on npm registry.
+
+${chalk.cyan.bold('Command Syntax:')}
+  ${chalk.white('adf update [options]')}
+
+${chalk.cyan.bold('Options:')}
+  ${chalk.yellow('--check')} - Check for updates without installing
+              Shows version comparison and changelog preview
+              No modifications made to your installation
+
+${chalk.cyan.bold('Examples:')}
+  ${chalk.gray('# Check if updates are available')}
+  $ adf update --check
+
+  ${chalk.gray('# Update to latest version')}
+  $ adf update
+
+  ${chalk.gray('# Check current version')}
+  $ adf --version
+
+${chalk.cyan.bold('Update Process:')}
+  1. Fetches latest version info from npm registry
+  2. Compares with your installed version
+  3. Shows changelog and new features
+  4. Prompts for confirmation (if installing)
+  5. Downloads and installs latest version
+  6. Verifies successful installation
+
+${chalk.cyan.bold('Installation Methods:')}
+  ${chalk.yellow('Global Install')} (recommended)
+    $ npm install -g @iservu-inc/adf-cli
+    Updates system-wide installation
+
+  ${chalk.yellow('Local Development')} (npm link)
+    $ cd adf-cli && git pull && npm link
+    Updates linked development version
+
+${chalk.cyan.bold('What Gets Updated:')}
+  • Core CLI functionality
+  • AI provider integrations (Anthropic, OpenAI, Google, OpenRouter)
+  • Interview question sets
+  • Output generators and templates
+  • Bug fixes and performance improvements
+
+${chalk.cyan.bold('Backwards Compatibility:')}
+  • Existing .adf directories are preserved
+  • Sessions and learning data remain intact
+  • API keys and configurations are not affected
+  • May require re-running 'adf deploy' for new features
+`)
   .action(updateCommand);
 
 // adf config
 program
   .command('config')
   .description('Configure ADF settings (AI provider, etc.)')
+  .addHelpText('after', `
+${chalk.cyan.bold('Description:')}
+  Interactive configuration wizard for ADF settings.
+  Configure AI providers, analysis settings, and learning system preferences.
+
+${chalk.cyan.bold('Configuration Categories:')}
+  ${chalk.yellow('1. AI Provider Setup')}
+     Configure which AI provider to use for interviews
+     • Select provider (Anthropic, OpenAI, Google, OpenRouter)
+     • Enter/validate API key
+     • Choose model from dynamically fetched list
+     • Test connection before saving
+
+  ${chalk.yellow('2. Analysis Settings')}
+     Control AI analysis features and performance
+     • Performance Mode: Fast / Balanced / Comprehensive
+     • Answer Quality Analysis: ON / OFF
+     • Smart Question Filtering: ON / OFF
+     • Question Reordering: ON / OFF
+     • Context Extraction: ON / OFF
+
+  ${chalk.yellow('3. Learning System')}
+     Manage skip pattern detection and auto-filtering
+     • Enable/Disable learning system
+     • View detected patterns and rules
+     • Manage learned preferences
+     • Export analytics to JSON/CSV
+     • Configure decay thresholds
+
+${chalk.cyan.bold('AI Providers Supported:')}
+  ${chalk.yellow('Anthropic Claude')}
+    Models: claude-sonnet-4-5, claude-opus-4-5, claude-3-5-sonnet, etc.
+    API Key: Get from https://console.anthropic.com/
+    Format: sk-ant-...
+
+  ${chalk.yellow('OpenAI GPT')}
+    Models: gpt-5.2-chat, gpt-4o, o1, o3, etc. (116+ models)
+    API Key: Get from https://platform.openai.com/api-keys
+    Format: sk-...
+
+  ${chalk.yellow('Google Gemini')}
+    Models: gemini-2.0-flash, gemini-1.5-pro, gemini-1.5-flash, etc.
+    API Key: Get from https://aistudio.google.com/app/apikey
+    Format: (varies)
+
+  ${chalk.yellow('OpenRouter')}
+    Models: 100+ models from multiple providers
+    API Key: Get from https://openrouter.ai/keys
+    Format: sk-or-...
+
+${chalk.cyan.bold('Examples:')}
+  ${chalk.gray('# Open configuration menu')}
+  $ adf config
+
+  ${chalk.gray('# After configuration, verify with:')}
+  $ cat .adf/.env
+  $ adf init
+
+${chalk.cyan.bold('Performance Modes:')}
+  ${chalk.yellow('Fast')}           - Minimal AI calls (~0.5s per answer)
+                    Answer quality: OFF
+                    Smart filtering: OFF
+                    Best for: Quick interviews, testing
+
+  ${chalk.yellow('Balanced')}       - Moderate AI usage (~2-3s per answer)
+                    Answer quality: ON
+                    Smart filtering: ON
+                    Best for: Most projects (recommended)
+
+  ${chalk.yellow('Comprehensive')} - Full AI analysis (~4-6s per answer)
+                    All features: ON
+                    Context extraction: ON
+                    Question reordering: ON
+                    Best for: Critical projects, detailed requirements
+
+${chalk.cyan.bold('Storage Locations:')}
+  API Keys:           ${chalk.white('.adf/.env')} ${chalk.gray('(gitignored)')}
+  Analysis Config:    ${chalk.white('.adf/analysis-config.json')}
+  Learning Data:      ${chalk.white('.adf/learning/')}
+  Active Provider:    ${chalk.white('.adf/.env')} ${chalk.gray('(ADF_CURRENT_PROVIDER)')}
+  Active Model:       ${chalk.white('.adf/.env')} ${chalk.gray('(ADF_CURRENT_MODEL)')}
+
+${chalk.cyan.bold('Security Notes:')}
+  • API keys stored in .adf/.env (automatically gitignored)
+  • Never committed to version control
+  • Keys validated before saving
+  • Models tested for operational status
+  • All data stored locally on your machine
+`)
   .action(configCommand);
 
 // Handle unknown commands