@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/lib/generators/vscode-generator.js

@@ -0,0 +1,403 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Generator for VS Code configuration files
+ * Creates .github/copilot-instructions.md and .vscode/settings.json
+ *
+ * Supports:
+ * - GitHub Copilot instructions
+ * - Custom chat modes
+ * - Language Model API integration
+ */
+class VSCodeGenerator extends ToolConfigGenerator {
+  /**
+   * Generate all VS Code configuration files
+   */
+  async generate() {
+    await this.initialize();
+
+    const generated = {
+      copilot: [],
+      vscode: []
+    };
+
+    // Generate .github/copilot-instructions.md (GitHub Copilot)
+    const copilotPath = await this.generateCopilotInstructions();
+    generated.copilot.push(copilotPath);
+
+    // Generate/enhance .vscode/settings.json (custom chat modes)
+    const settingsPath = await this.generateVSCodeSettings();
+    generated.vscode.push(settingsPath);
+
+    return generated;
+  }
+
+  /**
+   * Generate .github/copilot-instructions.md
+   */
+  async generateCopilotInstructions() {
+    await this.ensureDir('.github');
+
+    const content = this.framework === 'rapid' ?
+      this.generateCopilotPRP() :
+      this.framework === 'balanced' ?
+      this.generateCopilotBalanced() :
+      this.generateCopilotBMAD();
+
+    return await this.writeToProject('.github/copilot-instructions.md', content);
+  }
+
+  generateCopilotPRP() {
+    const projectName = this.getProjectName();
+    const sections = this.outputs.sections || {};
+
+    return `# Copilot Instructions for ${projectName}
+
+## Project Overview
+
+${sections['1._goal_definition'] || sections['goal_definition'] || 'Software development project'}
+
+## Tech Stack
+
+${this.extractTechStack(sections)}
+
+## Implementation Blueprint
+
+${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See PRP for details'}
+
+## Code Style
+
+- Use the specified tech stack
+- Follow the file structure in the blueprint
+- Write clean, readable code
+- Include error handling
+- Add tests for new features
+
+## Testing
+
+- Write tests for all new functionality
+- Follow test patterns in the blueprint
+- Ensure tests pass before committing
+
+## When Generating Code
+
+1. **Check requirements**: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+2. **Follow the implementation blueprint** exactly
+3. **Include error handling** in all code
+4. **Add type definitions** (if using TypeScript)
+5. **Write accompanying tests**
+
+## Success Criteria
+
+${sections['5._validation'] || sections['validation'] || 'See PRP'}
+
+Ensure all code meets these criteria before considering it complete.
+
+## Reference Document
+
+Full PRP: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from PRP framework*
+`;
+  }
+
+  generateCopilotBalanced() {
+    const projectName = this.getProjectName();
+    const constitution = this.outputs.constitution || '';
+    const specification = this.outputs.specification || '';
+    const plan = this.outputs.plan || '';
+
+    const principles = this.extractSection(constitution, 'Core Principles');
+    const constraints = this.extractSection(constitution, 'Constraints');
+    const techStack = this.extractSection(plan, 'Technology Stack');
+    const codeStyle = this.extractSection(plan, 'Code Style') ||
+                      this.extractSection(plan, 'Coding Standards');
+
+    return `# Copilot Instructions for ${projectName}
+
+## Project Overview
+
+${this.extractSection(specification, 'Overview') || this.extractSection(specification, 'Purpose')}
+
+## Core Principles
+
+${principles || 'Follow best practices'}
+
+**These must always be followed.**
+
+## Constraints (Non-Negotiable)
+
+${constraints || 'No specific constraints'}
+
+**Never violate these constraints.**
+
+## Tech Stack
+
+${techStack || 'See technical plan'}
+
+## Architecture
+
+${this.extractSection(specification, 'Architecture') || 'See specification.md'}
+
+Full architecture: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+
+## Code Standards
+
+${codeStyle || 'Follow best practices'}
+
+- Write tests first (TDD approach)
+- Follow architecture patterns
+- Adhere to all constraints
+- Maintain consistency
+
+## Patterns to Use
+
+${this.extractSection(plan, 'Recommended Patterns') || this.extractSection(specification, 'Patterns') || '- Follow architectural patterns from specification'}
+
+## Patterns to Avoid
+
+${this.extractSection(plan, 'Anti-Patterns') || this.extractSection(specification, 'What Not To Do') || '- Violating constraints\n- Skipping tests\n- Deviating from architecture'}
+
+## Testing Requirements
+
+${this.extractSection(plan, 'Testing') || '- Comprehensive test coverage\n- Unit and integration tests\n- All tests must pass'}
+
+## When Generating Code
+
+1. **Review requirements**: Check specification and technical plan
+2. **Follow architecture**: Use patterns from specification
+3. **Check constraints**: Never violate constitution constraints
+4. **Include error handling**: Handle all error cases
+5. **Add type definitions**: Use strong typing
+6. **Write tests**: Test-driven development
+
+## Reference Documents
+
+- **Constitution**: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\` (principles & constraints)
+- **Specification**: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\` (requirements & architecture)
+- **Technical Plan**: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\` (technical decisions)
+- **Tasks**: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\` (implementation breakdown)
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from Balanced framework*
+`;
+  }
+
+  generateCopilotBMAD() {
+    const projectName = this.getProjectName();
+    const prd = this.outputs.prd || '';
+    const architecture = this.outputs.architecture || '';
+
+    return `# Copilot Instructions for ${projectName}
+
+## Product Overview
+
+${this.extractSection(prd, 'Executive Summary') || this.extractSection(prd, 'Overview')}
+
+## Goals and Objectives
+
+${this.extractSection(prd, 'Goals and Objectives') || 'See PRD'}
+
+## Technical Requirements
+
+${this.extractSection(prd, 'Technical Requirements') || this.extractSection(prd, 'Technical Architecture')}
+
+## System Architecture
+
+${this.extractSection(architecture, 'System Overview') || this.extractSection(architecture, 'Architecture Overview')}
+
+Full architecture: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+
+## Code Quality Standards
+
+- **Test coverage**: >= 80%
+- **Architecture**: Follow patterns from architecture.md
+- **User stories**: Implement as specified in stories.md
+- **Documentation**: Document public APIs and complex logic
+- **Error handling**: Handle all error cases gracefully
+- **Performance**: Consider scalability and performance
+
+## Testing Requirements
+
+- Comprehensive test coverage (>= 80%)
+- Unit tests for all components
+- Integration tests for workflows
+- E2E tests for user journeys
+- All tests must pass before committing
+
+## Security Requirements
+
+${this.extractSection(prd, 'Security') || this.extractSection(prd, 'Security Requirements') || '- Never commit sensitive data\n- Validate all user input\n- Use environment variables for secrets'}
+
+## Performance Considerations
+
+${this.extractSection(prd, 'Performance') || '- Optimize critical paths\n- Monitor resource usage\n- Follow performance patterns from architecture'}
+
+## Patterns to Use
+
+- Follow architectural patterns from architecture.md
+- Implement user stories as specified
+- Use consistent coding style
+- Write self-documenting code
+
+## Patterns to Avoid
+
+- Deviating from architectural decisions
+- Skipping tests
+- Ignoring user story acceptance criteria
+- Committing sensitive data
+- Making breaking changes without approval
+
+## When Generating Code
+
+1. **Review requirements**: Read the PRD for context
+2. **Check architecture**: Follow system design from architecture.md
+3. **Review user story**: Understand acceptance criteria
+4. **Include error handling**: Handle all cases
+5. **Add type definitions**: Use strong typing
+6. **Write tests first**: Test-driven development
+7. **Validate against criteria**: Ensure acceptance criteria met
+
+## Reference Documents
+
+- **PRD**: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\` (complete product requirements)
+- **Architecture**: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\` (system design & technical architecture)
+- **User Stories**: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\` (user needs & acceptance criteria)
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from BMAD framework*
+`;
+  }
+
+  /**
+   * Generate/enhance .vscode/settings.json with custom chat modes
+   */
+  async generateVSCodeSettings() {
+    await this.ensureDir('.vscode');
+
+    const settingsPath = path.join(this.projectPath, '.vscode', 'settings.json');
+    let settings = {};
+
+    // Load existing settings if they exist
+    if (await fs.pathExists(settingsPath)) {
+      try {
+        const content = await fs.readFile(settingsPath, 'utf-8');
+        settings = JSON.parse(content);
+      } catch (error) {
+        // If parsing fails, start fresh
+        console.warn('Warning: Could not parse existing .vscode/settings.json, will create new');
+      }
+    }
+
+    // Add custom chat modes
+    settings['github.copilot.chat.modes'] = this.generateChatModes();
+
+    const content = JSON.stringify(settings, null, 2);
+    await fs.writeFile(settingsPath, content, 'utf-8');
+
+    return '.vscode/settings.json';
+  }
+
+  generateChatModes() {
+    const sessionId = this.getSessionId();
+
+    const modes = {
+      architect: {
+        instructions: "Focus on system design and architecture patterns. Check component boundaries, data flow, and scalability.",
+        context: []
+      },
+      implementer: {
+        instructions: "Implement features following requirements and architecture. Write tests first.",
+        context: []
+      },
+      reviewer: {
+        instructions: "Review code against requirements and best practices. Check for compliance, quality, and security.",
+        context: []
+      }
+    };
+
+    // Add context files based on framework
+    if (this.framework === 'rapid') {
+      modes.architect.context.push(`.adf/sessions/${sessionId}/outputs/prp.md`);
+      modes.implementer.context.push(`.adf/sessions/${sessionId}/outputs/prp.md`);
+      modes.reviewer.context.push(`.adf/sessions/${sessionId}/outputs/prp.md`);
+    } else if (this.framework === 'balanced') {
+      modes.architect.context.push(
+        `.adf/sessions/${sessionId}/outputs/specification.md`,
+        `.adf/sessions/${sessionId}/outputs/plan.md`
+      );
+      modes.implementer.context.push(
+        `.adf/sessions/${sessionId}/outputs/specification.md`,
+        `.adf/sessions/${sessionId}/outputs/tasks.md`
+      );
+      modes.reviewer.context.push(
+        `.adf/sessions/${sessionId}/outputs/constitution.md`,
+        `.adf/sessions/${sessionId}/outputs/plan.md`
+      );
+    } else {
+      modes.architect.context.push(
+        `.adf/sessions/${sessionId}/outputs/architecture.md`,
+        `.adf/sessions/${sessionId}/outputs/prd.md`
+      );
+      modes.implementer.context.push(
+        `.adf/sessions/${sessionId}/outputs/stories.md`,
+        `.adf/sessions/${sessionId}/outputs/prd.md`
+      );
+      modes.reviewer.context.push(
+        `.adf/sessions/${sessionId}/outputs/prd.md`,
+        `.adf/sessions/${sessionId}/outputs/architecture.md`
+      );
+    }
+
+    return modes;
+  }
+
+  /**
+   * Extract tech stack from PRP sections
+   */
+  extractTechStack(sections) {
+    const contextualIntelligence = sections['3._contextual_intelligence'] ||
+                                   sections['contextual_intelligence'] || '';
+
+    const lines = contextualIntelligence.split('\n');
+    const techLines = [];
+    let inTechSection = false;
+
+    for (const line of lines) {
+      if (line.toLowerCase().includes('tech') ||
+          line.toLowerCase().includes('stack') ||
+          line.toLowerCase().includes('technology')) {
+        inTechSection = true;
+      }
+      if (inTechSection && line.trim()) {
+        techLines.push(line);
+        if (techLines.length > 10) break;
+      }
+      if (line.startsWith('##') && inTechSection && techLines.length > 0) {
+        break;
+      }
+    }
+
+    return techLines.length > 0 ? techLines.join('\n') : 'See framework outputs for tech stack';
+  }
+
+  /**
+   * Get ADF CLI version
+   */
+  getADFVersion() {
+    try {
+      const packageJson = require('../../package.json');
+      return packageJson.version;
+    } catch (error) {
+      return '0.3.0';
+    }
+  }
+}
+
+module.exports = VSCodeGenerator;