@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/lib/generators/windsurf-generator.js

@@ -0,0 +1,596 @@
+const ToolConfigGenerator = require('./tool-config-generator');
+const path = require('path');
+
+/**
+ * Generator for Windsurf (Codeium) configuration files
+ * Creates .windsurfrules, rules, and workflows
+ *
+ * File limits: 12,000 characters per rule file
+ * See: https://docs.windsurf.com/
+ */
+class WindsurfGenerator extends ToolConfigGenerator {
+  /**
+   * Generate all Windsurf configuration files
+   */
+  async generate() {
+    await this.initialize();
+
+    const generated = {
+      legacy: [],
+      rules: [],
+      workflows: []
+    };
+
+    // Generate .windsurfrules (legacy compatibility)
+    const legacyPath = await this.generateLegacyRules();
+    generated.legacy.push(legacyPath);
+
+    // Generate .windsurf/rules/*.md (modern)
+    const rulesPaths = await this.generateModernRules();
+    generated.rules.push(...rulesPaths);
+
+    // Generate .windsurf/workflows/*.md
+    const workflowsPaths = await this.generateWorkflows();
+    generated.workflows.push(...workflowsPaths);
+
+    return generated;
+  }
+
+  /**
+   * Generate .windsurfrules (legacy format, still supported)
+   */
+  async generateLegacyRules() {
+    const content = this.framework === 'rapid' ?
+      this.generateLegacyPRP() :
+      this.framework === 'balanced' ?
+      this.generateLegacyBalanced() :
+      this.generateLegacyBMAD();
+
+    return await this.writeToProject('.windsurfrules', content);
+  }
+
+  generateLegacyPRP() {
+    const projectName = this.getProjectName();
+    const sections = this.outputs.sections || {};
+
+    return `# ${projectName} - Windsurf Rules
+
+## Project Goal
+
+${sections['1._goal_definition'] || sections['goal_definition'] || 'See prp.md for details'}
+
+## Tech Stack
+
+${this.extractTechStack(sections)}
+
+## Implementation Blueprint
+
+${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See prp.md for implementation details'}
+
+## Success Criteria
+
+${sections['5._validation'] || sections['validation'] || 'See prp.md for validation criteria'}
+
+## AI Behavior
+
+- Always reference the full PRP: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+- Follow the implementation blueprint exactly as specified
+- Validate against success criteria before marking complete
+- Ask clarifying questions if requirements are unclear
+- Maintain consistency with the tech stack
+
+## Code Generation Rules
+
+- Use the specified tech stack
+- Follow the file structure in the implementation blueprint
+- Include error handling
+- Write tests for new functionality
+- Document complex logic
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from PRP framework*
+`;
+  }
+
+  generateLegacyBalanced() {
+    const projectName = this.getProjectName();
+    const constitution = this.outputs.constitution || '';
+    const specification = this.outputs.specification || '';
+
+    const principles = this.extractSection(constitution, 'Core Principles');
+    const constraints = this.extractSection(constitution, 'Constraints');
+
+    return `# ${projectName} - Windsurf Rules
+
+## Core Principles
+
+${principles || 'Follow best practices'}
+
+## Constraints
+
+${constraints || 'No specific constraints'}
+
+## Tech Stack
+
+${this.extractSection(this.outputs.plan || '', 'Technology Stack') || 'See technical plan'}
+
+## Architecture
+
+${this.extractSection(specification, 'Architecture') || 'See specification.md'}
+
+## AI Behavior
+
+**Before implementing:**
+1. Review constitution: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\`
+2. Check specification: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+3. Consult technical plan: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\`
+
+**Never violate:**
+- The core principles
+- The constraints
+
+**Always follow:**
+- Architecture patterns from specification
+- Code standards from technical plan
+- Task breakdown from tasks.md
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from Balanced framework*
+`;
+  }
+
+  generateLegacyBMAD() {
+    const projectName = this.getProjectName();
+    const prd = this.outputs.prd || '';
+
+    return `# ${projectName} - Windsurf Rules
+
+## Product Overview
+
+${this.extractSection(prd, 'Executive Summary') || this.extractSection(prd, 'Overview')}
+
+## Technical Requirements
+
+${this.extractSection(prd, 'Technical Requirements') || 'See PRD for details'}
+
+## Architecture
+
+${this.extractSection(this.outputs.architecture || '', 'System Overview') || 'See architecture.md'}
+
+## AI Behavior
+
+**Before implementing:**
+1. Read the PRD: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\`
+2. Study the architecture: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+3. Review user stories: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\`
+
+**Always:**
+- Implement user stories as specified
+- Follow architectural patterns
+- Write comprehensive tests
+- Consider scalability and performance
+- Handle errors gracefully
+
+**Never:**
+- Deviate from architectural decisions without discussion
+- Skip tests
+- Commit sensitive data
+
+---
+
+*Generated by ADF CLI v${this.getADFVersion()} from BMAD framework*
+`;
+  }
+
+  /**
+   * Generate .windsurf/rules/*.md (modern format)
+   */
+  async generateModernRules() {
+    await this.ensureDir('.windsurf/rules');
+
+    const paths = [];
+
+    // Project context rule
+    paths.push(await this.generateProjectContextRule());
+
+    // Architecture rule (if available)
+    if (this.outputs.architecture || this.outputs.specification || this.outputs.sections) {
+      paths.push(await this.generateArchitectureRule());
+    }
+
+    // Coding standards rule (if available)
+    if (this.outputs.plan || this.outputs.specification) {
+      paths.push(await this.generateCodingStandardsRule());
+    }
+
+    return paths;
+  }
+
+  async generateProjectContextRule() {
+    const projectName = this.getProjectName();
+
+    let content;
+    if (this.framework === 'rapid') {
+      const sections = this.outputs.sections || {};
+      content = `# Project Context - ${projectName}
+
+## Goal
+
+${sections['1._goal_definition'] || sections['goal_definition'] || 'Software development project'}
+
+## Tech Stack
+
+${this.extractTechStack(sections)}
+
+## Context Intelligence
+
+${sections['3._contextual_intelligence'] || sections['contextual_intelligence'] || 'See PRP for details'}
+
+## Full Context
+
+All requirements are documented in: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+
+Read this file before implementing any features.
+`;
+    } else if (this.framework === 'balanced') {
+      content = `# Project Context - ${projectName}
+
+## Overview
+
+${this.extractSection(this.outputs.specification || '', 'Overview') || 'See specification'}
+
+## Core Principles
+
+${this.extractSection(this.outputs.constitution || '', 'Core Principles') || 'Follow best practices'}
+
+## Tech Stack
+
+${this.extractSection(this.outputs.plan || '', 'Technology Stack') || 'See technical plan'}
+
+## Full Context
+
+Review these files before implementing:
+- Constitution: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\`
+- Specification: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+- Technical Plan: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\`
+`;
+    } else {
+      content = `# Project Context - ${projectName}
+
+## Product Overview
+
+${this.extractSection(this.outputs.prd || '', 'Executive Summary') || 'See PRD'}
+
+## Goals
+
+${this.extractSection(this.outputs.prd || '', 'Goals and Objectives') || 'See PRD'}
+
+## Full Context
+
+Review these files before implementing:
+- PRD: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\`
+- Architecture: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+- User Stories: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\`
+`;
+    }
+
+    return await this.writeToProject('.windsurf/rules/project-context.md', content);
+  }
+
+  async generateArchitectureRule() {
+    const projectName = this.getProjectName();
+
+    let content;
+    if (this.framework === 'rapid') {
+      const sections = this.outputs.sections || {};
+      content = `# Architecture - ${projectName}
+
+## Implementation Blueprint
+
+${sections['4._implementation_blueprint'] || sections['implementation_blueprint'] || 'See PRP'}
+
+## Reference
+
+Full implementation details: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+`;
+    } else if (this.framework === 'balanced') {
+      content = `# Architecture - ${projectName}
+
+${this.extractSection(this.outputs.specification || '', 'Architecture') || 'See specification'}
+
+## Technical Decisions
+
+${this.extractSection(this.outputs.plan || '', 'Architecture') || 'See technical plan'}
+
+## Reference
+
+Full architecture: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+`;
+    } else {
+      content = `# Architecture - ${projectName}
+
+${this.extractSection(this.outputs.architecture || '', 'System Overview') || 'See architecture.md'}
+
+## Components
+
+${this.extractSection(this.outputs.architecture || '', 'Components') || 'See architecture.md'}
+
+## Reference
+
+Full architecture: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+`;
+    }
+
+    return await this.writeToProject('.windsurf/rules/architecture.md', content);
+  }
+
+  async generateCodingStandardsRule() {
+    const projectName = this.getProjectName();
+
+    let content;
+    if (this.framework === 'rapid') {
+      content = `# Coding Standards - ${projectName}
+
+## General Guidelines
+
+- Follow the tech stack specifications
+- Write clean, readable code
+- Include error handling
+- Add tests for new features
+- Document complex logic
+
+## Reference
+
+See implementation blueprint in: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+`;
+    } else if (this.framework === 'balanced') {
+      content = `# Coding Standards - ${projectName}
+
+${this.extractSection(this.outputs.plan || '', 'Code Style') || this.extractSection(this.outputs.plan || '', 'Coding Standards') || ''}
+
+## Principles to Follow
+
+${this.extractSection(this.outputs.constitution || '', 'Core Principles') || 'Follow best practices'}
+
+## Reference
+
+Full standards: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\`
+`;
+    } else {
+      content = `# Coding Standards - ${projectName}
+
+${this.extractSection(this.outputs.prd || '', 'Code Quality') || ''}
+
+## Best Practices
+
+- Write comprehensive tests
+- Handle errors gracefully
+- Document public APIs
+- Follow architectural patterns
+- Consider performance and scalability
+
+## Reference
+
+Full requirements: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\`
+`;
+    }
+
+    return await this.writeToProject('.windsurf/rules/coding-standards.md', content);
+  }
+
+  /**
+   * Generate .windsurf/workflows/*.md
+   */
+  async generateWorkflows() {
+    await this.ensureDir('.windsurf/workflows');
+
+    const paths = [];
+
+    // Review requirements workflow
+    paths.push(await this.generateReviewWorkflow());
+
+    // Implement story workflow (for Balanced/BMAD)
+    if (this.framework === 'balanced' || this.framework === 'comprehensive') {
+      paths.push(await this.generateImplementWorkflow());
+    }
+
+    return paths;
+  }
+
+  async generateReviewWorkflow() {
+    let content;
+
+    if (this.framework === 'rapid') {
+      content = `# Review Requirements
+
+Use this workflow to review requirements before implementing.
+
+## Steps
+
+1. Read the full PRP: \`.adf/sessions/${this.getSessionId()}/outputs/prp.md\`
+2. Understand the goal and business justification
+3. Review the tech stack and contextual intelligence
+4. Study the implementation blueprint
+5. Note the success criteria
+
+## Questions to Ask
+
+- What is the core feature being built?
+- Who are the users?
+- What problem does this solve?
+- What are the technical constraints?
+- How will success be measured?
+`;
+    } else if (this.framework === 'balanced') {
+      content = `# Review Requirements
+
+Use this workflow to review requirements before implementing.
+
+## Steps
+
+1. Read the constitution: \`.adf/sessions/${this.getSessionId()}/outputs/constitution.md\`
+   - Note core principles and constraints
+2. Read the specification: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+   - Understand what needs to be built
+3. Review the technical plan: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\`
+   - Understand architectural decisions
+4. Check tasks: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\`
+   - See implementation breakdown
+
+## Questions to Ask
+
+- What are the non-negotiable constraints?
+- What architectural patterns should I follow?
+- What are the acceptance criteria?
+- Are there any dependencies?
+`;
+    } else {
+      content = `# Review Requirements
+
+Use this workflow to review requirements before implementing.
+
+## Steps
+
+1. Read the PRD: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\`
+   - Understand product vision and goals
+2. Study the architecture: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+   - Know the system design
+3. Review user stories: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\`
+   - Understand user needs
+
+## Questions to Ask
+
+- What user problem are we solving?
+- What are the technical requirements?
+- What are the performance/scalability needs?
+- What are the security considerations?
+- How does this fit in the overall architecture?
+`;
+    }
+
+    return await this.writeToProject('.windsurf/workflows/review-requirements.md', content);
+  }
+
+  async generateImplementWorkflow() {
+    let content;
+
+    if (this.framework === 'balanced') {
+      content = `# Implement Feature
+
+Use this workflow when implementing a feature.
+
+## Steps
+
+1. Review the specification for this feature
+2. Check the technical plan for architecture patterns
+3. Review the task breakdown
+4. Plan your implementation approach
+5. Write tests first (TDD)
+6. Implement following architecture patterns
+7. Verify against acceptance criteria
+8. Run tests and linter
+9. Create pull request
+
+## Checklist
+
+- [ ] Read relevant sections of specification.md
+- [ ] Understand architectural patterns from plan.md
+- [ ] Review task breakdown
+- [ ] Write failing tests
+- [ ] Implement feature
+- [ ] All tests pass
+- [ ] Code follows standards
+- [ ] Acceptance criteria met
+
+## Reference Files
+
+- Specification: \`.adf/sessions/${this.getSessionId()}/outputs/specification.md\`
+- Plan: \`.adf/sessions/${this.getSessionId()}/outputs/plan.md\`
+- Tasks: \`.adf/sessions/${this.getSessionId()}/outputs/tasks.md\`
+`;
+    } else {
+      content = `# Implement User Story
+
+Use this workflow when implementing a user story.
+
+## Steps
+
+1. Find the user story in stories.md
+2. Read the acceptance criteria
+3. Review the architecture for component location
+4. Check the PRD for technical requirements
+5. Plan your implementation
+6. Write tests first (TDD)
+7. Implement the story
+8. Verify against acceptance criteria
+9. Run full test suite
+10. Create pull request
+
+## Checklist
+
+- [ ] User story identified and understood
+- [ ] Acceptance criteria clear
+- [ ] Architecture reviewed
+- [ ] Tests written and failing
+- [ ] Implementation complete
+- [ ] All acceptance criteria met
+- [ ] All tests pass
+- [ ] Code quality checks pass
+
+## Reference Files
+
+- User Stories: \`.adf/sessions/${this.getSessionId()}/outputs/stories.md\`
+- Architecture: \`.adf/sessions/${this.getSessionId()}/outputs/architecture.md\`
+- PRD: \`.adf/sessions/${this.getSessionId()}/outputs/prd.md\`
+`;
+    }
+
+    return await this.writeToProject('.windsurf/workflows/implement-feature.md', content);
+  }
+
+  /**
+   * Extract tech stack from PRP sections
+   */
+  extractTechStack(sections) {
+    const contextualIntelligence = sections['3._contextual_intelligence'] ||
+                                   sections['contextual_intelligence'] || '';
+
+    // Look for tech stack mentions
+    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; // Limit lines
+      }
+      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 = WindsurfGenerator;

package/package.json

@@ -1,13 +1,14 @@
 {
   "name": "@iservu-inc/adf-cli",
-  "version": "0.1.6",
+  "version": "0.3.0",
   "description": "CLI tool for AgentDevFramework - AI-assisted development framework",
   "main": "index.js",
   "bin": {
     "adf": "bin/adf.js"
   },
   "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1"
+    "test": "jest --coverage",
+    "test:watch": "jest --watch"
   },
   "keywords": [
     "cli",
@@ -28,11 +29,11 @@
   "author": "iServU",
   "license": "MIT",
   "dependencies": {
-    "inquirer": "^8.2.5",
     "chalk": "^4.1.2",
-    "ora": "^5.4.1",
+    "commander": "^11.1.0",
     "fs-extra": "^11.2.0",
-    "commander": "^11.1.0"
+    "inquirer": "^8.2.5",
+    "ora": "^5.4.1"
   },
   "engines": {
     "node": ">=18.0.0",
@@ -48,5 +49,9 @@
   "homepage": "https://github.com/iservu/adf-cli#readme",
   "publishConfig": {
     "access": "public"
+  },
+  "devDependencies": {
+    "@types/node": "^24.6.2",
+    "jest": "^30.2.0"
   }
 }