@iservu-inc/adf-cli 0.1.6 → 0.3.0

package/tests/windsurf-generator.test.js

@@ -0,0 +1,320 @@
+const fs = require('fs-extra');
+const path = require('path');
+const WindsurfGenerator = require('../lib/generators/windsurf-generator');
+
+const TEST_PROJECT_PATH = path.join(__dirname, 'test-project-windsurf');
+const TEST_SESSION_PATH = path.join(TEST_PROJECT_PATH, '.adf', 'sessions', 'test-session');
+
+describe('WindsurfGenerator', () => {
+  beforeEach(async () => {
+    // Clean up test directories
+    await fs.remove(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_PROJECT_PATH);
+    await fs.ensureDir(TEST_SESSION_PATH);
+    await fs.ensureDir(path.join(TEST_SESSION_PATH, 'outputs'));
+  });
+
+  afterEach(async () => {
+    // Clean up after tests
+    await fs.remove(TEST_PROJECT_PATH);
+  });
+
+  describe('PRP Framework', () => {
+    it('should generate Windsurf configurations from PRP output', async () => {
+      // Create mock PRP output
+      const prpContent = `# Product Requirement Prompt (PRP)
+
+## 1. Goal Definition
+Build a React dashboard that displays real-time analytics from PostgreSQL database.
+
+## 2. Business Justification
+This will help users make data-driven decisions and improve productivity.
+
+## 3. Contextual Intelligence
+### Technology Stack
+- Frontend: React 18, TypeScript
+- Backend: Node.js, Express
+- Database: PostgreSQL
+
+## 4. Implementation Blueprint
+### File Structure
+- src/components/Dashboard/
+- src/api/analytics/
+
+### Core Logic
+1. Fetch data from analytics API
+2. Process and aggregate
+3. Render charts
+
+## 5. Validation
+### Success Criteria
+- Dashboard loads in <2s
+- All charts render correctly
+`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      // Create metadata
+      await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+        framework: 'rapid',
+        projectName: 'Test Analytics Dashboard'
+      });
+
+      // Generate Windsurf configs
+      const generator = new WindsurfGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      const generated = await generator.generate();
+
+      // Verify .windsurfrules was created
+      const legacyPath = path.join(TEST_PROJECT_PATH, '.windsurfrules');
+      expect(await fs.pathExists(legacyPath)).toBe(true);
+
+      const legacyContent = await fs.readFile(legacyPath, 'utf-8');
+      expect(legacyContent).toContain('Test Analytics Dashboard');
+      expect(legacyContent).toContain('Project Goal');
+      expect(legacyContent).toContain('React dashboard');
+      expect(legacyContent).toContain('Tech Stack');
+      expect(legacyContent).toContain('AI Behavior');
+      expect(legacyContent).toContain('.adf/sessions/test-session/outputs/prp.md');
+
+      // Verify modern rules files (PRP only generates 2: project-context and architecture)
+      expect(generated.rules).toHaveLength(2);
+
+      // Verify project-context.md
+      const contextPath = path.join(TEST_PROJECT_PATH, '.windsurf', 'rules', 'project-context.md');
+      expect(await fs.pathExists(contextPath)).toBe(true);
+      const contextContent = await fs.readFile(contextPath, 'utf-8');
+      expect(contextContent).toContain('Project Context');
+      expect(contextContent).toContain('Goal');
+
+      // Verify architecture.md
+      const archPath = path.join(TEST_PROJECT_PATH, '.windsurf', 'rules', 'architecture.md');
+      expect(await fs.pathExists(archPath)).toBe(true);
+
+      // Verify workflows
+      expect(generated.workflows).toHaveLength(1); // Only review-requirements for rapid
+
+      const reviewWorkflowPath = path.join(TEST_PROJECT_PATH, '.windsurf', 'workflows', 'review-requirements.md');
+      expect(await fs.pathExists(reviewWorkflowPath)).toBe(true);
+      const reviewContent = await fs.readFile(reviewWorkflowPath, 'utf-8');
+      expect(reviewContent).toContain('Review Requirements');
+      expect(reviewContent).toContain('Steps');
+    });
+  });
+
+  describe('Balanced Framework', () => {
+    it('should generate Windsurf configurations from Balanced outputs', async () => {
+      // Create mock outputs
+      const constitutionContent = `# Constitution
+
+## Core Principles
+1. User privacy is paramount
+2. Performance over features
+
+## Constraints
+- No third-party analytics
+- WCAG 2.1 AA compliance
+`;
+
+      const specificationContent = `# Specification
+
+## Overview
+A comprehensive user management system.
+
+## Architecture
+Microservices architecture with API gateway.
+`;
+
+      const planContent = `# Technical Plan
+
+## Technology Stack
+- React 18
+- Node.js 20
+- PostgreSQL 15
+
+## Code Style
+- Use TypeScript strict mode
+- Follow Airbnb style guide
+`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'constitution.md'),
+        constitutionContent,
+        'utf-8'
+      );
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'specification.md'),
+        specificationContent,
+        'utf-8'
+      );
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'plan.md'),
+        planContent,
+        'utf-8'
+      );
+
+      await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+        framework: 'balanced',
+        projectName: 'User Management System'
+      });
+
+      // Generate Windsurf configs
+      const generator = new WindsurfGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'balanced');
+      const generated = await generator.generate();
+
+      // Verify .windsurfrules
+      const legacyPath = path.join(TEST_PROJECT_PATH, '.windsurfrules');
+      const legacyContent = await fs.readFile(legacyPath, 'utf-8');
+      expect(legacyContent).toContain('Core Principles');
+      expect(legacyContent).toContain('User privacy is paramount');
+      expect(legacyContent).toContain('Constraints');
+      expect(legacyContent).toContain('constitution.md');
+      expect(legacyContent).toContain('specification.md');
+      expect(legacyContent).toContain('plan.md');
+
+      // Verify workflows (Balanced should have 2 workflows)
+      expect(generated.workflows).toHaveLength(2);
+
+      const implementWorkflowPath = path.join(TEST_PROJECT_PATH, '.windsurf', 'workflows', 'implement-feature.md');
+      expect(await fs.pathExists(implementWorkflowPath)).toBe(true);
+    });
+  });
+
+  describe('BMAD Framework', () => {
+    it('should generate Windsurf configurations from BMAD outputs', async () => {
+      // Create mock outputs
+      const prdContent = `# Product Requirements Document
+
+## Executive Summary
+A complete e-commerce platform for small businesses.
+
+## Goals and Objectives
+- Enable online sales
+- Provide analytics
+
+## Technical Requirements
+- RESTful API
+- Payment gateway integration
+`;
+
+      const architectureContent = `# System Architecture
+
+## System Overview
+Modular monolith architecture with separate domains.
+
+## Components
+- Order Management
+- Inventory System
+- Payment Processing
+`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prd.md'),
+        prdContent,
+        'utf-8'
+      );
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'architecture.md'),
+        architectureContent,
+        'utf-8'
+      );
+
+      await fs.writeJson(path.join(TEST_SESSION_PATH, '_metadata.json'), {
+        framework: 'comprehensive',
+        projectName: 'E-commerce Platform'
+      });
+
+      // Generate Windsurf configs
+      const generator = new WindsurfGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'comprehensive');
+      const generated = await generator.generate();
+
+      // Verify .windsurfrules
+      const legacyPath = path.join(TEST_PROJECT_PATH, '.windsurfrules');
+      const legacyContent = await fs.readFile(legacyPath, 'utf-8');
+      expect(legacyContent).toContain('E-commerce Platform');
+      expect(legacyContent).toContain('Product Overview');
+      expect(legacyContent).toContain('e-commerce platform');
+      expect(legacyContent).toContain('prd.md');
+      expect(legacyContent).toContain('architecture.md');
+
+      // Verify workflows (BMAD should have 2 workflows)
+      expect(generated.workflows).toHaveLength(2);
+    });
+  });
+
+  describe('Character Limits', () => {
+    it('should respect 12,000 character limit per rule file', async () => {
+      // Create a very long PRP
+      const longContent = `# PRP\n\n## 1. Goal Definition\n${'x'.repeat(5000)}\n\n## 4. Implementation Blueprint\n${'y'.repeat(5000)}`;
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        longContent,
+        'utf-8'
+      );
+
+      const generator = new WindsurfGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      // Verify each rule file is under 12,000 characters
+      const rulesDir = path.join(TEST_PROJECT_PATH, '.windsurf', 'rules');
+      const ruleFiles = await fs.readdir(rulesDir);
+
+      for (const file of ruleFiles) {
+        const content = await fs.readFile(path.join(rulesDir, file), 'utf-8');
+        expect(content.length).toBeLessThan(12000);
+      }
+    });
+  });
+
+  describe('Template Variables', () => {
+    it('should replace session ID in paths', async () => {
+      const prpContent = '# PRP\n\n## 1. Goal Definition\nTest project';
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      const generator = new WindsurfGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const legacyContent = await fs.readFile(
+        path.join(TEST_PROJECT_PATH, '.windsurfrules'),
+        'utf-8'
+      );
+
+      // Should contain the actual session ID, not a template variable
+      expect(legacyContent).toContain('test-session');
+      expect(legacyContent).not.toContain('{SESSION_ID}');
+    });
+
+    it('should include ADF CLI version', async () => {
+      const prpContent = '# PRP\n\n## 1. Goal Definition\nTest';
+
+      await fs.writeFile(
+        path.join(TEST_SESSION_PATH, 'outputs', 'prp.md'),
+        prpContent,
+        'utf-8'
+      );
+
+      const generator = new WindsurfGenerator(TEST_SESSION_PATH, TEST_PROJECT_PATH, 'rapid');
+      await generator.generate();
+
+      const legacyContent = await fs.readFile(
+        path.join(TEST_PROJECT_PATH, '.windsurfrules'),
+        'utf-8'
+      );
+
+      expect(legacyContent).toContain('Generated by');
+      expect(legacyContent).toContain('ADF CLI');
+    });
+  });
+});