@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/lib/generators/cursor-generator.js

@@ -0,0 +1,374 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generator for Cursor AI configuration files
+ * Creates .cursor/rules, .cursor/mcp.json, and deprecation notices
+ *
+ * See: https://docs.cursor.com/
+ */
+class CursorGenerator extends ToolConfigGenerator {
+  /**
+   * Generate all Cursor configuration files
+   */
+  async generate() {
+    await this.initialize();
+
+    const generated = {
+      rules: [],
+      mcp: [],
+      legacy: []
+    };
+
+    // Generate .cursor/rules (modern, recommended)
+    const rulesPath = await this.generateRules();
+    generated.rules.push(rulesPath);
+
+    // Generate .cursor/mcp.json (optional, advanced)
+    // Commented out for now - can be enabled later
+    // const mcpPath = await this.generateMCP();
+    // generated.mcp.push(mcpPath);
+
+    // Generate .cursorrules deprecation notice (legacy support)
+    const legacyPath = await this.generateLegacyNotice();
+    generated.legacy.push(legacyPath);
+
+    return generated;
+  }
+
+  /**
+   * Generate .cursor/rules (primary configuration)
+   */
+  async generateRules() {
+    await this.ensureDir('.cursor');
+
+    const content = this.framework === 'rapid' ?
+      this.generateRulesPRP() :
+      this.framework === 'balanced' ?
+      this.generateRulesBalanced() :
+      this.generateRulesBMAD();
+
+    return await this.writeToProject('.cursor/rules', content);
+  }
+
+  generateRulesPRP() {
+    const projectName = this.getProjectName();
+    const sections = this.outputs.sections || {};
+
+    return `# ${projectName} - Cursor Rules
+
+You are a senior developer working on ${projectName}.
+
+## Project Goal
+
+${sections['1._goal_definition'] || sections['goal_definition'] || 'See PRP for details'}
+
+## Tech Stack
+
+${this.extractTechStack(sections)}
+
+## Implementation Blueprint
+
+${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See PRP for details'}
+
+## Success Criteria
+
+${sections['5._validation'] || sections['validation'] || 'See PRP for validation criteria'}
+
+## Before Implementing Features
+
+1. **Read the full PRP**: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+2. **Follow the implementation blueprint** exactly as specified
+3. **Validate against success criteria** before marking complete
+4. **Ask clarifying questions** if requirements are unclear
+
+## Code Standards
+
+- Use the specified tech stack
+- Follow the file structure in the blueprint
+- Include error handling
+- Write tests for new functionality
+- Document complex logic
+- Maintain consistency with existing code
+
+## Testing
+
+- Write tests for all new features
+- Ensure tests pass before committing
+- Follow TDD when appropriate
+
+## What to Avoid
+
+- Deviating from the implementation blueprint
+- Skipping tests
+- Ignoring success criteria
+- Using technologies not in the tech stack
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from PRP framework*
+*This is a .cursor/rules file. The legacy .cursorrules file is deprecated.*
+`;
+  }
+
+  generateRulesBalanced() {
+    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');
+
+    return `# ${projectName} - Cursor Rules
+
+You are a senior developer working on ${projectName}.
+
+## Core Principles
+
+${principles || 'Follow best practices'}
+
+## Constraints (Non-Negotiable)
+
+${constraints || 'No specific constraints'}
+
+## Tech Stack
+
+${techStack || 'See technical plan for details'}
+
+## Architecture
+
+${this.extractSection(specification, 'Architecture') || 'See specification.md for complete architecture'}
+
+## Before Implementing
+
+1. **Read the constitution**: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\`
+   - Understand principles and constraints
+2. **Review the specification**: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+   - Know what needs to be built
+3. **Check the technical plan**: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\`
+   - Follow architectural decisions
+4. **Review tasks**: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\`
+   - Understand implementation phases
+
+## Code Standards
+
+${this.extractSection(plan, 'Code Style') || this.extractSection(plan, 'Coding Standards') || 'Follow best practices'}
+
+- Write tests first (TDD approach)
+- Follow architecture patterns from specification
+- Adhere to constraints (these are non-negotiable)
+- Maintain consistency with code style
+
+## Testing
+
+- Comprehensive test coverage
+- Unit tests for logic
+- Integration tests for workflows
+- Follow testing approach in technical plan
+
+## What You MUST NOT Do
+
+- Violate any constraints from constitution
+- Deviate from architectural patterns
+- Skip tests
+- Ignore code standards
+
+## Reference Files
+
+- **Constitution**: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\` (principles & constraints)
+- **Specification**: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\` (detailed requirements)
+- **Technical Plan**: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\` (architecture & decisions)
+- **Tasks**: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\` (implementation breakdown)
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from Balanced framework*
+*This is a .cursor/rules file. The legacy .cursorrules file is deprecated.*
+`;
+  }
+
+  generateRulesBMAD() {
+    const projectName = this.getProjectName();
+    const prd = this.outputs.prd || '';
+    const architecture = this.outputs.architecture || '';
+
+    return `# ${projectName} - Cursor Rules
+
+You are a senior developer working on ${projectName}.
+
+## Product Overview
+
+${this.extractSection(prd, 'Executive Summary') || this.extractSection(prd, 'Overview') || 'See PRD'}
+
+## Goals and Objectives
+
+${this.extractSection(prd, 'Goals and Objectives') || 'See PRD'}
+
+## Technical Requirements
+
+${this.extractSection(prd, 'Technical Requirements') || this.extractSection(prd, 'Technical Architecture') || 'See PRD'}
+
+## System Architecture
+
+${this.extractSection(architecture, 'System Overview') || this.extractSection(architecture, 'Architecture Overview') || 'See architecture.md'}
+
+## Before Implementing
+
+1. **Read the PRD**: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\`
+   - Understand complete product vision
+2. **Study the architecture**: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+   - Know the system design and component structure
+3. **Review user stories**: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\`
+   - Understand user needs and acceptance criteria
+
+## Code Quality Standards
+
+- Maintain test coverage >= 80%
+- Follow architectural patterns from architecture.md
+- Implement user stories as specified in stories.md
+- Write clean, maintainable, documented code
+- Handle errors gracefully
+- Consider scalability and performance
+
+## Testing
+
+- Write comprehensive tests
+- Unit tests for components
+- Integration tests for workflows
+- E2E tests for user journeys
+- All tests must pass before committing
+
+## Security
+
+- Never commit sensitive data (API keys, passwords, tokens)
+- Use environment variables for configuration
+- Validate all user input
+- Follow security best practices
+- See PRD for specific security requirements
+
+## Performance
+
+- Follow performance requirements in PRD
+- Optimize critical paths
+- Monitor resource usage
+- See architecture.md for performance patterns
+
+## What You MUST NOT Do
+
+- Deviate from architectural decisions without discussion
+- Skip tests
+- Ignore user story acceptance criteria
+- Commit sensitive data
+- Make breaking changes without approval
+
+## Reference Files
+
+- **PRD**: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\` (complete product requirements)
+- **Architecture**: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\` (system design)
+- **User Stories**: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\` (user needs & acceptance criteria)
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from BMAD framework*
+*This is a .cursor/rules file. The legacy .cursorrules file is deprecated.*
+`;
+  }
+
+  /**
+   * Generate .cursor/mcp.json (Model Context Protocol servers)
+   * Optional advanced feature for custom tools
+   */
+  async generateMCP() {
+    await this.ensureDir('.cursor');
+
+    const mcpConfig = {
+      mcpServers: {
+        "requirement-checker": {
+          command: "node",
+          args: ["./tools/requirement-checker.js"],
+          env: {
+            SESSION_PATH: `.adf/sessions/${this.getSessionId()}`
+          }
+        }
+      }
+    };
+
+    const content = JSON.stringify(mcpConfig, null, 2);
+    return await this.writeToProject('.cursor/mcp.json', content);
+  }
+
+  /**
+   * Generate .cursorrules with deprecation notice
+   * Legacy support - redirect to modern .cursor/rules
+   */
+  async generateLegacyNotice() {
+    const content = `# DEPRECATED: .cursorrules
+
+This file format is deprecated by Cursor.
+
+**Please use:** \`.cursor/rules\` instead
+
+The modern \`.cursor/rules\` file provides:
+- Better organization
+- Project-scoped rules
+- Enhanced functionality
+
+## Migration
+
+The ADF CLI has automatically generated:
+- \`.cursor/rules\` - Your project rules (use this)
+
+You can delete this .cursorrules file.
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()}*
+`;
+
+    return await this.writeToProject('.cursorrules', content);
+  }
+
+  /**
+   * 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 = CursorGenerator;

package/lib/generators/index.js

@@ -0,0 +1,98 @@
+/**
+ * Tool Configuration Generators
+ * Transform ADF framework outputs into IDE/tool-specific configurations
+ */
+
+const AgentsMdGenerator = require('./agents-md-generator');
+const WindsurfGenerator = require('./windsurf-generator');
+const CursorGenerator = require('./cursor-generator');
+const VSCodeGenerator = require('./vscode-generator');
+const ToolConfigGenerator = require('./tool-config-generator');
+
+/**
+ * Generate all tool configurations for a project
+ * @param {string} sessionPath - Path to ADF session
+ * @param {string} projectPath - Path to project root
+ * @param {string} framework - Framework type (rapid/balanced/comprehensive)
+ * @param {object} options - Generation options
+ * @returns {object} Generated file paths
+ */
+async function generateAll(sessionPath, projectPath, framework, options = {}) {
+  const generated = {
+    universal: [],
+    windsurf: [],
+    cursor: [],
+    vscode: []
+  };
+
+  // Always generate AGENTS.md (universal standard)
+  const agentsMd = new AgentsMdGenerator(sessionPath, projectPath, framework);
+  const agentsMdPath = await agentsMd.generate();
+  generated.universal.push(agentsMdPath);
+
+  // Generate tool-specific configs based on options
+  if (options.tool === 'windsurf' || options.all) {
+    const windsurf = new WindsurfGenerator(sessionPath, projectPath, framework);
+    const windsurfPaths = await windsurf.generate();
+    generated.windsurf = windsurfPaths;
+  }
+
+  if (options.tool === 'cursor' || options.all) {
+    const cursor = new CursorGenerator(sessionPath, projectPath, framework);
+    const cursorPaths = await cursor.generate();
+    generated.cursor = cursorPaths;
+  }
+
+  if (options.tool === 'vscode' || options.all) {
+    const vscode = new VSCodeGenerator(sessionPath, projectPath, framework);
+    const vscodePaths = await vscode.generate();
+    generated.vscode = vscodePaths;
+  }
+
+  return generated;
+}
+
+/**
+ * Generate only AGENTS.md (universal standard)
+ */
+async function generateAgentsMd(sessionPath, projectPath, framework) {
+  const generator = new AgentsMdGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Windsurf configurations
+ */
+async function generateWindsurf(sessionPath, projectPath, framework) {
+  const generator = new WindsurfGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate Cursor configurations
+ */
+async function generateCursor(sessionPath, projectPath, framework) {
+  const generator = new CursorGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+/**
+ * Generate VS Code configurations
+ */
+async function generateVSCode(sessionPath, projectPath, framework) {
+  const generator = new VSCodeGenerator(sessionPath, projectPath, framework);
+  return await generator.generate();
+}
+
+module.exports = {
+  generateAll,
+  generateAgentsMd,
+  generateWindsurf,
+  generateCursor,
+  generateVSCode,
+  AgentsMdGenerator,
+  WindsurfGenerator,
+  CursorGenerator,
+  VSCodeGenerator,
+  ToolConfigGenerator
+};

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

@@ -0,0 +1,188 @@
+const fs = require('fs-extra');
+const path = require('path');
+
+/**
+ * Base class for generating tool-specific configuration files
+ * Transforms ADF framework outputs into IDE/tool configurations
+ */
+class ToolConfigGenerator {
+  constructor(sessionPath, projectPath, framework) {
+    this.sessionPath = sessionPath;
+    this.projectPath = projectPath;
+    this.framework = framework;
+    this.outputsPath = path.join(sessionPath, 'outputs');
+    this.metadata = null;
+    this.outputs = {};
+  }
+
+  /**
+   * Load session metadata and framework outputs
+   */
+  async initialize() {
+    // Load metadata
+    const metadataPath = path.join(this.sessionPath, '_metadata.json');
+    if (await fs.pathExists(metadataPath)) {
+      this.metadata = await fs.readJson(metadataPath);
+    }
+
+    // Load framework outputs based on type
+    await this.loadFrameworkOutputs();
+  }
+
+  /**
+   * Load framework-specific output files
+   */
+  async loadFrameworkOutputs() {
+    if (this.framework === 'rapid') {
+      await this.loadPRPOutputs();
+    } else if (this.framework === 'balanced') {
+      await this.loadBalancedOutputs();
+    } else if (this.framework === 'comprehensive') {
+      await this.loadBMADOutputs();
+    }
+  }
+
+  async loadPRPOutputs() {
+    const prpPath = path.join(this.outputsPath, 'prp.md');
+    if (await fs.pathExists(prpPath)) {
+      this.outputs.prp = await fs.readFile(prpPath, 'utf-8');
+      this.outputs.sections = this.parsePRPSections(this.outputs.prp);
+    }
+  }
+
+  async loadBalancedOutputs() {
+    const files = ['constitution.md', 'specification.md', 'plan.md', 'tasks.md'];
+    for (const file of files) {
+      const filePath = path.join(this.outputsPath, file);
+      if (await fs.pathExists(filePath)) {
+        const key = file.replace('.md', '');
+        this.outputs[key] = await fs.readFile(filePath, 'utf-8');
+      }
+    }
+  }
+
+  async loadBMADOutputs() {
+    const files = ['prd.md', 'architecture.md', 'stories.md'];
+    for (const file of files) {
+      const filePath = path.join(this.outputsPath, file);
+      if (await fs.pathExists(filePath)) {
+        const key = file.replace('.md', '');
+        this.outputs[key] = await fs.readFile(filePath, 'utf-8');
+      }
+    }
+  }
+
+  /**
+   * Parse PRP markdown into sections
+   */
+  parsePRPSections(content) {
+    const sections = {};
+    const lines = content.split('\n');
+    let currentSection = null;
+    let currentContent = [];
+
+    for (const line of lines) {
+      // Check for main headings (## Section)
+      const headingMatch = line.match(/^##\s+(.+)$/);
+      if (headingMatch) {
+        // Save previous section
+        if (currentSection) {
+          sections[currentSection] = currentContent.join('\n').trim();
+        }
+        // Start new section
+        currentSection = headingMatch[1].toLowerCase().replace(/\s+/g, '_');
+        currentContent = [];
+      } else if (currentSection) {
+        currentContent.push(line);
+      }
+    }
+
+    // Save last section
+    if (currentSection) {
+      sections[currentSection] = currentContent.join('\n').trim();
+    }
+
+    return sections;
+  }
+
+  /**
+   * Extract project name from metadata or session
+   */
+  getProjectName() {
+    if (this.metadata && this.metadata.projectName) {
+      return this.metadata.projectName;
+    }
+    // Fallback to directory name
+    return path.basename(this.projectPath);
+  }
+
+  /**
+   * Get session ID
+   */
+  getSessionId() {
+    return path.basename(this.sessionPath);
+  }
+
+  /**
+   * Replace template variables in content
+   */
+  replaceVariables(template, variables) {
+    let result = template;
+    for (const [key, value] of Object.entries(variables)) {
+      const regex = new RegExp(`\\{${key}\\}`, 'g');
+      result = result.replace(regex, value || '');
+    }
+    return result;
+  }
+
+  /**
+   * Extract content between markdown headings
+   */
+  extractSection(content, sectionName) {
+    const lines = content.split('\n');
+    let inSection = false;
+    let sectionContent = [];
+
+    for (const line of lines) {
+      if (line.startsWith('##')) {
+        if (inSection) {
+          break; // End of our section
+        }
+        if (line.toLowerCase().includes(sectionName.toLowerCase())) {
+          inSection = true;
+          continue;
+        }
+      }
+      if (inSection) {
+        sectionContent.push(line);
+      }
+    }
+
+    return sectionContent.join('\n').trim();
+  }
+
+  /**
+   * Write file to project root
+   */
+  async writeToProject(fileName, content) {
+    const filePath = path.join(this.projectPath, fileName);
+    await fs.writeFile(filePath, content, 'utf-8');
+    return filePath;
+  }
+
+  /**
+   * Ensure directory exists
+   */
+  async ensureDir(dirPath) {
+    await fs.ensureDir(path.join(this.projectPath, dirPath));
+  }
+
+  /**
+   * Generate all configurations (override in subclasses)
+   */
+  async generate() {
+    throw new Error('generate() must be implemented by subclass');
+  }
+}
+
+module.exports = ToolConfigGenerator;