@iservu-inc/adf-cli 0.12.10 → 0.12.12

package/CHANGELOG.md

@@ -5,6 +5,46 @@ 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.10] - 2025-12-23
+
+### 🐛 Critical Bug Fixes
+
+**Patch Release:** Two critical bug fixes for deployment and AI provider error handling.
+
+#### Fixed
+
+**Deployment Error Fix:**
+- 🔧 **Fixed EISDIR error** when deploying to directory-based tools (claude-code, deepagent, generic)
+- Error: `EISDIR: illegal operation on a directory, open '.framework/agents'`
+- Root cause: Attempting to write file to directory path
+- Solution: Skip generic config writing for tools with directory-based configs (ending with `/`)
+- These tools use dedicated generators that handle file creation properly
+
+**AI Provider Error Handling:**
+- 🔧 **Improved rate limit error detection** for Google Gemini models
+- Now distinguishes between rate limit/quota errors vs model availability issues
+- Clear messaging for quota exceeded scenarios with actionable solutions:
+  - Try different model with available quota
+  - Wait for quota reset
+  - Upgrade to paid tier
+  - Use different AI provider
+- Added **Google Gemini free tier model recommendations**:
+  - `gemini-1.5-flash` (fastest, lowest quota usage) - Recommended
+  - `gemini-1.5-flash-8b` (ultra-fast, minimal quota)
+  - `gemini-2.0-flash-exp` (newer, experimental)
+- Warns about Pro models (gemini-pro, gemini-2.5-pro) potentially exceeding free tier quota
+
+#### Technical Details
+
+**Modified Files:**
+- `lib/commands/deploy.js` - Skip config writing for directory-based tools
+- `lib/ai/ai-config.js` - Enhanced error detection and messaging for rate limits
+
+#### Impact
+- ✅ Deployment now succeeds for all 11 supported tools
+- ✅ Users get clear guidance when hitting API rate limits
+- ✅ Reduces confusion about model availability vs quota issues
+
 ## [0.12.9] - 2025-12-23
 
 ### 🚀 Multi-Tool Expansion & AI Provider Robustness

package/README.md

@@ -501,16 +501,20 @@ When we release updates to the framework:
 
 See [CHANGELOG.md](./CHANGELOG.md) for detailed version history.
 
-**Latest:** v0.12.9 (2025-12-23)
-- **Multi-Tool Expansion & AI Provider Robustness (v0.12.9)**
+**Latest:** v0.12.10 (2025-12-23)
+- **Critical Bug Fixes (v0.12.10)** - Patch release
+  - Fixed EISDIR deployment error for directory-based tools
+  - Improved rate limit error detection for Gemini models
+  - Added free tier model recommendations for Google Gemini
+  - Clear messaging for quota vs availability issues
+
+**Previous Releases:**
+- **v0.12.9 (2025-12-23)** - Multi-Tool Expansion & AI Provider Robustness
   - 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

package/bin/adf.js

@@ -20,6 +20,7 @@ const initCommand = require('../lib/commands/init');
 const deployCommand = require('../lib/commands/deploy');
 const updateCommand = require('../lib/commands/update');
 const configCommand = require('../lib/commands/config');
+const guideCommand = require('../lib/commands/guide');
 
 const program = new Command();
 
@@ -41,6 +42,9 @@ ${chalk.cyan.bold('Quick Start:')}
   ${chalk.gray('3. Deploy to your AI coding assistant')}
   $ adf deploy
 
+  ${chalk.gray('4. Get setup instructions for your tool')}
+  $ adf guide <tool>
+
 ${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
@@ -61,9 +65,14 @@ ${chalk.cyan.bold('Getting Help:')}
   ${chalk.gray('# Detailed help for specific commands')}
   $ adf init --help
   $ adf deploy --help
+  $ adf guide --help
   $ adf config --help
   $ adf update --help
 
+  ${chalk.gray('# Get tool-specific setup guides')}
+  $ adf guide windsurf
+  $ adf guide claude-code
+
   ${chalk.gray('# Check version and install path')}
   $ adf --version
 
@@ -304,6 +313,69 @@ ${chalk.cyan.bold('Backwards Compatibility:')}
 `)
   .action(updateCommand);
 
+// adf guide
+program
+  .command('guide [tool]')
+  .description('Show setup guide for deployed tools')
+  .addHelpText('after', `
+${chalk.cyan.bold('Description:')}
+  Get detailed setup and usage instructions for AI tools after deployment.
+  Shows what files were generated, how to configure the tool, and how to start using it.
+
+${chalk.cyan.bold('Command Syntax:')}
+  ${chalk.white('adf guide [tool]')}
+
+  ${chalk.yellow('[tool]')} - (Optional) Tool name
+              If omitted, shows list of available guides
+
+${chalk.cyan.bold('Available Tools:')}
+  ${chalk.yellow('windsurf')}      - Codeium Windsurf IDE
+  ${chalk.yellow('cursor')}        - Cursor AI IDE
+  ${chalk.yellow('vscode')}        - Visual Studio Code with GitHub Copilot
+  ${chalk.yellow('zed')}           - Zed Editor
+  ${chalk.yellow('antigravity')}   - Google Antigravity
+  ${chalk.yellow('claude-code')}   - Claude Code CLI
+  ${chalk.yellow('opencode')}      - OpenCode CLI
+  ${chalk.yellow('gemini-cli')}    - Google Gemini CLI
+  ${chalk.yellow('deepagent')}     - Abacus.ai DeepAgent
+
+${chalk.cyan.bold('What You\'ll Learn:')}
+  • Which files were generated and what they do
+  • How to configure the tool to use ADF outputs
+  • How to start coding with AI assistance
+  • MCP server setup (if applicable)
+  • Keyboard shortcuts and workflows
+  • Troubleshooting common issues
+
+${chalk.cyan.bold('Examples:')}
+  ${chalk.gray('# List all available guides')}
+  $ adf guide
+
+  ${chalk.gray('# Get Windsurf setup instructions')}
+  $ adf guide windsurf
+
+  ${chalk.gray('# Learn how to use Claude Code CLI')}
+  $ adf guide claude-code
+
+  ${chalk.gray('# See Gemini CLI integration steps')}
+  $ adf guide gemini-cli
+
+${chalk.cyan.bold('Workflow:')}
+  1. Run ${chalk.white('adf init')} to gather requirements
+  2. Run ${chalk.white('adf deploy <tool>')} to deploy configurations
+  3. Run ${chalk.white('adf guide <tool>')} to learn how to use the tool
+  4. Start coding with AI assistance!
+
+${chalk.cyan.bold('What\'s in a Guide:')}
+  • 📁 Generated files with status check (✓ exists / ✗ missing)
+  • ⚙️  Step-by-step setup instructions
+  • 🔌 MCP server configuration (if applicable)
+  • 🚀 Usage examples and workflows
+  • 🔧 Troubleshooting tips
+  • 📖 Quick reference links
+`)
+  .action(guideCommand);
+
 // adf config
 program
   .command('config')

package/lib/commands/guide.js

@@ -0,0 +1,426 @@
+const chalk = require('chalk');
+const path = require('path');
+const fs = require('fs-extra');
+
+const TOOL_GUIDES = {
+  'windsurf': {
+    name: 'Codeium Windsurf',
+    files: [
+      { path: '.windsurfrules', desc: 'Legacy rules file (deprecated)' },
+      { path: '.windsurf/rules/*.md', desc: 'Modular rules (one per agent)' },
+      { path: '.windsurf/workflows/*.md', desc: 'Workflow definitions' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest (ANDF standard)' }
+    ],
+    setup: [
+      '1. Open your project in Windsurf IDE',
+      '2. Windsurf automatically detects .windsurfrules and .windsurf/ directory',
+      '3. Agent rules are loaded when you start a coding session',
+      '4. Use Cmd/Ctrl+L to open AI chat with agent context'
+    ],
+    usage: [
+      '• Start coding - agents automatically follow project rules',
+      '• Use @agents.md to reference the agent manifest',
+      '• Access workflows via Cmd/Ctrl+K → Select Workflow',
+      '• Agents adapt based on your workflow level (rapid/balanced/comprehensive)'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Rules not loading? Check .windsurf/rules/ contains .md files',
+      '• Restart Windsurf if rules don\'t update',
+      '• Check Output → Windsurf for any parsing errors'
+    ]
+  },
+
+  'cursor': {
+    name: 'Cursor AI IDE',
+    files: [
+      { path: '.cursor/rules', desc: 'Cursor rules file (symlink to AGENTS.md)' },
+      { path: '.cursorrules', desc: 'Deprecated - shows migration notice' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.context/', desc: 'Deep context (architecture, glossary)' }
+    ],
+    setup: [
+      '1. Open your project in Cursor',
+      '2. Cursor automatically reads .cursor/rules (which links to AGENTS.md)',
+      '3. Rules are active in all AI interactions (Cmd/Ctrl+K and Cmd/Ctrl+L)',
+      '4. No additional setup needed!'
+    ],
+    usage: [
+      '• Cmd/Ctrl+K - Inline code generation with agent context',
+      '• Cmd/Ctrl+L - Chat with AI using project rules',
+      '• Use @AGENTS.md to explicitly reference agent instructions',
+      '• Use @.context/memory/ for architecture details',
+      '• Tab to accept AI suggestions'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Rules not active? Check .cursor/rules exists',
+      '• Verify symlink: should point to ../AGENTS.md',
+      '• Restart Cursor if rules don\'t apply',
+      '• Check Settings → Features → Rules enabled'
+    ]
+  },
+
+  'vscode': {
+    name: 'Visual Studio Code (GitHub Copilot)',
+    files: [
+      { path: '.github/copilot-instructions.md', desc: 'GitHub Copilot custom instructions' },
+      { path: '.vscode/settings.json', desc: 'Custom chat participants and commands' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.context/', desc: 'Deep context directory' }
+    ],
+    setup: [
+      '1. Install GitHub Copilot extension in VS Code',
+      '2. Open your project - settings load automatically',
+      '3. Custom instructions are read by Copilot automatically',
+      '4. Restart VS Code to load custom chat modes'
+    ],
+    usage: [
+      '• Use @workspace to include project context in Copilot chat',
+      '• Copilot reads .github/copilot-instructions.md automatically',
+      '• Custom chat participants defined in settings.json:',
+      '  - @architect - Architecture discussions',
+      '  - @reviewer - Code review',
+      '  - @planner - Planning and estimation',
+      '• Inline suggestions follow your project\'s patterns'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Instructions not working? Check GitHub Copilot is active',
+      '• Verify .github/copilot-instructions.md exists',
+      '• Settings not loading? Reload VS Code window',
+      '• Check Copilot status in bottom-right status bar'
+    ]
+  },
+
+  'zed': {
+    name: 'Zed Editor',
+    files: [
+      { path: '.zed/settings.json', desc: 'Zed-specific settings with MCP config' },
+      { path: '.zed/keymap.json', desc: 'Agent switching shortcuts' },
+      { path: '.zed/rules', desc: 'Symlink to AGENTS.md' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.context/', desc: 'Deep context accessible via MCP' }
+    ],
+    setup: [
+      '1. Open your project in Zed',
+      '2. Zed reads .zed/settings.json automatically',
+      '3. MCP servers start automatically (project_context, archon)',
+      '4. Use keyboard shortcuts to switch agents (Ctrl+Shift+A)'
+    ],
+    usage: [
+      '• Ctrl+Shift+A - Switch active agent',
+      '• Ctrl+Enter - Quick agent action',
+      '• Ctrl+Shift+L - List available tools/workflows',
+      '• Agents access .context/ via MCP filesystem server',
+      '• Use /assistant to interact with current agent'
+    ],
+    mcpServers: [
+      {
+        name: 'project_context',
+        command: 'npx @modelcontextprotocol/server-filesystem .context',
+        desc: 'Provides read-only access to .context/ directory'
+      },
+      {
+        name: 'archon',
+        url: 'http://archon.ad.iservu.cc:8051/mcp',
+        desc: 'Internal API documentation and RAG (if available)'
+      }
+    ],
+    troubleshooting: [
+      '• Rules not loading? Check .zed/rules symlink exists',
+      '• MCP servers not starting? Check Node.js is installed',
+      '• Verify MCP config in .zed/settings.json',
+      '• Check Zed logs: View → Debug → Show Logs'
+    ]
+  },
+
+  'antigravity': {
+    name: 'Google Antigravity',
+    files: [
+      { path: '.antigravity/agents.yaml', desc: 'Antigravity agent configuration' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest (mounted in container)' },
+      { path: '.context/', desc: 'Deep context (architecture, glossary)' }
+    ],
+    setup: [
+      '1. Open your project in Antigravity',
+      '2. Antigravity reads .antigravity/agents.yaml',
+      '3. AGENTS.md is mounted read-only in agent filesystem',
+      '4. Agent automatically reads AGENTS.md on startup',
+      '5. No additional setup needed!'
+    ],
+    usage: [
+      '• Agent has access to AGENTS.md via file system mount',
+      '• .context/ directory accessible for architecture details',
+      '• Use conversational commands: "follow the dev agent workflow"',
+      '• Agent references AGENTS.md automatically for instructions',
+      '• Switch agent modes by referencing different roles in AGENTS.md'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Agent not following rules? Check .antigravity/agents.yaml exists',
+      '• Verify AGENTS.md file path in filesystem mount',
+      '• Check agent logs for AGENTS.md read confirmation',
+      '• Restart Antigravity session if config doesn\'t load'
+    ]
+  },
+
+  'claude-code': {
+    name: 'Claude Code CLI',
+    files: [
+      { path: '.framework/agents/*.md', desc: 'Agent definition files (analyst, pm, dev, qa, etc.)' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.context/', desc: 'Deep context directory' }
+    ],
+    setup: [
+      '1. Navigate to your project directory',
+      '2. Run: claude-code --agents .framework/agents/',
+      '3. Or configure in .claude/settings.json:',
+      '   {',
+      '     "agentsPath": ".framework/agents/"',
+      '   }',
+      '4. Claude Code loads agents automatically'
+    ],
+    usage: [
+      '• Start chat: claude-code',
+      '• Agents are available as slash commands:',
+      '  /dev - Switch to developer agent',
+      '  /pm - Switch to product manager agent',
+      '  /qa - Switch to QA engineer agent',
+      '• Reference AGENTS.md in chat: "read AGENTS.md"',
+      '• Access requirements: "show me .adf/sessions/*/outputs/"'
+    ],
+    mcpServers: [
+      {
+        name: 'filesystem',
+        desc: 'Can be configured to access project files',
+        command: 'Add to .claude/settings.json MCP servers config'
+      }
+    ],
+    troubleshooting: [
+      '• Agents not loading? Check .framework/agents/ contains .md files',
+      '• Verify agentsPath in .claude/settings.json',
+      '• Run: claude-code doctor to check configuration',
+      '• Check for agent file read permissions'
+    ]
+  },
+
+  'opencode': {
+    name: 'OpenCode CLI',
+    files: [
+      { path: '.opencode.json', desc: 'OpenCode project configuration' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.context/', desc: 'Deep context directory' }
+    ],
+    setup: [
+      '1. Navigate to your project directory',
+      '2. Run: opencode init (if not already initialized)',
+      '3. OpenCode reads .opencode.json automatically',
+      '4. MCP filesystem server starts automatically',
+      '5. Agents configured based on workflow level'
+    ],
+    usage: [
+      '• Start coding session: opencode',
+      '• Agents automatically have project context',
+      '• MCP provides access to all project files',
+      '• Use natural language for tasks:',
+      '  "Implement the login feature"',
+      '  "Review the authentication code"',
+      '  "Run tests and fix failures"'
+    ],
+    mcpServers: [
+      {
+        name: 'filesystem',
+        command: 'npx -y @modelcontextprotocol/server-filesystem',
+        desc: 'Provides full project file access'
+      }
+    ],
+    troubleshooting: [
+      '• Config not loading? Check .opencode.json syntax',
+      '• MCP errors? Ensure npx is available',
+      '• Verify Node.js version >= 18.0.0',
+      '• Run: opencode --version to check installation'
+    ]
+  },
+
+  'gemini-cli': {
+    name: 'Google Gemini CLI',
+    files: [
+      { path: 'GEMINI.md', desc: 'Project context and instructions for Gemini' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' },
+      { path: '.context/', desc: 'Deep context directory' }
+    ],
+    setup: [
+      '1. Install Gemini CLI: npm install -g @google/generative-ai-cli',
+      '2. Configure API key: export GOOGLE_API_KEY=your_key',
+      '3. Navigate to your project directory',
+      '4. Gemini CLI automatically detects GEMINI.md'
+    ],
+    usage: [
+      '• Start session: gemini-cli',
+      '• Gemini reads GEMINI.md automatically for context',
+      '• Reference project docs:',
+      '  "Read the requirements in .adf/sessions/"',
+      '  "Follow the workflow defined in GEMINI.md"',
+      '• Use for code generation, review, and planning',
+      '• Agent adapts based on your workflow level'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• GEMINI.md not detected? Check file exists in project root',
+      '• API key issues? Verify GOOGLE_API_KEY is set',
+      '• Check Gemini CLI version: gemini-cli --version',
+      '• Review GEMINI.md for correct formatting'
+    ]
+  },
+
+  'deepagent': {
+    name: 'Abacus.ai DeepAgent',
+    files: [
+      { path: '.deepagent/agents/*.md', desc: 'Agent markdown files' },
+      { path: '.deepagent/README.md', desc: 'Project overview and usage' },
+      { path: 'AGENTS.md', desc: 'Universal agent manifest' }
+    ],
+    setup: [
+      '1. Install DeepAgent: pip install deepagent',
+      '2. Navigate to your project directory',
+      '3. Run: deepagent init (loads .deepagent/ config)',
+      '4. Agents are loaded automatically'
+    ],
+    usage: [
+      '• Start session: deepagent',
+      '• Switch agents: deepagent --agent dev',
+      '• Agents read their .md files for instructions',
+      '• Use natural language for development tasks',
+      '• DeepAgent follows workflow level automatically'
+    ],
+    mcpServers: [],
+    troubleshooting: [
+      '• Agents not loading? Check .deepagent/agents/ directory',
+      '• Verify agent .md files are present',
+      '• Check DeepAgent version: deepagent --version',
+      '• Review .deepagent/README.md for setup info'
+    ]
+  }
+};
+
+async function guide(tool, options) {
+  const cwd = process.cwd();
+
+  // If no tool specified, show available guides
+  if (!tool) {
+    console.log(chalk.cyan.bold('\n📚 ADF Tool Setup Guides\n'));
+    console.log(chalk.gray('Get detailed setup and usage instructions for deployed tools.\n'));
+
+    console.log(chalk.yellow('Available Guides:'));
+    console.log('');
+
+    for (const [key, toolInfo] of Object.entries(TOOL_GUIDES)) {
+      console.log(chalk.green(`  adf guide ${key.padEnd(15)}`), chalk.gray(`- ${toolInfo.name}`));
+    }
+
+    console.log('');
+    console.log(chalk.cyan('Usage:'));
+    console.log(chalk.white('  adf guide <tool>'));
+    console.log('');
+    console.log(chalk.cyan('Examples:'));
+    console.log(chalk.gray('  $ adf guide windsurf'));
+    console.log(chalk.gray('  $ adf guide claude-code'));
+    console.log(chalk.gray('  $ adf guide gemini-cli'));
+    console.log('');
+
+    return;
+  }
+
+  // Get tool guide
+  const toolGuide = TOOL_GUIDES[tool];
+  if (!toolGuide) {
+    console.error(chalk.red(`\n❌ No guide available for "${tool}"`));
+    console.log(chalk.yellow('\nRun "adf guide" to see available guides.\n'));
+    process.exit(1);
+  }
+
+  // Display guide
+  console.log(chalk.cyan.bold(`\n📚 ${toolGuide.name} Setup Guide\n`));
+  console.log(chalk.gray('━'.repeat(60)) + '\n');
+
+  // Check what files exist
+  console.log(chalk.yellow.bold('📁 Generated Files:\n'));
+  for (const file of toolGuide.files) {
+    const exists = await checkFileExists(cwd, file.path);
+    const status = exists ? chalk.green('✓') : chalk.red('✗');
+    console.log(`  ${status} ${chalk.white(file.path)}`);
+    console.log(chalk.gray(`     ${file.desc}`));
+  }
+  console.log('');
+
+  // Setup instructions
+  console.log(chalk.yellow.bold('⚙️  Setup Instructions:\n'));
+  for (const step of toolGuide.setup) {
+    console.log(chalk.gray(`  ${step}`));
+  }
+  console.log('');
+
+  // MCP Servers (if applicable)
+  if (toolGuide.mcpServers && toolGuide.mcpServers.length > 0) {
+    console.log(chalk.yellow.bold('🔌 MCP Servers:\n'));
+    for (const server of toolGuide.mcpServers) {
+      console.log(chalk.cyan(`  • ${server.name}`));
+      console.log(chalk.gray(`    ${server.desc}`));
+      if (server.command) {
+        console.log(chalk.gray(`    Command: ${server.command}`));
+      }
+      if (server.url) {
+        console.log(chalk.gray(`    URL: ${server.url}`));
+      }
+      console.log('');
+    }
+  }
+
+  // Usage instructions
+  console.log(chalk.yellow.bold('🚀 Usage:\n'));
+  for (const instruction of toolGuide.usage) {
+    console.log(chalk.gray(`  ${instruction}`));
+  }
+  console.log('');
+
+  // Troubleshooting
+  console.log(chalk.yellow.bold('🔧 Troubleshooting:\n'));
+  for (const tip of toolGuide.troubleshooting) {
+    console.log(chalk.gray(`  ${tip}`));
+  }
+  console.log('');
+
+  // Quick reference
+  console.log(chalk.gray('━'.repeat(60)) + '\n');
+  console.log(chalk.cyan.bold('📖 Quick Reference:\n'));
+  console.log(chalk.gray(`  Requirements: .adf/sessions/*/outputs/`));
+  console.log(chalk.gray(`  Universal agent config: AGENTS.md`));
+  console.log(chalk.gray(`  Deep context: .context/memory/`));
+  console.log('');
+
+  console.log(chalk.cyan('Need more help?'));
+  console.log(chalk.gray('  • Documentation: https://github.com/iservu/adf-cli#readme'));
+  console.log(chalk.gray('  • Issues: https://github.com/iservu/adf-cli/issues'));
+  console.log('');
+}
+
+/**
+ * Check if file/pattern exists
+ */
+async function checkFileExists(cwd, filePath) {
+  // Handle glob patterns
+  if (filePath.includes('*')) {
+    const dir = path.dirname(filePath);
+    const dirPath = path.join(cwd, dir);
+    if (!await fs.pathExists(dirPath)) return false;
+
+    const files = await fs.readdir(dirPath);
+    return files.length > 0;
+  }
+
+  // Regular file
+  return await fs.pathExists(path.join(cwd, filePath));
+}
+
+module.exports = guide;

package/lib/generators/tool-config-generator.js

@@ -177,6 +177,116 @@ class ToolConfigGenerator {
     await fs.ensureDir(path.join(this.projectPath, dirPath));
   }
 
+  /**
+   * Get project context (name, commands, directories)
+   */
+  async getProjectContext() {
+    const context = {
+      name: this.getProjectName(),
+      overview: '',
+      buildCommand: 'npm run build',
+      testCommand: 'npm test',
+      lintCommand: 'npm run lint',
+      sourceDir: 'src/',
+      testDir: 'tests/',
+      docsDir: 'docs/'
+    };
+
+    // Try to extract overview from outputs
+    if (this.outputs.constitution) {
+      const overview = this.extractSection(this.outputs.constitution, 'overview');
+      if (overview) context.overview = overview;
+    } else if (this.outputs.prd) {
+      const overview = this.extractSection(this.outputs.prd, 'overview');
+      if (overview) context.overview = overview;
+    } else if (this.outputs.prp) {
+      const overview = this.extractSection(this.outputs.prp, 'overview');
+      if (overview) context.overview = overview;
+    }
+
+    // Try to read package.json for accurate commands
+    try {
+      const packageJsonPath = path.join(this.projectPath, 'package.json');
+      if (await fs.pathExists(packageJsonPath)) {
+        const packageJson = await fs.readJson(packageJsonPath);
+        if (packageJson.scripts) {
+          if (packageJson.scripts.build) context.buildCommand = 'npm run build';
+          if (packageJson.scripts.test) context.testCommand = 'npm test';
+          if (packageJson.scripts.lint) context.lintCommand = 'npm run lint';
+        }
+      }
+    } catch (error) {
+      // Ignore, use defaults
+    }
+
+    return context;
+  }
+
+  /**
+   * Get framework-specific context
+   */
+  async getFrameworkContext() {
+    const context = {
+      type: this.framework,
+      keyPoints: ''
+    };
+
+    // Extract key points from outputs
+    if (this.outputs.constitution) {
+      context.keyPoints = this.extractSection(this.outputs.constitution, 'key principles');
+    } else if (this.outputs.prd) {
+      context.keyPoints = this.extractSection(this.outputs.prd, 'key requirements');
+    }
+
+    return context;
+  }
+
+  /**
+   * Get summary of generated outputs
+   */
+  async getOutputSummary() {
+    const files = Object.keys(this.outputs);
+    if (files.length === 0) return null;
+
+    return `Generated outputs: ${files.map(f => `${f}.md`).join(', ')}`;
+  }
+
+  /**
+   * Deploy agent files to target directory
+   */
+  async deployAgentFiles(targetDir) {
+    const agentsList = this.getAgentsList();
+    const deployedFiles = [];
+
+    for (const agent of agentsList) {
+      const srcAgent = path.join(__dirname, '../templates/shared/agents', `${agent}.md`);
+      const destAgent = path.join(targetDir, `${agent}.md`);
+
+      if (await fs.pathExists(srcAgent)) {
+        await fs.copy(srcAgent, destAgent);
+        deployedFiles.push(destAgent);
+      }
+    }
+
+    return deployedFiles;
+  }
+
+  /**
+   * Get list of agents based on framework
+   */
+  getAgentsList() {
+    switch (this.framework) {
+      case 'rapid':
+        return ['dev', 'qa'];
+      case 'balanced':
+        return ['analyst', 'pm', 'dev', 'qa'];
+      case 'comprehensive':
+        return ['analyst', 'pm', 'architect', 'sm', 'dev', 'qa'];
+      default:
+        return ['dev', 'qa'];
+    }
+  }
+
   /**
    * Generate all configurations (override in subclasses)
    */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.12.10",
+  "version": "0.12.12",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework with multi-provider AI support",
   "main": "index.js",
   "bin": {