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

package/dist/utils/interactiveSetup.test.js

@@ -0,0 +1,124 @@
+import { describe, it, expect, beforeEach, afterEach } from 'vitest';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+import { executeInteractiveSetup, generateSetupSummary, } from './interactiveSetup.js';
+describe('interactiveSetup', () => {
+    let testOutputDir;
+    let testProjectDir;
+    beforeEach(() => {
+        testOutputDir = path.join(os.tmpdir(), 'cdd-interactive-setup-test');
+        testProjectDir = path.join(testOutputDir, 'test-project');
+        if (fs.existsSync(testOutputDir)) {
+            fs.rmSync(testOutputDir, { recursive: true, force: true });
+        }
+        fs.mkdirSync(testProjectDir, { recursive: true });
+    });
+    afterEach(() => {
+        if (fs.existsSync(testOutputDir)) {
+            fs.rmSync(testOutputDir, { recursive: true, force: true });
+        }
+    });
+    describe('executeInteractiveSetup', () => {
+        it('should return success result when setup completes', async () => {
+            // Mock runFullSetup to return success
+            const { executeInteractiveSetup } = await import('./interactiveSetup.js');
+            const config = {
+                projectPath: testProjectDir,
+            };
+            const result = await executeInteractiveSetup(config);
+            // Note: This will use default responder which returns empty arrays
+            // In actual implementation, we need to mock the responder properly
+            expect(result).toHaveProperty('success');
+            expect(result).toHaveProperty('message');
+            expect(result).toHaveProperty('documentsCreated');
+        });
+        it('should use custom outputDir when provided', async () => {
+            const customOutputDir = path.join(testProjectDir, 'custom-cdd');
+            const config = {
+                projectPath: testProjectDir,
+                outputDir: customOutputDir,
+            };
+            await executeInteractiveSetup(config);
+            // Verify outputDir was used (will be created by setupIntegration)
+            // This is just a smoke test - full integration tested in setupIntegration.test.ts
+            expect(true).toBe(true);
+        });
+        it('should handle resume flag', async () => {
+            const config = {
+                projectPath: testProjectDir,
+                resume: true,
+            };
+            const result = await executeInteractiveSetup(config);
+            expect(result).toHaveProperty('resumed');
+        });
+        it('should handle errors gracefully', async () => {
+            // Pass invalid projectPath to trigger error
+            const config = {
+                projectPath: '/nonexistent/path/that/does/not/exist',
+            };
+            const result = await executeInteractiveSetup(config);
+            expect(result.success).toBe(false);
+            expect(result.message).toBeTruthy();
+            expect(result.errors).toBeDefined();
+        });
+    });
+    describe('generateSetupSummary', () => {
+        it('should generate success summary with documents', () => {
+            const result = {
+                success: true,
+                message: 'Setup complete',
+                documentsCreated: [
+                    '/path/to/product.md',
+                    '/path/to/guidelines.md',
+                    '/path/to/tech-stack.md',
+                ],
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('✅ CDD Setup Complete!');
+            expect(summary).toContain('product.md');
+            expect(summary).toContain('guidelines.md');
+            expect(summary).toContain('tech-stack.md');
+            expect(summary).toContain('Next steps:');
+        });
+        it('should generate success summary with resume info', () => {
+            const result = {
+                success: true,
+                message: 'Setup complete',
+                documentsCreated: ['/path/to/guidelines.md'],
+                resumed: true,
+                resumedFrom: '2.1_product_guide',
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('Resumed from checkpoint');
+            expect(summary).toContain('2.1_product_guide');
+        });
+        it('should generate failure summary with partial completion', () => {
+            const result = {
+                success: false,
+                message: 'Setup failed at guidelines',
+                documentsCreated: ['/path/to/product.md'],
+                errors: ['Approval rejected 3 times'],
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('❌ CDD Setup Failed');
+            expect(summary).toContain('Setup failed at guidelines');
+            expect(summary).toContain('Partially completed');
+            expect(summary).toContain('product.md');
+            expect(summary).toContain('resume setup');
+            expect(summary).toContain('Approval rejected 3 times');
+        });
+        it('should generate failure summary with no documents', () => {
+            const result = {
+                success: false,
+                message: 'Project path does not exist',
+                documentsCreated: [],
+                errors: ['ENOENT: no such file or directory'],
+            };
+            const summary = generateSetupSummary(result);
+            expect(summary).toContain('❌ CDD Setup Failed');
+            expect(summary).toContain('Project path does not exist');
+            expect(summary).toContain('ENOENT');
+        });
+    });
+});

package/dist/utils/metadataTracker.d.ts

@@ -0,0 +1,39 @@
+export type TaskStatus = "pending" | "in_progress" | "completed" | "cancelled";
+export type PhaseStatus = "pending" | "in_progress" | "completed";
+export interface TaskMetadata {
+    taskId: string;
+    taskName: string;
+    status: TaskStatus;
+    commitSha?: string;
+    startedAt?: string;
+    completedAt?: string;
+}
+export interface PhaseMetadata {
+    phaseId: string;
+    phaseName: string;
+    status: PhaseStatus;
+    checkpointSha?: string;
+    tasks: TaskMetadata[];
+}
+export interface TrackMetadata {
+    trackId: string;
+    trackName: string;
+    phases: PhaseMetadata[];
+    createdAt: string;
+    updatedAt: string;
+    completedAt?: string;
+}
+export declare class MetadataTracker {
+    private workDir;
+    private trackId;
+    private metadataPath;
+    constructor(workDir: string, trackId: string);
+    private ensureDirectory;
+    initializeMetadata(metadata: TrackMetadata): void;
+    readMetadata(): TrackMetadata | null;
+    private writeMetadata;
+    updateTaskStatus(phaseId: string, taskId: string, status: TaskStatus, commitSha?: string): void;
+    updatePhaseStatus(phaseId: string, status: PhaseStatus, checkpointSha?: string): void;
+    getActivePhase(): PhaseMetadata | null;
+    getActiveTask(): TaskMetadata | null;
+}

package/dist/utils/metadataTracker.js

@@ -0,0 +1,105 @@
+import { join } from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync } from "fs";
+export class MetadataTracker {
+    workDir;
+    trackId;
+    metadataPath;
+    constructor(workDir, trackId) {
+        this.workDir = workDir;
+        this.trackId = trackId;
+        this.metadataPath = join(workDir, "conductor-cdd", "tracks", trackId, "status.json");
+    }
+    ensureDirectory() {
+        const dir = join(this.metadataPath, "..");
+        if (!existsSync(dir)) {
+            mkdirSync(dir, { recursive: true });
+        }
+    }
+    initializeMetadata(metadata) {
+        this.ensureDirectory();
+        writeFileSync(this.metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    readMetadata() {
+        if (!existsSync(this.metadataPath)) {
+            return null;
+        }
+        try {
+            return JSON.parse(readFileSync(this.metadataPath, "utf-8"));
+        }
+        catch (e) {
+            return null;
+        }
+    }
+    writeMetadata(metadata) {
+        metadata.updatedAt = new Date().toISOString();
+        writeFileSync(this.metadataPath, JSON.stringify(metadata, null, 2));
+    }
+    updateTaskStatus(phaseId, taskId, status, commitSha) {
+        const metadata = this.readMetadata();
+        if (!metadata) {
+            throw new Error("Metadata file does not exist. Initialize first.");
+        }
+        const phase = metadata.phases.find(p => p.phaseId === phaseId);
+        if (!phase) {
+            throw new Error(`Phase '${phaseId}' not found`);
+        }
+        const task = phase.tasks.find(t => t.taskId === taskId);
+        if (!task) {
+            throw new Error(`Task '${taskId}' not found in phase '${phaseId}'`);
+        }
+        task.status = status;
+        if (commitSha) {
+            task.commitSha = commitSha;
+        }
+        if (status === "in_progress" && !task.startedAt) {
+            task.startedAt = new Date().toISOString();
+        }
+        if (status === "completed") {
+            task.completedAt = new Date().toISOString();
+        }
+        this.writeMetadata(metadata);
+    }
+    updatePhaseStatus(phaseId, status, checkpointSha) {
+        const metadata = this.readMetadata();
+        if (!metadata) {
+            throw new Error("Metadata file does not exist. Initialize first.");
+        }
+        const phase = metadata.phases.find(p => p.phaseId === phaseId);
+        if (!phase) {
+            throw new Error(`Phase '${phaseId}' not found`);
+        }
+        phase.status = status;
+        if (checkpointSha) {
+            phase.checkpointSha = checkpointSha;
+        }
+        this.writeMetadata(metadata);
+    }
+    getActivePhase() {
+        const metadata = this.readMetadata();
+        if (!metadata) {
+            return null;
+        }
+        // First look for in_progress phase
+        const inProgressPhase = metadata.phases.find(p => p.status === "in_progress");
+        if (inProgressPhase) {
+            return inProgressPhase;
+        }
+        // Then look for first pending phase
+        const pendingPhase = metadata.phases.find(p => p.status === "pending");
+        return pendingPhase || null;
+    }
+    getActiveTask() {
+        const activePhase = this.getActivePhase();
+        if (!activePhase) {
+            return null;
+        }
+        // First look for in_progress task
+        const inProgressTask = activePhase.tasks.find(t => t.status === "in_progress");
+        if (inProgressTask) {
+            return inProgressTask;
+        }
+        // Then look for first pending task
+        const pendingTask = activePhase.tasks.find(t => t.status === "pending");
+        return pendingTask || null;
+    }
+}

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

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

package/dist/utils/metadataTracker.test.js

@@ -0,0 +1,265 @@
+import { describe, it, expect, beforeEach, afterEach } from "vitest";
+import { mkdirSync, rmSync, existsSync, readFileSync } from "fs";
+import { join } from "path";
+import { MetadataTracker } from "./metadataTracker.js";
+describe("MetadataTracker", () => {
+    const testDir = join(process.cwd(), "test-metadata-tracker");
+    const trackId = "track_test_123";
+    let tracker;
+    beforeEach(() => {
+        // Create test directory
+        mkdirSync(testDir, { recursive: true });
+        tracker = new MetadataTracker(testDir, trackId);
+    });
+    afterEach(() => {
+        // Clean up
+        rmSync(testDir, { recursive: true, force: true });
+    });
+    describe("initializeMetadata", () => {
+        it("should create a status.json file with initial metadata", () => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "pending",
+                        tasks: [
+                            {
+                                taskId: "task1",
+                                taskName: "Task 1",
+                                status: "pending"
+                            }
+                        ]
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+            const metadataPath = join(testDir, "conductor-cdd", "tracks", trackId, "status.json");
+            expect(existsSync(metadataPath)).toBe(true);
+            const savedMetadata = JSON.parse(readFileSync(metadataPath, "utf-8"));
+            expect(savedMetadata.trackId).toBe(trackId);
+            expect(savedMetadata.trackName).toBe("Test Track");
+            expect(savedMetadata.phases).toHaveLength(1);
+        });
+    });
+    describe("updateTaskStatus", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "pending",
+                        tasks: [
+                            {
+                                taskId: "task1",
+                                taskName: "Task 1",
+                                status: "pending"
+                            },
+                            {
+                                taskId: "task2",
+                                taskName: "Task 2",
+                                status: "pending"
+                            }
+                        ]
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should update a task status from pending to in_progress", () => {
+            tracker.updateTaskStatus("phase1", "task1", "in_progress");
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            const task = metadata.phases[0].tasks.find((t) => t.taskId === "task1");
+            expect(task?.status).toBe("in_progress");
+        });
+        it("should update a task status from in_progress to completed with commit SHA", () => {
+            tracker.updateTaskStatus("phase1", "task1", "in_progress");
+            tracker.updateTaskStatus("phase1", "task1", "completed", "abc1234");
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            const task = metadata.phases[0].tasks.find((t) => t.taskId === "task1");
+            expect(task?.status).toBe("completed");
+            expect(task?.commitSha).toBe("abc1234");
+        });
+        it("should update the updatedAt timestamp", async () => {
+            // Wait a small amount to ensure timestamp changes
+            const beforeUpdate = tracker.readMetadata().updatedAt;
+            await new Promise(resolve => setTimeout(resolve, 10));
+            tracker.updateTaskStatus("phase1", "task1", "in_progress");
+            const afterUpdate = tracker.readMetadata().updatedAt;
+            expect(afterUpdate).not.toBe(beforeUpdate);
+        });
+        it("should throw error if phase does not exist", () => {
+            expect(() => {
+                tracker.updateTaskStatus("invalid_phase", "task1", "in_progress");
+            }).toThrow("Phase 'invalid_phase' not found");
+        });
+        it("should throw error if task does not exist", () => {
+            expect(() => {
+                tracker.updateTaskStatus("phase1", "invalid_task", "in_progress");
+            }).toThrow("Task 'invalid_task' not found in phase 'phase1'");
+        });
+    });
+    describe("updatePhaseStatus", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "pending",
+                        tasks: []
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should update a phase status to completed with checkpoint SHA", () => {
+            tracker.updatePhaseStatus("phase1", "completed", "def5678");
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            const phase = metadata.phases.find((p) => p.phaseId === "phase1");
+            expect(phase?.status).toBe("completed");
+            expect(phase?.checkpointSha).toBe("def5678");
+        });
+        it("should throw error if phase does not exist", () => {
+            expect(() => {
+                tracker.updatePhaseStatus("invalid_phase", "completed");
+            }).toThrow("Phase 'invalid_phase' not found");
+        });
+    });
+    describe("readMetadata", () => {
+        it("should return null if status.json does not exist", () => {
+            const metadata = tracker.readMetadata();
+            expect(metadata).toBeNull();
+        });
+        it("should return parsed metadata if status.json exists", () => {
+            const initialMetadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(initialMetadata);
+            const metadata = tracker.readMetadata();
+            expect(metadata).not.toBeNull();
+            expect(metadata?.trackId).toBe(trackId);
+        });
+    });
+    describe("getActivePhase", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "completed",
+                        tasks: []
+                    },
+                    {
+                        phaseId: "phase2",
+                        phaseName: "Phase 2: Implementation",
+                        status: "in_progress",
+                        tasks: []
+                    },
+                    {
+                        phaseId: "phase3",
+                        phaseName: "Phase 3: Testing",
+                        status: "pending",
+                        tasks: []
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should return the first in_progress phase", () => {
+            const activePhase = tracker.getActivePhase();
+            expect(activePhase?.phaseId).toBe("phase2");
+        });
+        it("should return the first pending phase if no in_progress phase exists", () => {
+            tracker.updatePhaseStatus("phase2", "completed");
+            const activePhase = tracker.getActivePhase();
+            expect(activePhase?.phaseId).toBe("phase3");
+        });
+        it("should return null if all phases are completed", () => {
+            tracker.updatePhaseStatus("phase2", "completed");
+            tracker.updatePhaseStatus("phase3", "completed");
+            const activePhase = tracker.getActivePhase();
+            expect(activePhase).toBeNull();
+        });
+    });
+    describe("getActiveTask", () => {
+        beforeEach(() => {
+            const metadata = {
+                trackId: trackId,
+                trackName: "Test Track",
+                phases: [
+                    {
+                        phaseId: "phase1",
+                        phaseName: "Phase 1: Setup",
+                        status: "in_progress",
+                        tasks: [
+                            {
+                                taskId: "task1",
+                                taskName: "Task 1",
+                                status: "completed"
+                            },
+                            {
+                                taskId: "task2",
+                                taskName: "Task 2",
+                                status: "in_progress"
+                            },
+                            {
+                                taskId: "task3",
+                                taskName: "Task 3",
+                                status: "pending"
+                            }
+                        ]
+                    }
+                ],
+                createdAt: new Date().toISOString(),
+                updatedAt: new Date().toISOString()
+            };
+            tracker.initializeMetadata(metadata);
+        });
+        it("should return the first in_progress task in the active phase", () => {
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask?.taskId).toBe("task2");
+        });
+        it("should return the first pending task if no in_progress task exists", () => {
+            tracker.updateTaskStatus("phase1", "task2", "completed");
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask?.taskId).toBe("task3");
+        });
+        it("should return null if all tasks in active phase are completed", () => {
+            tracker.updateTaskStatus("phase1", "task2", "completed");
+            tracker.updateTaskStatus("phase1", "task3", "completed");
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask).toBeNull();
+        });
+        it("should return null if there is no active phase", () => {
+            tracker.updatePhaseStatus("phase1", "completed");
+            const activeTask = tracker.getActiveTask();
+            expect(activeTask).toBeNull();
+        });
+    });
+});

package/dist/utils/planParser.d.ts

@@ -0,0 +1,25 @@
+export interface PlanPhase {
+    phaseId: string;
+    phaseName: string;
+    content: string;
+}
+/**
+ * Adds machine-parsable XML-style delimiters around each phase in a plan.md file
+ * @param planContent The original plan.md content
+ * @returns The plan content with phase delimiters added
+ */
+export declare function addPhaseDelimiters(planContent: string): string;
+/**
+ * Extracts the active phase from a delimited plan
+ * Active phase is the first in-progress phase, or first pending phase if none in progress
+ * @param delimitedPlan Plan content with phase delimiters
+ * @returns The active phase or null if all phases complete
+ */
+export declare function extractActivePhase(delimitedPlan: string): PlanPhase | null;
+/**
+ * Extracts a specific phase by name (case-insensitive partial match)
+ * @param delimitedPlan Plan content with phase delimiters
+ * @param phaseName Name or partial name of the phase
+ * @returns The matching phase or null
+ */
+export declare function extractPhaseByName(delimitedPlan: string, phaseName: string): PlanPhase | null;

package/dist/utils/planParser.js

@@ -0,0 +1,107 @@
+/**
+ * Adds machine-parsable XML-style delimiters around each phase in a plan.md file
+ * @param planContent The original plan.md content
+ * @returns The plan content with phase delimiters added
+ */
+export function addPhaseDelimiters(planContent) {
+    const lines = planContent.split("\n");
+    const result = [];
+    let phaseCounter = 0;
+    let inPhase = false;
+    let currentPhaseId = "";
+    for (let i = 0; i < lines.length; i++) {
+        const line = lines[i];
+        // Detect phase header (## Phase X: ...)
+        const phaseMatch = line.match(/^##\s+Phase\s+\d+:/i);
+        if (phaseMatch) {
+            // Close previous phase if exists
+            if (inPhase) {
+                result.push(`<!-- PHASE_END:${currentPhaseId} -->`);
+            }
+            // Start new phase
+            phaseCounter++;
+            currentPhaseId = `phase${phaseCounter}`;
+            result.push(`<!-- PHASE_START:${currentPhaseId} -->`);
+            result.push(line);
+            inPhase = true;
+        }
+        else {
+            result.push(line);
+            // Close phase if we hit the next phase or end of file
+            if (inPhase && i === lines.length - 1) {
+                result.push(`<!-- PHASE_END:${currentPhaseId} -->`);
+            }
+        }
+        // Check if next line is a new phase header to close current phase
+        if (inPhase && i + 1 < lines.length) {
+            const nextLine = lines[i + 1];
+            const nextPhaseMatch = nextLine.match(/^##\s+Phase\s+\d+:/i);
+            if (nextPhaseMatch) {
+                result.push(`<!-- PHASE_END:${currentPhaseId} -->`);
+                inPhase = false;
+            }
+        }
+    }
+    return result.join("\n");
+}
+/**
+ * Extracts the active phase from a delimited plan
+ * Active phase is the first in-progress phase, or first pending phase if none in progress
+ * @param delimitedPlan Plan content with phase delimiters
+ * @returns The active phase or null if all phases complete
+ */
+export function extractActivePhase(delimitedPlan) {
+    const phases = extractAllPhases(delimitedPlan);
+    if (phases.length === 0) {
+        return null;
+    }
+    // Find first in-progress phase (contains [~])
+    const inProgressPhase = phases.find(p => p.content.includes("[~]"));
+    if (inProgressPhase) {
+        return inProgressPhase;
+    }
+    // Find first pending phase (contains [ ] but no checkpoint marker)
+    const pendingPhase = phases.find(p => {
+        const hasIncompleteTasks = p.content.includes("[ ]");
+        const hasCheckpoint = p.content.includes("[checkpoint:");
+        return hasIncompleteTasks || !hasCheckpoint;
+    });
+    return pendingPhase || null;
+}
+/**
+ * Extracts a specific phase by name (case-insensitive partial match)
+ * @param delimitedPlan Plan content with phase delimiters
+ * @param phaseName Name or partial name of the phase
+ * @returns The matching phase or null
+ */
+export function extractPhaseByName(delimitedPlan, phaseName) {
+    const phases = extractAllPhases(delimitedPlan);
+    const normalizedName = phaseName.toLowerCase();
+    return (phases.find(p => p.phaseName.toLowerCase().includes(normalizedName)) || null);
+}
+/**
+ * Extracts all phases from a delimited plan
+ * @param delimitedPlan Plan content with phase delimiters
+ * @returns Array of all phases
+ */
+function extractAllPhases(delimitedPlan) {
+    const phases = [];
+    const phaseRegex = /<!-- PHASE_START:(\w+) -->[\s\S]*?<!-- PHASE_END:\1 -->/g;
+    const matches = delimitedPlan.matchAll(phaseRegex);
+    for (const match of matches) {
+        const phaseId = match[1];
+        const content = match[0];
+        // Extract phase name from the content
+        const nameMatch = content.match(/^<!-- PHASE_START:\w+ -->\s*\n##\s+(.+)$/m);
+        const phaseName = nameMatch ? nameMatch[1].trim() : phaseId;
+        phases.push({
+            phaseId,
+            phaseName,
+            content: content
+                .replace(/<!-- PHASE_START:\w+ -->\n?/, "")
+                .replace(/\n?<!-- PHASE_END:\w+ -->/, "")
+                .trim()
+        });
+    }
+    return phases;
+}

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

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