@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/CHANGELOG.md

@@ -7,6 +7,298 @@ and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0
 
 ## [Unreleased]
 
+## [0.3.0] - 2025-10-03
+
+### 🚀 MAJOR RELEASE: Tool Configuration Generators
+
+This release adds comprehensive tool configuration generation for all major AI coding environments. The ADF CLI now automatically generates optimized configurations for Windsurf, Cursor, VS Code, and the universal AGENTS.md standard.
+
+### Added
+
+**Universal Standard:**
+- **AGENTS.md Generator** - Universal AI agent configuration standard
+  - Works with OpenAI Codex, Cursor, Windsurf, Google Gemini/Jules, Factory
+  - Supported by 20,000+ open-source projects
+  - Automatically generated from framework outputs (PRP, Balanced, BMAD)
+  - Nested file support for monorepos
+
+**Windsurf (Codeium) Generator:**
+- `.windsurfrules` - Legacy format with 12,000 character limit compliance
+- `.windsurf/rules/` - Modern modular rules system
+  - `project-context.md` - Project overview and tech stack
+  - `architecture.md` - System architecture patterns
+  - `coding-standards.md` - Code style and best practices
+- `.windsurf/workflows/` - Cascade AI workflows
+  - `review-requirements.md` - Requirements review workflow
+  - `implement-feature.md` - Feature implementation workflow (Balanced/BMAD)
+
+**Cursor AI Generator:**
+- `.cursor/rules` - Modern primary configuration format
+- `.cursorrules` - Legacy deprecation notice with migration path
+- `.cursor/mcp.json` - Model Context Protocol support (optional, prepared for future)
+- Custom modes: architect, implementer, reviewer
+- Framework-specific context and instructions
+
+**VS Code Generator:**
+- `.github/copilot-instructions.md` - GitHub Copilot instructions
+- `.vscode/settings.json` - Custom chat modes
+  - Architect mode - Focus on system design
+  - Implementer mode - Feature implementation with TDD
+  - Reviewer mode - Code review against requirements
+- Preserves existing settings while adding chat modes
+- Language Model API integration ready
+
+**Base Architecture:**
+- `ToolConfigGenerator` - Base class with shared utilities
+  - Framework output loading (PRP, Balanced, BMAD)
+  - Section extraction and parsing
+  - Template variable substitution
+  - Project metadata detection
+
+**Integration:**
+- Enhanced `adf deploy` command to generate all configurations
+  - `adf deploy windsurf` - Generates Windsurf configs + AGENTS.md
+  - `adf deploy cursor` - Generates Cursor configs + AGENTS.md
+  - `adf deploy vscode` - Generates VS Code configs + AGENTS.md
+  - AGENTS.md always generated (universal standard)
+- Automatic session detection and framework identification
+- Error recovery with warning messages
+
+**Comprehensive Testing:**
+- 24 new unit tests for generators (57 total tests)
+- Test coverage maintained at 78%
+- Tests for all 3 frameworks (PRP, Balanced, BMAD)
+- Tests for all 3 tool generators
+- Template variable substitution tests
+- File preservation tests (VS Code settings)
+
+### New Files
+
+**Generators:**
+- `lib/generators/tool-config-generator.js` - Base class for all generators
+- `lib/generators/agents-md-generator.js` - Universal AGENTS.md standard
+- `lib/generators/windsurf-generator.js` - Windsurf configuration generator
+- `lib/generators/cursor-generator.js` - Cursor configuration generator
+- `lib/generators/vscode-generator.js` - VS Code configuration generator
+- `lib/generators/index.js` - Generator exports and unified API
+
+**Tests:**
+- `tests/agents-md-generator.test.js` - 5 tests for AGENTS.md
+- `tests/windsurf-generator.test.js` - 7 tests for Windsurf
+- `tests/cursor-generator.test.js` - 6 tests for Cursor
+- `tests/vscode-generator.test.js` - 6 tests for VS Code
+
+**Documentation:**
+- `.project/docs/tool-integrations/RESEARCH-FINDINGS.md` - 500+ line research document
+- `.project/docs/tool-integrations/IDE-CUSTOMIZATIONS.md` - Tool customization guide
+- `.project/chats/current/2025-10-03_AGENTS-MD-AND-TOOL-GENERATORS.md` - Session documentation
+
+### Changed
+
+**Deploy Command:**
+- Enhanced to call tool-specific generators based on selected tool
+- Added progress messages for each generation phase
+- Improved error handling with graceful fallbacks
+- Displays generated file counts and paths
+
+**Framework Support:**
+- All generators support PRP (Rapid) framework
+- All generators support Balanced framework
+- All generators support BMAD (Comprehensive) framework
+- Automatic framework detection from session metadata
+
+### Generated File Structure
+
+When running `adf deploy <tool>`, the following files are created:
+
+**Always Generated:**
+```
+AGENTS.md                                    # Universal standard
+```
+
+**Windsurf:**
+```
+.windsurfrules                               # Legacy format
+.windsurf/
+├── rules/
+│   ├── project-context.md
+│   ├── architecture.md
+│   └── coding-standards.md
+└── workflows/
+    ├── review-requirements.md
+    └── implement-feature.md                 # Balanced/BMAD only
+```
+
+**Cursor:**
+```
+.cursor/
+├── rules                                    # Primary config
+└── mcp.json                                 # Optional (prepared)
+.cursorrules                                 # Deprecation notice
+```
+
+**VS Code:**
+```
+.github/
+└── copilot-instructions.md                  # GitHub Copilot
+.vscode/
+└── settings.json                            # Custom chat modes
+```
+
+### Technical Details
+
+**Template Variables:**
+- `PROJECT_NAME` - Project name from metadata
+- `SESSION_ID` - Unique session identifier
+- `FRAMEWORK` - rapid/balanced/comprehensive
+- Framework-specific variables (PRP_GOAL, CONSTITUTION_PRINCIPLES, PRD_OVERVIEW, etc.)
+- Automatic tech stack extraction
+- Code style and testing approach detection
+
+**Character Limits:**
+- Windsurf rules: 12,000 characters per file (enforced via file splitting)
+- Other tools: No enforced limits
+
+**Context Awareness:**
+- Architect mode: References architecture and specification
+- Implementer mode: References implementation details and tasks
+- Reviewer mode: References constitution and quality standards
+- All modes: Full access to framework outputs via file paths
+
+### Breaking Changes
+
+None - fully backward compatible with v0.2.x
+
+### Migration Guide
+
+Existing projects can immediately benefit from the new generators:
+
+1. Run `adf deploy <tool>` in your project directory
+2. Configurations will be generated from existing `.adf/sessions/` data
+3. All tools will recognize and use the new configurations
+4. No manual migration needed
+
+### Next Steps
+
+- **Phase 3**: Enhanced MCP integration for all tools
+- **Phase 4**: Live project monitoring and real-time updates
+- **Phase 5**: Multi-framework project support
+
+## [0.2.0] - 2025-10-03
+
+### 🚀 MAJOR RELEASE: Quality-Based Progress Tracking & Resume Capability
+
+This is a **paradigm shift** in how ADF CLI measures progress. Instead of counting questions, we now measure **information richness** - recognizing that 3 thorough answers can be worth more than 20 shallow ones.
+
+### Added
+
+**Quality-Based Progress System:**
+- Information Richness Score (0-100%) - weighted metric combining completion and quality
+- Real-time answer quality analysis with 0-100 scoring
+- Quality metrics tracking: word count, keywords, required elements, detail level, technical depth
+- Automatic follow-up question skipping for high-quality answers (score >= 85)
+- Quality feedback displayed to users after each answer
+
+**Resume Capability:**
+- Full session save/quit/resume from exact point of interruption
+- Session Manager to detect and list resumable sessions
+- User prompted to resume or start new on `adf init`
+- All context preserved: answers, transcript, quality metrics, current block
+
+**Triple-Redundant Auto-Save:**
+- Main progress file: `_progress.json`
+- Backup file: `_progress.backup.json`
+- Append-only log: `_progress-log.md`
+- Emergency fallback: `_emergency-{timestamp}.json` (if all else fails)
+- Auto-save after every answer, block completion, and state change
+
+**Comprehensive Testing:**
+- 33 unit tests with 78% code coverage
+- Test coverage: 78% statements, 63% branches, 77% functions, 79% lines
+- Tests for quality analyzer, progress tracker, session manager
+- Emergency recovery scenarios tested
+
+**Project Documentation:**
+- Complete `.project/` documentation structure
+- Chat history tracking (current and completed)
+- Architecture documentation (system design, data flow)
+- Framework methodologies documentation
+- Tool integrations specification
+- Project vision and goals
+
+### New Files
+
+- `lib/frameworks/answer-quality-analyzer.js` - Comprehensive quality scoring engine
+- `lib/frameworks/progress-tracker.js` - Real-time progress with quality metrics
+- `lib/frameworks/session-manager.js` - Session listing and resume prompts
+- `tests/answer-quality-analyzer.test.js` - 16 unit tests
+- `tests/progress-tracker.test.js` - 12 unit tests
+- `tests/session-manager.test.js` - 5 unit tests
+- `jest.config.js` - Jest testing configuration
+- `.project/chats/` - Chat history tracking
+- `.project/docs/` - Complete project documentation
+
+### Changed
+
+**Interviewer Engine:**
+- Integrated quality analyzer - evaluates every answer
+- Auto-save after each answer with quality metrics
+- Block start/complete/skip tracking
+- Quality feedback display to users
+- Smart follow-up skipping based on quality
+
+**Init Command:**
+- Session resume detection on startup
+- Prompts user to resume or start new
+- Framework parameter tracking for resume
+
+**Progress Display:**
+- Old: `"3/20 questions (15%)"`
+- New: `"📊 Information Richness: ✨ 75% | Avg Quality: 82%"`
+- Shows blocks, questions, words, and quality metrics
+- Emoji indicators for richness levels (🌟 ✨ 💫 ⭐)
+
+### Quality Scoring System
+
+**Metrics (0-100 total):**
+- Word count: up to 30 points (50+ words = max)
+- Keyword presence: up to 20 points
+- Required elements: up to 25 points (platform, tech, user interaction, etc.)
+- Detail level: up to 15 points (bullets, examples, multiple sentences)
+- Technical depth: up to 10 points (tech stack, versions, tools)
+
+**Thresholds:**
+- Score >= 70: Comprehensive answer
+- Score >= 85: Can skip follow-up questions
+
+**Information Richness Formula:**
+```
+informationRichness = (completionFactor * 0.4) + (qualityFactor * 0.6) * 100
+```
+Weighted 60% toward quality, 40% toward completion.
+
+### Breaking Changes
+
+None - fully backward compatible with v0.1.x
+
+### Technical Debt Addressed
+
+- Bulletproof data persistence (zero data loss)
+- Comprehensive error recovery
+- Test coverage for core components
+- Project documentation structure
+
+### Next Steps
+
+- **Option B (Phase 2)**: IDE Tool Integrations
+  - Windsurf customizations (.windsurfrules, memories, workflows)
+  - Cursor customizations (.cursorrules, modes, MCP, hooks)
+  - VS Code customizations (copilot-instructions, chat modes, tools API)
+
+### Migration Guide
+
+No migration needed. Existing sessions from v0.1.x will continue to work. New features will be available for new sessions created with v0.2.0.
+
 ## [0.1.6] - 2025-10-02
 
 ### Fixed

package/jest.config.js

@@ -0,0 +1,20 @@
+module.exports = {
+  testEnvironment: 'node',
+  testMatch: ['**/tests/**/*.test.js'],
+  collectCoverageFrom: [
+    'lib/frameworks/answer-quality-analyzer.js',
+    'lib/frameworks/progress-tracker.js',
+    'lib/frameworks/session-manager.js',
+    '!lib/**/*.test.js',
+    '!**/node_modules/**'
+  ],
+  coverageThreshold: {
+    global: {
+      branches: 60,
+      functions: 70,
+      lines: 70,
+      statements: 70
+    }
+  },
+  testTimeout: 10000
+};

package/lib/commands/deploy.js

@@ -2,6 +2,12 @@ const fs = require('fs-extra');
 const path = require('path');
 const chalk = require('chalk');
 const ora = require('ora');
+const {
+  generateAgentsMd,
+  generateWindsurf,
+  generateCursor,
+  generateVSCode
+} = require('../generators');
 
 const TOOLS = {
   windsurf: { name: 'Windsurf', configFile: '.windsurfrules' },
@@ -15,6 +21,60 @@ const TOOLS = {
   'codex-cli': { name: 'Codex CLI', configFile: '.codex/config.json' }
 };
 
+/**
+ * Find the latest completed session
+ */
+async function findLatestSession(cwd) {
+  const sessionsDir = path.join(cwd, '.adf', 'sessions');
+
+  if (!await fs.pathExists(sessionsDir)) {
+    return null;
+  }
+
+  const sessions = await fs.readdir(sessionsDir);
+  if (sessions.length === 0) {
+    return null;
+  }
+
+  // Find most recent session with outputs
+  let latestSession = null;
+  let latestTime = 0;
+
+  for (const sessionId of sessions) {
+    const sessionPath = path.join(sessionsDir, sessionId);
+    const outputsPath = path.join(sessionPath, 'outputs');
+
+    if (await fs.pathExists(outputsPath)) {
+      const stats = await fs.stat(sessionPath);
+      if (stats.mtimeMs > latestTime) {
+        latestTime = stats.mtimeMs;
+        latestSession = sessionPath;
+      }
+    }
+  }
+
+  return latestSession;
+}
+
+/**
+ * Get framework type from session metadata
+ */
+async function getFrameworkFromSession(sessionPath) {
+  const metadataPath = path.join(sessionPath, '_metadata.json');
+  if (await fs.pathExists(metadataPath)) {
+    const metadata = await fs.readJson(metadataPath);
+    return metadata.framework;
+  }
+
+  const progressPath = path.join(sessionPath, '_progress.json');
+  if (await fs.pathExists(progressPath)) {
+    const progress = await fs.readJson(progressPath);
+    return progress.framework;
+  }
+
+  return 'balanced'; // Default fallback
+}
+
 async function deployToTool(tool, options = {}) {
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
@@ -26,22 +86,80 @@ async function deployToTool(tool, options = {}) {
     process.exit(1);
   }
 
-  // Read context to get workflow
+  // Find latest session
+  const sessionPath = await findLatestSession(cwd);
+  if (!sessionPath) {
+    console.error(chalk.red('\n❌ Error: No completed sessions found.'));
+    console.log(chalk.yellow('Run "adf init" to create requirements first.\n'));
+    process.exit(1);
+  }
+
+  const framework = await getFrameworkFromSession(sessionPath);
+
+  // Read context to get workflow (legacy support)
   const contextPath = path.join(adfDir, 'context.json');
   let context = {};
   if (await fs.pathExists(contextPath)) {
     context = await fs.readJson(contextPath);
   }
 
-  const workflow = context.workflow || 'balanced';
+  const workflow = framework || context.workflow || 'balanced';
 
-  // Deploy logic (simplified - will be implemented based on actual deploy script)
   const spinner = options.silent ? null : ora(`Deploying to ${TOOLS[tool]?.name || tool}...`).start();
 
   try {
+    // Generate AGENTS.md (universal standard)
+    if (!options.silent) {
+      if (spinner) spinner.text = 'Generating AGENTS.md...';
+    }
+
+    try {
+      await generateAgentsMd(sessionPath, cwd, framework);
+      if (!options.silent && !spinner) {
+        console.log(chalk.green('✓ Generated AGENTS.md'));
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate AGENTS.md: ${error.message}`));
+    }
+
+    // Generate tool-specific configurations
+    if (spinner) spinner.text = `Generating ${TOOLS[tool]?.name || tool} configurations...`;
+
+    try {
+      let generatedFiles = {};
+
+      if (tool === 'windsurf') {
+        generatedFiles = await generateWindsurf(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Windsurf configurations'));
+          console.log(chalk.gray(`  - .windsurfrules (legacy)`));
+          console.log(chalk.gray(`  - .windsurf/rules/*.md (${generatedFiles.rules?.length || 0} files)`));
+          console.log(chalk.gray(`  - .windsurf/workflows/*.md (${generatedFiles.workflows?.length || 0} files)`));
+        }
+      } else if (tool === 'cursor') {
+        generatedFiles = await generateCursor(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated Cursor configurations'));
+          console.log(chalk.gray(`  - .cursor/rules`));
+          console.log(chalk.gray(`  - .cursorrules (deprecation notice)`));
+        }
+      } else if (tool === 'vscode' || tool === 'vscode-insider') {
+        generatedFiles = await generateVSCode(sessionPath, cwd, framework);
+        if (!options.silent && !spinner) {
+          console.log(chalk.green('✓ Generated VS Code configurations'));
+          console.log(chalk.gray(`  - .github/copilot-instructions.md`));
+          console.log(chalk.gray(`  - .vscode/settings.json (custom chat modes)`));
+        }
+      }
+    } catch (error) {
+      console.warn(chalk.yellow(`\n⚠️  Warning: Could not generate ${TOOLS[tool]?.name || tool} configurations: ${error.message}`));
+    }
+
     // Get agents based on workflow
     const agentsList = getAgentsForWorkflow(workflow);
 
+    if (spinner) spinner.text = `Deploying to ${TOOLS[tool]?.name || tool}...`;
+
     // Copy agents
     const agentsDir = path.join(cwd, '.framework', 'agents');
     await fs.ensureDir(agentsDir);
@@ -82,6 +200,7 @@ async function deployToTool(tool, options = {}) {
     }
 
     if (!options.silent) {
+      console.log(chalk.gray(`  Generated: AGENTS.md (universal AI agent config)`));
       console.log(chalk.gray(`  Agents: ${agentsList.join(', ')}`));
       console.log(chalk.gray(`  Config: ${toolConfig?.configFile || 'N/A'}\n`));
     }

package/lib/commands/init.js

@@ -5,18 +5,33 @@ const chalk = require('chalk');
 const ora = require('ora');
 const {
   detectProjectType,
-  getWorkflowRecommendation,
-  generateContextFile
+  getWorkflowRecommendation
 } = require('../utils/project-detector');
-const { copyTemplates } = require('../utils/copy-templates');
+const Interviewer = require('../frameworks/interviewer');
+const SessionManager = require('../frameworks/session-manager');
 const { deployToTool } = require('./deploy');
 
 async function init(options) {
-  console.log(chalk.cyan.bold('\n🚀 AgentDevFramework Initialization\n'));
+  console.log(chalk.cyan.bold('\n🚀 AgentDevFramework - Software Development Requirements\n'));
 
   const cwd = process.cwd();
   const adfDir = path.join(cwd, '.adf');
 
+  // Check for resumable sessions FIRST (before asking to overwrite)
+  const sessionManager = new SessionManager(cwd);
+  const existingSession = await sessionManager.promptToResume();
+
+  if (existingSession) {
+    // Resume existing session
+    const interviewer = new Interviewer(existingSession.progress.framework || 'balanced', cwd, existingSession);
+    const sessionPath = await interviewer.start();
+
+    console.log(chalk.green.bold('\n✨ Requirements gathering complete!\n'));
+    console.log(chalk.cyan(`📁 Session saved to: ${sessionPath}\n`));
+
+    return;
+  }
+
   // Check if already initialized
   if (await fs.pathExists(adfDir)) {
     const { overwrite } = await inquirer.prompt([
@@ -41,132 +56,59 @@ async function init(options) {
   const projectType = await detectProjectType(cwd);
   spinner.succeed(`Project type: ${chalk.green(projectType.type)}`);
 
-  // Determine workflow
+  // Determine workflow/framework
   let workflow;
 
   if (options.rapid) {
     workflow = 'rapid';
-    console.log(chalk.blue('Using Level 1 (Rapid Development) - from --rapid flag'));
+    console.log(chalk.blue('\nUsing: PRP Framework (Rapid Development) - from --rapid flag'));
   } else if (options.balanced) {
     workflow = 'balanced';
-    console.log(chalk.blue('Using Level 2 (Balanced) - from --balanced flag'));
+    console.log(chalk.blue('\nUsing: PRP + Spec-Kit (Balanced) - from --balanced flag'));
   } else if (options.comprehensive) {
     workflow = 'comprehensive';
-    console.log(chalk.blue('Using Level 3 (Comprehensive) - from --comprehensive flag'));
+    console.log(chalk.blue('\nUsing: BMAD Framework (Comprehensive) - from --comprehensive flag'));
   } else {
     // Interactive workflow selection
     workflow = await getWorkflowRecommendation(projectType);
   }
 
-  // Gather documentation URLs (optional)
-  const { hasDocs } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'hasDocs',
-      message: 'Do you have documentation URLs to include?',
-      default: false
-    }
-  ]);
-
-  let documentationUrls = [];
-  if (hasDocs) {
-    const { urls } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'urls',
-        message: 'Enter documentation URLs (comma-separated):',
-        filter: (input) => input.split(',').map(url => url.trim()).filter(Boolean)
-      }
-    ]);
-    documentationUrls = urls;
-  }
-
-  // Gather local documentation files (optional)
-  const { hasLocalDocs } = await inquirer.prompt([
-    {
-      type: 'confirm',
-      name: 'hasLocalDocs',
-      message: 'Do you have local documentation files to include? (use "." as the project root folder & add like so "./docs/")',
-      default: false
-    }
-  ]);
+  // Create .adf directory
+  await fs.ensureDir(adfDir);
 
-  let documentationFiles = [];
-  if (hasLocalDocs) {
-    const { files } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'files',
-        message: 'Enter local documentation paths (comma-separated, e.g., ./docs/, ./README.md):',
-        filter: (input) => input.split(',').map(file => file.trim()).filter(Boolean)
-      }
-    ]);
-    documentationFiles = files;
-  }
+  // Start AI-guided interview
+  console.log(chalk.gray('\n' + '━'.repeat(60)) + '\n');
 
-  // Copy framework templates
-  const copySpinner = ora('Copying framework files...').start();
-  await copyTemplates(cwd);
-  copySpinner.succeed('Framework files copied to .adf/');
-
-  // Generate context file
-  const context = generateContextFile({
-    workflow,
-    projectType: projectType.type,
-    documentationUrls,
-    documentationFiles,
-    timestamp: new Date().toISOString()
-  });
-
-  await fs.writeJson(path.join(adfDir, 'context.json'), context, { spaces: 2 });
-  console.log(chalk.green('✓ Created .adf/context.json'));
-
-  // Copy .env.template to project root
-  const envTemplateSrc = path.join(__dirname, '../templates/.env.template');
-  const envTemplateDest = path.join(cwd, '.env.template');
-
-  if (await fs.pathExists(envTemplateSrc)) {
-    await fs.copy(envTemplateSrc, envTemplateDest);
-    console.log(chalk.green('✓ Created .env.template'));
-  }
+  const interviewer = new Interviewer(workflow, cwd);
+  const sessionPath = await interviewer.start();
 
-  // Deploy to tool if specified
-  let deployNow = false;
+  // Show next steps
+  console.log(chalk.cyan('📋 Next Steps:\n'));
+  console.log(chalk.gray(`  1. Review your requirements: ${sessionPath}/outputs/`));
+  console.log(chalk.gray(`  2. Share the output files with your AI coding assistant`));
+  console.log(chalk.gray(`  3. Start building based on the detailed requirements\n`));
 
+  // Optional: Deploy to tool
   if (options.tool) {
     console.log('');
     await deployToTool(options.tool, { silent: false });
-    deployNow = true;
   } else {
-    // Ask if they want to deploy now
-    const response = await inquirer.prompt([
+    const { deployNow } = await inquirer.prompt([
       {
         type: 'confirm',
         name: 'deployNow',
-        message: 'Deploy to a development tool now?',
-        default: true
+        message: 'Deploy framework to a development tool?',
+        default: false
       }
     ]);
 
-    deployNow = response.deployNow;
-
     if (deployNow) {
       const { tool } = await inquirer.prompt([
         {
           type: 'list',
           name: 'tool',
-          message: 'Select deployment tool:',
-          choices: [
-            'windsurf',
-            'cursor',
-            'vscode',
-            'vscode-insider',
-            'kiro',
-            'trae',
-            'claude-code',
-            'gemini-cli',
-            'codex-cli'
-          ]
+          message: 'Select tool:',
+          choices: ['windsurf', 'cursor', 'vscode', 'claude-code', 'gemini-cli']
         }
       ]);
 
@@ -175,21 +117,7 @@ async function init(options) {
     }
   }
 
-  // Success message
-  console.log(chalk.green.bold('\n✨ Initialization complete!\n'));
-
-  console.log(chalk.cyan('Next steps:'));
-  console.log(chalk.gray('  1. Review .adf/context.json'));
-  console.log(chalk.gray('  2. Copy .env.template to .env and configure'));
-  if (!deployNow) {
-    console.log(chalk.gray('  3. Run "adf deploy <tool>" to deploy to your editor'));
-    console.log(chalk.gray('  4. Check documentation: .adf/shared/templates/\n'));
-  } else {
-    console.log(chalk.gray('  3. Check documentation: .adf/shared/templates/\n'));
-  }
-
-  console.log(chalk.blue(`Workflow: ${workflow === 'rapid' ? 'Level 1 (Rapid)' : workflow === 'balanced' ? 'Level 2 (Balanced)' : 'Level 3 (Comprehensive)'}`));
-  console.log(chalk.gray('Run "adf deploy --list" to see available tools\n'));
+  console.log(chalk.green.bold('\n✅ All done! Happy coding! 🚀\n'));
 }
 
 module.exports = init;