opencode-conductor-cdd-plugin 1.0.0-beta.18 → 1.0.0-beta.19

package/dist/utils/setupIntegration.test.js

@@ -0,0 +1,344 @@
+import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import { setupProductGuide, setupGuidelines, setupTechStack, setupStyleguides, setupWorkflow, runFullSetup, } from './setupIntegration.js';
+describe('setupIntegration', () => {
+    const testOutputDir = path.join(process.cwd(), 'test-output-setup-integration');
+    const testProjectDir = path.join(testOutputDir, 'test-project');
+    beforeEach(() => {
+        // Create test directories
+        if (!fs.existsSync(testOutputDir)) {
+            fs.mkdirSync(testOutputDir, { recursive: true });
+        }
+        if (!fs.existsSync(testProjectDir)) {
+            fs.mkdirSync(testProjectDir, { recursive: true });
+        }
+    });
+    afterEach(() => {
+        // Clean up test files
+        if (fs.existsSync(testOutputDir)) {
+            fs.rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('setupProductGuide - End-to-End Integration', () => {
+        it('should generate product.md for greenfield project with user selections', async () => {
+            // Mock user responses: Select A, B, C for 3 questions
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']) // Question 1: Primary goal
+                .mockResolvedValueOnce(['B']) // Question 2: Target users
+                .mockResolvedValueOnce(['A']); // Question 3: Key features
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true, finalContent: undefined });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupProductGuide(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.1_product_guide');
+            expect(result.filePath).toContain('product.md');
+            // Verify file was created
+            const productPath = path.join(testProjectDir, 'conductor-cdd', 'product.md');
+            expect(fs.existsSync(productPath)).toBe(true);
+            // Verify state file was created
+            const statePath = path.join(testProjectDir, 'conductor-cdd', 'setup_state.json');
+            expect(fs.existsSync(statePath)).toBe(true);
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            expect(state.last_successful_step).toBe('2.1_product_guide');
+        });
+        it('should generate product.md for brownfield project with context awareness', async () => {
+            // Create brownfield project structure
+            const packageJson = {
+                name: 'test-app',
+                version: '1.0.0',
+                dependencies: {
+                    'react': '^18.0.0',
+                    'express': '^4.18.0',
+                },
+            };
+            fs.writeFileSync(path.join(testProjectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+            fs.mkdirSync(path.join(testProjectDir, 'src'), { recursive: true });
+            fs.writeFileSync(path.join(testProjectDir, 'src', 'index.ts'), 'console.log("test");');
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']) // Question 1
+                .mockResolvedValueOnce(['B']) // Question 2
+                .mockResolvedValueOnce(['A']); // Question 3
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupProductGuide(options);
+            expect(result.success).toBe(true);
+            expect(result.isBrownfield).toBe(true);
+            // Verify content includes detected technologies
+            const productPath = path.join(testProjectDir, 'conductor-cdd', 'product.md');
+            const content = fs.readFileSync(productPath, 'utf-8');
+            // Should detect context from package.json
+            expect(content.length).toBeGreaterThan(50);
+        });
+        it('should handle option E (auto-generate) early exit', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['E']); // Auto-generate immediately
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupProductGuide(options);
+            if (!result.success) {
+                console.error('[Test Debug] Option E test failed:', result.error);
+            }
+            expect(result.success).toBe(true);
+            expect(result.autoGenerated).toBe(true);
+            expect(mockResponder).toHaveBeenCalledTimes(1); // Only asked once
+            // Verify file was still created
+            const productPath = path.join(testProjectDir, 'conductor-cdd', 'product.md');
+            expect(fs.existsSync(productPath)).toBe(true);
+        });
+        it('should handle option D (custom input) with user text', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['D']) // Question 1: Custom input
+                .mockResolvedValueOnce(['A']) // Question 2
+                .mockResolvedValueOnce(['B']); // Question 3
+            const mockCustomInput = vi.fn()
+                .mockResolvedValueOnce('A revolutionary AI-powered task management platform');
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+                customInputPrompt: mockCustomInput,
+            };
+            const result = await setupProductGuide(options);
+            expect(result.success).toBe(true);
+            expect(mockCustomInput).toHaveBeenCalled();
+            const productPath = path.join(testProjectDir, 'conductor-cdd', 'product.md');
+            const content = fs.readFileSync(productPath, 'utf-8');
+            expect(content).toContain('AI-powered task management platform');
+        });
+        it('should handle approval rejection and revision loop', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']) // Question 1
+                .mockResolvedValueOnce(['B']) // Question 2
+                .mockResolvedValueOnce(['A']); // Question 3
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: false, revisionGuidance: 'Add more details about users' })
+                .mockResolvedValueOnce({ approved: true, finalContent: 'Revised content with more details' });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupProductGuide(options);
+            expect(result.success).toBe(true);
+            expect(result.revisionCount).toBe(1);
+            expect(mockApproval).toHaveBeenCalledTimes(2);
+            const productPath = path.join(testProjectDir, 'conductor-cdd', 'product.md');
+            const content = fs.readFileSync(productPath, 'utf-8');
+            expect(content).toContain('Revised content with more details');
+        });
+        it('should enforce max 5 questions limit', async () => {
+            // Setup to answer 10 times, but should only be asked 5
+            const mockResponder = vi.fn()
+                .mockResolvedValue(['A']);
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupProductGuide(options);
+            expect(result.success).toBe(true);
+            expect(mockResponder.mock.calls.length).toBeLessThanOrEqual(5);
+        });
+        it('should NOT include unselected options in final document', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValueOnce(['A']) // Question 1: Select only A
+                .mockResolvedValueOnce(['A']) // Question 2
+                .mockResolvedValueOnce(['A']); // Question 3
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupProductGuide(options);
+            expect(result.success).toBe(true);
+            const productPath = path.join(testProjectDir, 'conductor-cdd', 'product.md');
+            const content = fs.readFileSync(productPath, 'utf-8');
+            // Should NOT contain option markers
+            expect(content).not.toMatch(/\bA\)/);
+            expect(content).not.toMatch(/\bB\)/);
+            expect(content).not.toMatch(/\bC\)/);
+            expect(content).not.toMatch(/\bD\)/);
+            expect(content).not.toMatch(/\bE\)/);
+        });
+    });
+    describe('runFullSetup - Complete Workflow Integration', () => {
+        it('should generate all 5 documents in sequence', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValue(['A']); // Simple answer for all questions
+            const mockApproval = vi.fn()
+                .mockResolvedValue({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await runFullSetup(options);
+            expect(result.success).toBe(true);
+            expect(result.documentsCreated).toHaveLength(5);
+            // Verify all 5 documents were created
+            const cddDir = path.join(testProjectDir, 'conductor-cdd');
+            expect(fs.existsSync(path.join(cddDir, 'product.md'))).toBe(true);
+            expect(fs.existsSync(path.join(cddDir, 'guidelines.md'))).toBe(true);
+            expect(fs.existsSync(path.join(cddDir, 'tech-stack.md'))).toBe(true);
+            expect(fs.existsSync(path.join(cddDir, 'styleguides.md'))).toBe(true);
+            expect(fs.existsSync(path.join(cddDir, 'workflow.md'))).toBe(true);
+            // Verify final state
+            const statePath = path.join(cddDir, 'setup_state.json');
+            const state = JSON.parse(fs.readFileSync(statePath, 'utf-8'));
+            expect(state.last_successful_step).toBe('2.5_workflow');
+        });
+        it('should resume from checkpoint if interrupted', async () => {
+            // First, create partial state (stopped after product.md)
+            const cddDir = path.join(testProjectDir, 'conductor-cdd');
+            fs.mkdirSync(cddDir, { recursive: true });
+            const partialState = {
+                last_successful_step: '2.1_product_guide',
+                product_timestamp: new Date().toISOString(),
+            };
+            fs.writeFileSync(path.join(cddDir, 'setup_state.json'), JSON.stringify(partialState, null, 2));
+            // Mock responder should only be called for remaining sections
+            const mockResponder = vi.fn()
+                .mockResolvedValue(['A']);
+            const mockApproval = vi.fn()
+                .mockResolvedValue({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: cddDir,
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+                resume: true,
+            };
+            const result = await runFullSetup(options);
+            expect(result.success).toBe(true);
+            expect(result.resumed).toBe(true);
+            expect(result.resumedFrom).toBe('2.1_product_guide');
+            // Should have created remaining 4 documents
+            expect(result.documentsCreated).toHaveLength(4);
+        });
+        it('should handle failures and report partial completion', async () => {
+            const mockResponder = vi.fn()
+                .mockResolvedValue(['A']);
+            // Fail on guidelines approval
+            const mockApproval = vi.fn()
+                .mockResolvedValueOnce({ approved: true }) // product: success
+                .mockResolvedValue({ approved: false, revisionGuidance: 'Keep rejecting' }); // guidelines: fail
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+                maxRevisions: 2,
+            };
+            const result = await runFullSetup(options);
+            expect(result.success).toBe(false);
+            expect(result.documentsCreated.length).toBeLessThan(5);
+            expect(result.error).toContain('revision');
+            // Product should be created, but not all others
+            const cddDir = path.join(testProjectDir, 'conductor-cdd');
+            expect(fs.existsSync(path.join(cddDir, 'product.md'))).toBe(true);
+        });
+    });
+    describe('Individual Section Setup Functions', () => {
+        it('should setup guidelines.md independently', async () => {
+            const mockResponder = vi.fn().mockResolvedValue(['A']);
+            const mockApproval = vi.fn().mockResolvedValue({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupGuidelines(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.2_product_guidelines');
+            const guidelinesPath = path.join(testProjectDir, 'conductor-cdd', 'guidelines.md');
+            expect(fs.existsSync(guidelinesPath)).toBe(true);
+        });
+        it('should setup tech-stack.md with auto-detected dependencies', async () => {
+            // Create package.json for detection
+            const packageJson = {
+                name: 'test-app',
+                dependencies: {
+                    'react': '^18.0.0',
+                    'typescript': '^5.0.0',
+                },
+            };
+            fs.writeFileSync(path.join(testProjectDir, 'package.json'), JSON.stringify(packageJson, null, 2));
+            const mockResponder = vi.fn().mockResolvedValue(['E']); // Auto-generate
+            const mockApproval = vi.fn().mockResolvedValue({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupTechStack(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.3_tech_stack');
+            const techStackPath = path.join(testProjectDir, 'conductor-cdd', 'tech-stack.md');
+            const content = fs.readFileSync(techStackPath, 'utf-8');
+            // Should detect React and TypeScript
+            expect(content.toLowerCase()).toMatch(/react|typescript/);
+        });
+        it('should setup styleguides.md', async () => {
+            const mockResponder = vi.fn().mockResolvedValue(['A']);
+            const mockApproval = vi.fn().mockResolvedValue({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupStyleguides(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.4_code_styleguides');
+            const styleguidesPath = path.join(testProjectDir, 'conductor-cdd', 'styleguides.md');
+            expect(fs.existsSync(styleguidesPath)).toBe(true);
+        });
+        it('should setup workflow.md', async () => {
+            const mockResponder = vi.fn().mockResolvedValue(['A']);
+            const mockApproval = vi.fn().mockResolvedValue({ approved: true });
+            const options = {
+                projectPath: testProjectDir,
+                outputDir: path.join(testProjectDir, 'conductor-cdd'),
+                responder: mockResponder,
+                approvalFlow: mockApproval,
+            };
+            const result = await setupWorkflow(options);
+            expect(result.success).toBe(true);
+            expect(result.checkpoint).toBe('2.5_workflow');
+            const workflowPath = path.join(testProjectDir, 'conductor-cdd', 'workflow.md');
+            expect(fs.existsSync(workflowPath)).toBe(true);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-cdd-plugin",
-  "version": "1.0.0-beta.18",
+  "version": "1.0.0-beta.19",
   "description": "Context-Driven Development (CDD) plugin for OpenCode - Transform your AI coding workflow with structured specifications, plans, and implementation tracking",
   "type": "module",
   "repository": {