opencode-conductor-cdd-plugin 1.0.0-beta.17 → 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/dist/utils/statusDisplay.d.ts

@@ -0,0 +1,35 @@
+export interface TrackStatusInfo {
+    trackId: string;
+    trackName: string;
+    totalTasks: number;
+    completedTasks: number;
+    inProgressTasks: number;
+    currentPhase: string;
+    lastUpdated: string;
+}
+export interface StatusFormatOptions {
+    compact?: boolean;
+    noColor?: boolean;
+    barLength?: number;
+}
+/**
+ * Calculates progress percentage
+ * @param completed Number of completed items
+ * @param total Total number of items
+ * @returns Progress percentage (0-100)
+ */
+export declare function calculateProgress(completed: number, total: number): number;
+/**
+ * Generates a visual progress bar
+ * @param percentage Progress percentage (0-100)
+ * @param length Length of the progress bar (default: 20)
+ * @returns Progress bar string
+ */
+export declare function generateProgressBar(percentage: number, length?: number): string;
+/**
+ * Formats track status into a visually appealing display
+ * @param track Track status information
+ * @param options Formatting options
+ * @returns Formatted status string
+ */
+export declare function formatTrackStatus(track: TrackStatusInfo, options?: StatusFormatOptions): string;

package/dist/utils/statusDisplay.js

@@ -0,0 +1,81 @@
+// ANSI color codes
+const colors = {
+    reset: "\x1b[0m",
+    bright: "\x1b[1m",
+    dim: "\x1b[2m",
+    green: "\x1b[32m",
+    yellow: "\x1b[33m",
+    blue: "\x1b[34m",
+    cyan: "\x1b[36m",
+    gray: "\x1b[90m"
+};
+/**
+ * Calculates progress percentage
+ * @param completed Number of completed items
+ * @param total Total number of items
+ * @returns Progress percentage (0-100)
+ */
+export function calculateProgress(completed, total) {
+    if (total === 0)
+        return 0;
+    return Math.round((completed / total) * 100);
+}
+/**
+ * Generates a visual progress bar
+ * @param percentage Progress percentage (0-100)
+ * @param length Length of the progress bar (default: 20)
+ * @returns Progress bar string
+ */
+export function generateProgressBar(percentage, length = 20) {
+    const filled = Math.round((percentage / 100) * length);
+    const empty = length - filled;
+    return "█".repeat(filled) + "░".repeat(empty);
+}
+/**
+ * Formats track status into a visually appealing display
+ * @param track Track status information
+ * @param options Formatting options
+ * @returns Formatted status string
+ */
+export function formatTrackStatus(track, options = {}) {
+    const { compact = false, noColor = false, barLength = 20 } = options;
+    const c = noColor
+        ? {
+            reset: "",
+            bright: "",
+            dim: "",
+            green: "",
+            yellow: "",
+            blue: "",
+            cyan: "",
+            gray: ""
+        }
+        : colors;
+    const progress = calculateProgress(track.completedTasks, track.totalTasks);
+    const progressBar = generateProgressBar(progress, barLength);
+    if (compact) {
+        return `${c.bright}${track.trackName}${c.reset} ${c.gray}[${track.trackId}]${c.reset}
+${c.cyan}${track.currentPhase}${c.reset} ${c.dim}|${c.reset} ${c.green}${track.completedTasks}${c.reset}/${track.totalTasks} tasks ${c.dim}(${progress}%)${c.reset}`;
+    }
+    const inProgressInfo = track.inProgressTasks > 0 ? `, ${track.inProgressTasks} in progress` : "";
+    const formattedDate = new Date(track.lastUpdated).toLocaleString("en-US", {
+        year: "numeric",
+        month: "short",
+        day: "numeric",
+        hour: "2-digit",
+        minute: "2-digit"
+    });
+    return `${c.bright}${c.blue}━━━ Track Status ━━━${c.reset}
+
+${c.bright}Track:${c.reset} ${track.trackName}
+${c.dim}ID: ${track.trackId}${c.reset}
+
+${c.bright}Phase:${c.reset} ${c.cyan}${track.currentPhase}${c.reset}
+
+${c.bright}Progress:${c.reset} ${c.green}${track.completedTasks}${c.reset}/${track.totalTasks} tasks ${c.dim}(${progress}%)${c.reset}${inProgressInfo}
+${progressBar}
+
+${c.gray}Last updated: ${formattedDate}${c.reset}
+
+${c.bright}${c.blue}━━━━━━━━━━━━━━━━━━━━${c.reset}`;
+}

package/dist/utils/statusDisplay.test.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/utils/statusDisplay.test.js

@@ -0,0 +1,102 @@
+import { describe, it, expect } from "vitest";
+import { formatTrackStatus, calculateProgress, generateProgressBar } from "./statusDisplay.js";
+describe("statusDisplay", () => {
+    describe("calculateProgress", () => {
+        it("should calculate progress percentage correctly", () => {
+            expect(calculateProgress(3, 10)).toBe(30);
+            expect(calculateProgress(5, 5)).toBe(100);
+            expect(calculateProgress(0, 10)).toBe(0);
+        });
+        it("should handle zero total gracefully", () => {
+            expect(calculateProgress(0, 0)).toBe(0);
+        });
+        it("should round to nearest integer", () => {
+            expect(calculateProgress(1, 3)).toBe(33);
+            expect(calculateProgress(2, 3)).toBe(67);
+        });
+    });
+    describe("generateProgressBar", () => {
+        it("should generate a progress bar with default length", () => {
+            const bar = generateProgressBar(50);
+            expect(bar).toHaveLength(20); // Default bar length
+            expect(bar).toContain("█");
+            expect(bar).toContain("░");
+        });
+        it("should generate full bar at 100%", () => {
+            const bar = generateProgressBar(100, 10);
+            expect(bar).toBe("██████████");
+        });
+        it("should generate empty bar at 0%", () => {
+            const bar = generateProgressBar(0, 10);
+            expect(bar).toBe("░░░░░░░░░░");
+        });
+        it("should handle custom bar length", () => {
+            const bar = generateProgressBar(50, 30);
+            expect(bar).toHaveLength(30);
+        });
+        it("should show correct filled/unfilled ratio", () => {
+            const bar = generateProgressBar(25, 8);
+            expect(bar).toBe("██░░░░░░"); // 25% of 8 = 2 filled
+        });
+    });
+    describe("formatTrackStatus", () => {
+        const sampleTrack = {
+            trackId: "track_test_123",
+            trackName: "Implement Authentication",
+            totalTasks: 10,
+            completedTasks: 7,
+            inProgressTasks: 1,
+            currentPhase: "Phase 2: Implementation",
+            lastUpdated: "2026-01-18T12:00:00Z"
+        };
+        it("should format a complete track status display", () => {
+            const status = formatTrackStatus(sampleTrack);
+            expect(status).toContain("Implement Authentication");
+            expect(status).toContain("Phase 2: Implementation");
+            expect(status).toMatch(/7.*\/.*10.*tasks/); // Match "7/10 tasks" with potential ANSI codes
+            expect(status).toContain("█"); // Progress bar
+            expect(status).toContain("Last updated:");
+        });
+        it("should show 100% completion for fully complete track", () => {
+            const completeTrack = {
+                ...sampleTrack,
+                completedTasks: 10,
+                inProgressTasks: 0,
+                currentPhase: "Completed"
+            };
+            const status = formatTrackStatus(completeTrack);
+            expect(status).toContain("100%");
+            expect(status).toMatch(/10.*\/.*10.*tasks/); // Match "10/10 tasks" with potential ANSI codes
+        });
+        it("should indicate in-progress tasks", () => {
+            const status = formatTrackStatus(sampleTrack);
+            expect(status).toContain("1 in progress");
+        });
+        it("should handle track with no tasks", () => {
+            const emptyTrack = {
+                ...sampleTrack,
+                totalTasks: 0,
+                completedTasks: 0,
+                inProgressTasks: 0
+            };
+            const status = formatTrackStatus(emptyTrack);
+            expect(status).toMatch(/0.*\/.*0.*tasks/); // Match "0/0 tasks" with potential ANSI codes
+            expect(status).toContain("0%");
+        });
+        it("should include color indicators in status (ANSI codes)", () => {
+            const status = formatTrackStatus(sampleTrack);
+            // Should contain ANSI escape codes for colors
+            expect(status).toMatch(/\x1b\[\d+m/); // Contains ANSI color codes
+        });
+        it("should format status with compact mode option", () => {
+            const status = formatTrackStatus(sampleTrack, { compact: true });
+            // Compact mode should be shorter (no progress bar or timestamps)
+            expect(status.split("\n").length).toBeLessThan(5);
+        });
+        it("should allow disabling color output", () => {
+            const status = formatTrackStatus(sampleTrack, { noColor: true });
+            // Should not contain ANSI escape codes
+            expect(status).not.toMatch(/\x1b\[\d+m/);
+        });
+    });
+});

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opencode-conductor-cdd-plugin",
-  "version": "1.0.0-beta.17",
+  "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": {