@iservu-inc/adf-cli 0.2.0 → 0.3.0

package/.project/chats/current/2025-10-03_AGENTS-MD-AND-TOOL-GENERATORS.md

@@ -0,0 +1,699 @@
+# ADF CLI - AGENTS.md and Tool Generators Implementation
+
+**Date:** 2025-10-03
+**Status:** In Progress - Building Tool-Specific Generators
+**Phase:** Option B - Tool Integrations (Phase 2A → 2B)
+
+---
+
+## Session Summary
+
+### What We've Accomplished
+
+**Phase 1 (Complete):**
+- ✅ Quality-based progress tracking
+- ✅ Triple-redundant auto-save
+- ✅ Resume capability
+- ✅ Answer quality analyzer
+- ✅ Session manager
+- ✅ 33 unit tests (78% coverage)
+- ✅ Published v0.2.0 to npm
+
+**Phase 2A (Complete):**
+- ✅ Research: AGENTS.md, Windsurf, Cursor, VS Code
+- ✅ Base ToolConfigGenerator class
+- ✅ AGENTS.md generator (PRP, Balanced, BMAD)
+- ✅ Integration into deploy command
+- ✅ 5 new tests for generators
+- ✅ Comprehensive research documentation
+
+**Phase 2B (Current):**
+- 🔄 Building Windsurf generator
+- 🔄 Building Cursor generator
+- 🔄 Building VS Code generator
+- ⏳ Testing all generators
+- ⏳ Version 0.3.0 release
+
+---
+
+## Project Structure
+
+```
+adf-cli/
+├── lib/
+│   ├── commands/
+│   │   ├── init.js              # Interview system
+│   │   ├── deploy.js            # Deploy + generate configs
+│   │   └── update.js
+│   ├── frameworks/
+│   │   ├── interviewer.js       # AI-driven interview
+│   │   ├── progress-tracker.js  # Quality-based progress
+│   │   ├── answer-quality-analyzer.js
+│   │   ├── session-manager.js   # Resume capability
+│   │   ├── questions.js         # Question database
+│   │   └── output-generators.js # PRP/Balanced/BMAD outputs
+│   └── generators/              # NEW: Tool config generators
+│       ├── tool-config-generator.js      # Base class
+│       ├── agents-md-generator.js        # ✅ AGENTS.md (universal)
+│       ├── windsurf-generator.js         # 🔄 In progress
+│       ├── cursor-generator.js           # 🔄 In progress
+│       ├── vscode-generator.js           # 🔄 In progress
+│       └── index.js
+├── tests/
+│   ├── answer-quality-analyzer.test.js   # 16 tests
+│   ├── progress-tracker.test.js          # 12 tests
+│   ├── session-manager.test.js           # 5 tests
+│   └── agents-md-generator.test.js       # 5 tests
+└── .project/
+    ├── chats/
+    │   ├── current/                      # This file
+    │   └── complete/                     # Archived chats
+    └── docs/
+        ├── goals/PROJECT-VISION.md
+        ├── architecture/SYSTEM-DESIGN.md
+        ├── frameworks/FRAMEWORK-METHODOLOGIES.md
+        └── tool-integrations/
+            ├── IDE-CUSTOMIZATIONS.md
+            └── RESEARCH-FINDINGS.md      # 500+ line spec
+```
+
+---
+
+## AGENTS.md Generator (Completed)
+
+### What It Does
+
+Generates **AGENTS.md** - the universal open standard for AI coding agent instructions.
+
+**Supported by:**
+- OpenAI Codex/Copilot
+- Google Gemini/Jules
+- Cursor
+- Windsurf
+- Factory
+- 20,000+ open-source projects
+
+### Implementation
+
+**Base Class:** `tool-config-generator.js`
+- Loads framework outputs
+- Parses markdown sections
+- Template variable substitution
+- File operations
+
+**Generator:** `agents-md-generator.js`
+- `generateFromPRP()` - PRP framework
+- `generateFromBalanced()` - Balanced framework
+- `generateFromBMAD()` - BMAD framework
+
+**Output Structure:**
+```markdown
+# Project Name
+
+## Overview
+[From framework outputs]
+
+## Tech Stack
+[Detected from outputs]
+
+## Build Commands
+npm install
+npm run build
+
+## Test Commands
+npm test
+
+## Implementation Blueprint
+[PRP: blueprint section]
+[Balanced: technical plan]
+[BMAD: architecture]
+
+## Success Criteria
+[Validation requirements]
+
+## Development Workflow
+1. Review requirements
+2. Check implementation blueprint
+3. Write tests first
+4. Implement following blueprint
+5. Verify against criteria
+
+## Key Context
+- Framework outputs: .adf/sessions/{session}/outputs/
+- Q&A responses: .adf/sessions/{session}/qa-responses/
+
+## AI Agent Instructions
+[Framework-specific guidance]
+```
+
+### Integration with Deploy Command
+
+**Enhanced deploy.js:**
+```javascript
+// Find latest session
+const sessionPath = await findLatestSession(cwd);
+
+// Get framework type
+const framework = await getFrameworkFromSession(sessionPath);
+
+// Generate AGENTS.md automatically
+await generateAgentsMd(sessionPath, cwd, framework);
+
+// Then deploy tool-specific configs
+```
+
+---
+
+## Tool Generators To Build
+
+### 1. Windsurf Generator
+
+**Files to Generate:**
+
+**`.windsurfrules`** (Legacy compatibility)
+```markdown
+# {PROJECT_NAME}
+
+## Context
+{GOAL or OVERVIEW}
+
+## Tech Stack
+{TECH_STACK}
+
+## Core Principles
+{CONSTITUTION_PRINCIPLES}
+
+## Architecture
+{ARCHITECTURE_SUMMARY}
+
+## Code Standards
+{CODE_STYLE}
+```
+
+**`.windsurf/rules/project-context.md`** (Modern)
+```markdown
+# Project Context
+
+## Goal
+{PRP_GOAL or PRD_OVERVIEW}
+
+## Tech Stack
+{TECH_STACK}
+
+## Key Principles
+{CONSTITUTION_PRINCIPLES}
+```
+
+**`.windsurf/rules/architecture.md`**
+```markdown
+# Architecture
+
+{ARCHITECTURE_CONTENT}
+
+Reference: .adf/sessions/{SESSION}/outputs/architecture.md
+```
+
+**`.windsurf/rules/coding-standards.md`**
+```markdown
+# Coding Standards
+
+{CODE_STYLE from Technical Plan}
+
+## Patterns to Use
+{RECOMMENDED_PATTERNS}
+
+## Patterns to Avoid
+{ANTI_PATTERNS}
+```
+
+**`.windsurf/workflows/implement-story.md`**
+```markdown
+# Implement Story Workflow
+
+1. Review story in stories.md
+2. Check architecture for component location
+3. Follow code standards
+4. Write tests first
+5. Implement feature
+6. Verify against acceptance criteria
+```
+
+**`.windsurf/workflows/review-requirements.md`**
+```markdown
+# Review Requirements Workflow
+
+1. Load PRD: .adf/sessions/{SESSION}/outputs/prd.md
+2. Check user stories
+3. Verify against current implementation
+4. Identify gaps
+```
+
+**Character Limits:** 12,000 per file
+**Activation:** Manual (@mention), Model Decision, Always On, File Glob
+
+### 2. Cursor Generator
+
+**Files to Generate:**
+
+**`.cursor/rules`** (Primary)
+```markdown
+# {PROJECT_NAME} - Cursor Rules
+
+## Project Context
+{PRP_GOAL or PRD_OVERVIEW}
+
+## Technical Stack
+{TECH_STACK}
+
+## Core Principles
+{CONSTITUTION_PRINCIPLES}
+
+## Architecture
+Reference: .adf/sessions/{SESSION}/outputs/architecture.md
+
+{ARCHITECTURE_SUMMARY}
+
+## Coding Standards
+{CODE_STYLE}
+
+## Before Writing Code
+1. Review PRD: .adf/sessions/{SESSION}/outputs/prd.md
+2. Check architecture patterns
+3. Verify constraints
+
+## Forbidden
+{CONSTITUTION_NON_NEGOTIABLES}
+
+## Reference Documents
+- PRD: .adf/sessions/{SESSION}/outputs/prd.md
+- Architecture: .adf/sessions/{SESSION}/outputs/architecture.md
+- Constitution: .adf/sessions/{SESSION}/outputs/constitution.md
+```
+
+**`.cursor/mcp.json`** (Optional - MCP servers)
+```json
+{
+  "mcpServers": {
+    "requirement-checker": {
+      "command": "node",
+      "args": ["./tools/requirement-checker.js"],
+      "env": {
+        "PRD_PATH": ".adf/sessions/{SESSION}/outputs/prd.md"
+      }
+    }
+  }
+}
+```
+
+**Legacy Support:**
+- Create `.cursorrules` with deprecation notice
+- Point to `.cursor/rules`
+
+### 3. VS Code Generator
+
+**Files to Generate:**
+
+**`.github/copilot-instructions.md`** (GitHub Copilot)
+```markdown
+# Copilot Instructions for {PROJECT_NAME}
+
+## Project Context
+{PRP_GOAL or PRD_OVERVIEW}
+
+## Tech Stack
+{TECH_STACK}
+
+## Architecture
+{ARCHITECTURE_SUMMARY}
+
+See full architecture: .adf/sessions/{SESSION}/outputs/architecture.md
+
+## Code Standards
+{CODE_STYLE}
+
+## Patterns to Use
+{RECOMMENDED_PATTERNS}
+
+## Patterns to Avoid
+{ANTI_PATTERNS}
+
+## Testing Requirements
+{TESTING_APPROACH}
+
+## Security Requirements
+{SECURITY_NOTES}
+
+## When Generating Code
+1. Review requirements: .adf/sessions/{SESSION}/outputs/
+2. Follow architecture patterns
+3. Include error handling
+4. Add type definitions
+5. Write tests
+
+## Reference Documents
+- PRD: .adf/sessions/{SESSION}/outputs/prd.md
+- Architecture: .adf/sessions/{SESSION}/outputs/architecture.md
+- Constitution: .adf/sessions/{SESSION}/outputs/constitution.md
+```
+
+**`.vscode/settings.json`** (Enhancement)
+```json
+{
+  "github.copilot.chat.modes": {
+    "architect": {
+      "instructions": "Focus on system design. Reference architecture.md",
+      "context": [".adf/sessions/{SESSION}/outputs/architecture.md"]
+    },
+    "implementer": {
+      "instructions": "Implement per PRD. Write tests first.",
+      "context": [
+        ".adf/sessions/{SESSION}/outputs/prd.md",
+        ".adf/sessions/{SESSION}/outputs/specification.md"
+      ]
+    },
+    "reviewer": {
+      "instructions": "Review against requirements and best practices.",
+      "context": [".adf/sessions/{SESSION}/outputs/constitution.md"]
+    }
+  }
+}
+```
+
+---
+
+## Template Variables System
+
+All generators use these variables:
+
+```javascript
+{
+  PROJECT_NAME,           // From metadata or directory
+  SESSION_ID,            // Session identifier
+  FRAMEWORK,             // rapid/balanced/comprehensive
+
+  // PRP
+  PRP_GOAL,
+  PRP_CONTEXT,
+  PRP_TECH_STACK,
+  PRP_IMPLEMENTATION,
+  PRP_VALIDATION,
+
+  // Balanced
+  CONSTITUTION_PRINCIPLES,
+  CONSTITUTION_CONSTRAINTS,
+  SPECIFICATION_OVERVIEW,
+  SPECIFICATION_ARCHITECTURE,
+  PLAN_TECH_STACK,
+  PLAN_CODE_STYLE,
+  TASKS_BREAKDOWN,
+
+  // BMAD
+  PRD_OVERVIEW,
+  PRD_GOALS,
+  PRD_TECH_REQUIREMENTS,
+  ARCHITECTURE_OVERVIEW,
+  ARCHITECTURE_COMPONENTS,
+  STORIES_LIST,
+
+  // Common
+  TECH_STACK,
+  CODE_STYLE,
+  TESTING_APPROACH,
+  SECURITY_NOTES,
+  RECOMMENDED_PATTERNS,
+  ANTI_PATTERNS
+}
+```
+
+---
+
+## Generator Architecture
+
+```javascript
+class ToolConfigGenerator {
+  constructor(sessionPath, projectPath, framework) {
+    this.sessionPath = sessionPath;
+    this.projectPath = projectPath;
+    this.framework = framework;
+  }
+
+  async initialize() {
+    // Load framework outputs
+    await this.loadFrameworkOutputs();
+  }
+
+  async generate() {
+    // Override in subclass
+  }
+
+  // Utilities
+  replaceVariables(template, variables)
+  extractSection(content, sectionName)
+  writeToProject(fileName, content)
+  ensureDir(dirPath)
+}
+
+class WindsurfGenerator extends ToolConfigGenerator {
+  async generate() {
+    await this.initialize();
+
+    // Generate .windsurfrules
+    await this.generateLegacyRules();
+
+    // Generate .windsurf/rules/*.md
+    await this.generateModernRules();
+
+    // Generate .windsurf/workflows/*.md
+    await this.generateWorkflows();
+
+    return {
+      legacy: ['.windsurfrules'],
+      rules: ['.windsurf/rules/...'],
+      workflows: ['.windsurf/workflows/...']
+    };
+  }
+}
+
+class CursorGenerator extends ToolConfigGenerator {
+  async generate() {
+    await this.initialize();
+
+    // Generate .cursor/rules
+    await this.generateRules();
+
+    // Generate .cursor/mcp.json (optional)
+    await this.generateMCP();
+
+    // Generate .cursorrules deprecation notice
+    await this.generateLegacyNotice();
+
+    return {
+      rules: ['.cursor/rules'],
+      mcp: ['.cursor/mcp.json'],
+      legacy: ['.cursorrules']
+    };
+  }
+}
+
+class VSCodeGenerator extends ToolConfigGenerator {
+  async generate() {
+    await this.initialize();
+
+    // Generate .github/copilot-instructions.md
+    await this.generateCopilotInstructions();
+
+    // Generate/enhance .vscode/settings.json
+    await this.generateVSCodeSettings();
+
+    return {
+      copilot: ['.github/copilot-instructions.md'],
+      vscode: ['.vscode/settings.json']
+    };
+  }
+}
+```
+
+---
+
+## Integration Strategy
+
+### Deploy Command Flow
+
+```javascript
+async function deployToTool(tool, options = {}) {
+  // Find latest session
+  const sessionPath = await findLatestSession(cwd);
+  const framework = await getFrameworkFromSession(sessionPath);
+
+  // ALWAYS generate AGENTS.md (universal)
+  await generateAgentsMd(sessionPath, cwd, framework);
+
+  // Generate tool-specific configs
+  if (tool === 'windsurf') {
+    const windsurf = new WindsurfGenerator(sessionPath, cwd, framework);
+    await windsurf.generate();
+  }
+
+  if (tool === 'cursor') {
+    const cursor = new CursorGenerator(sessionPath, cwd, framework);
+    await cursor.generate();
+  }
+
+  if (tool === 'vscode') {
+    const vscode = new VSCodeGenerator(sessionPath, cwd, framework);
+    await vscode.generate();
+  }
+
+  // Legacy agent deployment
+  await deployAgents(workflow);
+  await createToolConfig(tool);
+}
+```
+
+### Generated File Structure
+
+```
+project/
+├── AGENTS.md                                    # ✅ Universal (ALWAYS)
+├── .windsurfrules                               # Windsurf (legacy)
+├── .windsurf/
+│   ├── rules/
+│   │   ├── project-context.md
+│   │   ├── architecture.md
+│   │   └── coding-standards.md
+│   └── workflows/
+│       ├── implement-story.md
+│       └── review-requirements.md
+├── .cursor/
+│   ├── rules                                    # Cursor (primary)
+│   ├── mcp.json                                 # MCP servers
+│   └── .cursorrules                             # Deprecation notice
+├── .github/
+│   └── copilot-instructions.md                  # GitHub Copilot
+├── .vscode/
+│   └── settings.json                            # Custom chat modes
+└── .adf/
+    └── sessions/
+        └── {session-id}/
+            └── outputs/                         # Source framework outputs
+```
+
+---
+
+## Current Task List
+
+### Immediate (Phase 2B)
+
+- [ ] **Build Windsurf Generator**
+  - [ ] WindsurfGenerator class
+  - [ ] .windsurfrules generation
+  - [ ] .windsurf/rules/*.md generation
+  - [ ] .windsurf/workflows/*.md generation
+  - [ ] Template for each framework (PRP, Balanced, BMAD)
+  - [ ] Tests
+
+- [ ] **Build Cursor Generator**
+  - [ ] CursorGenerator class
+  - [ ] .cursor/rules generation
+  - [ ] .cursor/mcp.json generation
+  - [ ] .cursorrules deprecation notice
+  - [ ] Template for each framework
+  - [ ] Tests
+
+- [ ] **Build VS Code Generator**
+  - [ ] VSCodeGenerator class
+  - [ ] .github/copilot-instructions.md generation
+  - [ ] .vscode/settings.json enhancement
+  - [ ] Custom chat modes
+  - [ ] Template for each framework
+  - [ ] Tests
+
+### Testing & Polish
+
+- [ ] Test all generators with real session data
+- [ ] Test PRP framework outputs
+- [ ] Test Balanced framework outputs
+- [ ] Test BMAD framework outputs
+- [ ] Verify all tools recognize generated configs
+- [ ] End-to-end integration test
+
+### Release (v0.3.0)
+
+- [ ] Update package.json to 0.3.0
+- [ ] Update CHANGELOG.md
+- [ ] Commit all generators
+- [ ] Run full test suite
+- [ ] Publish to npm
+- [ ] Push to GitHub
+- [ ] Test global install
+
+---
+
+## Key Insights
+
+### Why This Matters
+
+1. **User Uses All 3 IDEs**: Windsurf, Cursor, VS Code all need configs
+2. **AGENTS.md Foundation**: Universal standard works everywhere
+3. **Tool-Specific Enhancement**: Each tool gets optimized configs
+4. **Zero Manual Work**: Automatic from framework outputs
+5. **Consistency**: Same source (framework outputs) → multiple formats
+
+### Design Decisions
+
+**Priority Order:**
+1. AGENTS.md (universal) - ALWAYS
+2. Tool-specific (if tool selected)
+
+**Template Strategy:**
+- Shared variables across all generators
+- Framework-specific content extraction
+- Fallbacks for missing sections
+
+**File Organization:**
+- Modern formats preferred (.windsurf/rules vs .windsurfrules)
+- Legacy compatibility maintained
+- Deprecation notices for old formats
+
+**Character Limits:**
+- Windsurf: 12,000 chars per rule file
+- Split into multiple files if needed
+
+---
+
+## Success Criteria
+
+### For Each Generator
+
+- [ ] Generates valid config files
+- [ ] Tool recognizes and uses config
+- [ ] All framework types supported (PRP, Balanced, BMAD)
+- [ ] Template variables substituted correctly
+- [ ] Files written to correct locations
+- [ ] Tests passing
+
+### For Overall System
+
+- [ ] `adf deploy windsurf` generates all Windsurf configs
+- [ ] `adf deploy cursor` generates all Cursor configs
+- [ ] `adf deploy vscode` generates all VS Code configs
+- [ ] AGENTS.md generated regardless of tool
+- [ ] No conflicts between generated files
+- [ ] User can customize after generation
+- [ ] Works on Windows, Mac, Linux
+
+---
+
+## Next Steps
+
+1. **Build WindsurfGenerator** (highest priority - user uses it)
+2. **Build CursorGenerator** (user uses it)
+3. **Build VSCodeGenerator** (user uses it)
+4. **Test with real project**
+5. **Version 0.3.0 release**
+
+---
+
+**Status:** Ready to build tool generators
+**Chat Active:** Yes
+**Next Action:** Create WindsurfGenerator class