@iservu-inc/adf-cli 0.2.0 → 0.3.0

package/CHANGELOG.md

@@ -7,6 +7,183 @@ 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

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`));
     }