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

package/dist/utils/configDetection.test.js

@@ -119,7 +119,7 @@ describe("configDetection", () => {
     });
     // New tests for oh-my-opencode-slim detection
     describe("oh-my-opencode-slim detection", () => {
-        it("should detect oh-my-opencode-slim when only slim config is present", () => {
+        it("should NOT detect synergy when slim config has no cdd agent", () => {
             vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
             vi.mocked(readFileSync).mockImplementation((path) => {
                 if (path === slimJsonPath) {
@@ -130,11 +130,11 @@ describe("configDetection", () => {
                 return "";
             });
             const result = detectCDDConfig();
-            expect(result.synergyActive).toBe(true);
-            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyActive).toBe(false);
+            expect(result.synergyFramework).toBe('none');
             expect(result.slimAgents).toEqual(['explorer', 'librarian', 'oracle', 'designer']);
         });
-        it("should prioritize oh-my-opencode-slim over oh-my-opencode when both present", () => {
+        it("should prioritize oh-my-opencode over slim when slim has no cdd agent", () => {
             vi.mocked(existsSync).mockReturnValue(true);
             vi.mocked(readFileSync).mockImplementation((path) => {
                 if (path === slimJsonPath) {
@@ -146,10 +146,11 @@ describe("configDetection", () => {
                 return "";
             });
             const result = detectCDDConfig();
-            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyFramework).toBe('oh-my-opencode');
             expect(result.synergyActive).toBe(true);
+            expect(result.cddModel).toBe('model-from-omo');
         });
-        it("should filter out disabled agents from slim config", () => {
+        it("should filter out disabled agents from slim config (but require cdd for synergy)", () => {
             vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
             vi.mocked(readFileSync).mockImplementation((path) => {
                 if (path === slimJsonPath) {
@@ -160,7 +161,8 @@ describe("configDetection", () => {
                 return "";
             });
             const result = detectCDDConfig();
-            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
             expect(result.slimAgents).toEqual(['explorer', 'librarian']);
         });
         it("should handle empty oh-my-opencode-slim config", () => {
@@ -203,4 +205,199 @@ describe("configDetection", () => {
             expect(result.synergyActive).toBe(false);
         });
     });
+    // New tests for CDD agent detection in oh-my-opencode-slim
+    describe("CDD agent detection in oh-my-opencode-slim", () => {
+        it("should detect cdd agent in slim config and activate synergy", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-sonnet" },
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.synergyActive).toBe(true);
+            expect(result.cddModel).toBe("anthropic/claude-3-5-sonnet");
+        });
+        it("should not activate synergy when slim config exists but no cdd agent", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should not activate synergy when slim config has empty agents object", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({ agents: {} });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should handle malformed slim config gracefully with hasCDDInSlim false", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return "invalid json";
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+        it("should extract cdd model from slim config when present", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "anthropic/claude-3-5-haiku" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.cddModel).toBe("anthropic/claude-3-5-haiku");
+            expect(result.hasCDDInSlim).toBe(true);
+        });
+        it("should handle cdd agent without model field in slim", () => {
+            vi.mocked(existsSync).mockImplementation((path) => path === slimJsonPath);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: {}
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.cddModel).toBeUndefined();
+        });
+        it("should prioritize slim model over oh-my-opencode model when both have cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-slim" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-omo" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.cddModel).toBe("model-from-slim");
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.hasCDDInOMO).toBe(true);
+        });
+        it("should select oh-my-opencode when only OMO has cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-omo" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.hasCDDInOMO).toBe(true);
+            expect(result.synergyFramework).toBe('oh-my-opencode');
+        });
+        it("should select slim when only slim has cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            cdd: { model: "model-from-slim" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            sisyphus: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(true);
+            expect(result.hasCDDInOMO).toBe(false);
+            expect(result.synergyFramework).toBe('oh-my-opencode-slim');
+        });
+        it("should not activate synergy when neither framework has cdd", () => {
+            vi.mocked(existsSync).mockReturnValue(true);
+            vi.mocked(readFileSync).mockImplementation((path) => {
+                if (path === slimJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            designer: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                if (path === omoJsonPath) {
+                    return JSON.stringify({
+                        agents: {
+                            sisyphus: { model: "google/gemini-3-flash" }
+                        }
+                    });
+                }
+                return "";
+            });
+            const result = detectCDDConfig();
+            expect(result.hasCDDInSlim).toBe(false);
+            expect(result.hasCDDInOMO).toBe(false);
+            expect(result.synergyFramework).toBe('none');
+            expect(result.synergyActive).toBe(false);
+        });
+    });
 });

package/dist/utils/documentGeneration.d.ts

@@ -0,0 +1,97 @@
+import { Question, Section } from './questionGenerator.js';
+import { CodebaseAnalysis } from './codebaseAnalysis.js';
+/**
+ * Document Generation Module
+ *
+ * Orchestrates the full document generation workflow:
+ * - Present questions sequentially (max 5)
+ * - Handle user selections (A-E, including custom and auto-generate)
+ * - Draft documents from selected answers only
+ * - Approval/revision loops
+ * - State persistence for resume functionality
+ *
+ * Based on reference implementations:
+ * - derekbar90/opencode-conductor
+ * - gemini-cli-extensions/conductor
+ */
+export interface QuestionAnswer {
+    questionId: string;
+    selections: string[];
+    selectedOptions: string[];
+    customText?: string;
+    timestamp: string;
+}
+export interface QuestionSession {
+    section: Section;
+    questionsAsked: Question[];
+    answers: QuestionAnswer[];
+    autoGenerateRequested: boolean;
+    autoGenerateAtQuestion?: number;
+    startTime: string;
+    endTime: string;
+}
+export interface DocumentDraft {
+    content: string;
+    inferredFromContext: boolean;
+    sectionsIncluded: string[];
+    wordCount: number;
+}
+export interface DocumentState {
+    section: Section;
+    checkpoint: string;
+    content: string;
+    filePath: string;
+    timestamp?: string;
+}
+export interface SaveStateResult {
+    success: boolean;
+    stateFile?: string;
+    checkpoint?: string;
+    filePath?: string;
+    previousCheckpoints?: string[];
+    error?: string;
+}
+export interface ApprovalResult {
+    approved: boolean;
+    finalContent?: string;
+    revisionGuidance?: string;
+}
+export interface DocumentGenerationOptions {
+    section: Section;
+    questions: Question[];
+    analysis: CodebaseAnalysis;
+    responder: (question: Question, questionNumber: number) => Promise<string[]>;
+    approvalFlow: (draft: DocumentDraft) => Promise<ApprovalResult>;
+    outputPath: string;
+    maxRevisions?: number;
+    customInputPrompt?: (question: Question) => Promise<string>;
+}
+export interface DocumentGenerationResult {
+    success: boolean;
+    checkpoint?: string;
+    autoGenerated?: boolean;
+    revisionCount?: number;
+    error?: string;
+}
+export interface PresentQuestionsOptions {
+    maxQuestions?: number;
+    customInputPrompt?: (question: Question) => Promise<string>;
+}
+/**
+ * Present questions sequentially to the user
+ * Stops after maxQuestions or when option E is selected
+ */
+export declare function presentQuestionsSequentially(questions: Question[], responder: (question: Question, questionNumber: number) => Promise<string[]>, options?: PresentQuestionsOptions): Promise<QuestionSession>;
+/**
+ * Draft document content from user's selected answers
+ * CRITICAL: Only use selected options, ignore questions and unselected options
+ */
+export declare function draftDocumentFromAnswers(session: QuestionSession, analysis: CodebaseAnalysis): DocumentDraft;
+/**
+ * Save document to file and update state
+ */
+export declare function saveDocumentState(state: DocumentState): Promise<SaveStateResult>;
+/**
+ * Orchestrate full document generation workflow
+ */
+export declare function generateDocument(options: DocumentGenerationOptions): Promise<DocumentGenerationResult>;

package/dist/utils/documentGeneration.js

@@ -0,0 +1,301 @@
+import * as fs from 'fs';
+import * as path from 'path';
+import { validateSelection, parseSelection } from './interactiveMenu.js';
+// Constants
+const MAX_QUESTIONS = 5;
+const MAX_REVISION_ATTEMPTS = 3;
+const STATE_FILE_PATH = 'conductor-cdd/setup_state.json';
+const CHECKPOINT_MAP = {
+    product: '2.1_product_guide',
+    guidelines: '2.2_product_guidelines',
+    'tech-stack': '2.3_tech_stack',
+    styleguides: '2.4_code_styleguides',
+    workflow: '2.5_workflow',
+};
+/**
+ * Present questions sequentially to the user
+ * Stops after maxQuestions or when option E is selected
+ */
+export async function presentQuestionsSequentially(questions, responder, options = {}) {
+    const { maxQuestions = MAX_QUESTIONS, customInputPrompt } = options;
+    const session = {
+        section: questions[0]?.section || 'product',
+        questionsAsked: [],
+        answers: [],
+        autoGenerateRequested: false,
+        startTime: new Date().toISOString(),
+        endTime: '',
+    };
+    for (let i = 0; i < Math.min(questions.length, maxQuestions); i++) {
+        const question = questions[i];
+        session.questionsAsked.push(question);
+        // Get user response
+        let selections;
+        let isValid = false;
+        // Keep asking until valid response
+        while (!isValid) {
+            selections = await responder(question, i + 1);
+            isValid = validateSelection(selections.join(','), question.type);
+        }
+        const parsedSelections = parseSelection(selections.join(','), question.type);
+        // Map selections to actual option text
+        const selectedOptions = parsedSelections.map(letter => {
+            const index = letter.charCodeAt(0) - 'A'.charCodeAt(0);
+            return question.options[index];
+        });
+        const answer = {
+            questionId: question.id,
+            selections: parsedSelections,
+            selectedOptions,
+            timestamp: new Date().toISOString(),
+        };
+        // Handle option D (custom input)
+        if (parsedSelections.includes('D') && customInputPrompt) {
+            answer.customText = await customInputPrompt(question);
+        }
+        session.answers.push(answer);
+        // Handle option E (auto-generate) - stop asking questions
+        if (parsedSelections.includes('E')) {
+            session.autoGenerateRequested = true;
+            session.autoGenerateAtQuestion = i;
+            break;
+        }
+    }
+    session.endTime = new Date().toISOString();
+    return session;
+}
+/**
+ * Draft document content from user's selected answers
+ * CRITICAL: Only use selected options, ignore questions and unselected options
+ */
+export function draftDocumentFromAnswers(session, analysis) {
+    const sections = [];
+    let inferredFromContext = session.autoGenerateRequested;
+    // Build content from selected answers
+    for (const answer of session.answers) {
+        if (answer.customText) {
+            // Option D: Use custom text directly
+            sections.push(answer.customText);
+        }
+        else {
+            // Options A, B, C: Use selected option text
+            for (const option of answer.selectedOptions) {
+                // Skip option D (Custom) and option E (Auto-generate)
+                if (!option.includes('custom') && !option.includes('Auto-generate')) {
+                    sections.push(option);
+                }
+            }
+        }
+    }
+    // If auto-generate was requested, infer additional content from context
+    if (session.autoGenerateRequested) {
+        sections.push(...inferAdditionalContent(session, analysis));
+    }
+    // Generate document structure based on section type
+    const content = formatDocumentContent(session.section, sections, analysis);
+    return {
+        content,
+        inferredFromContext,
+        sectionsIncluded: sections,
+        wordCount: content.split(/\s+/).length,
+    };
+}
+/**
+ * Infer additional content when auto-generate is requested
+ */
+function inferAdditionalContent(session, analysis) {
+    const inferred = [];
+    // Use codebase analysis - check both languages and frameworks
+    const hasCodebaseData = Object.keys(analysis.languages).length > 0 ||
+        analysis.frameworks.frontend.length > 0 ||
+        analysis.frameworks.backend.length > 0;
+    if (hasCodebaseData) {
+        // Infer from detected technologies
+        const languages = Object.keys(analysis.languages);
+        if (languages.length > 0) {
+            inferred.push(`Technologies: ${languages.join(', ')}`);
+        }
+        if (analysis.frameworks.frontend.length > 0) {
+            inferred.push(`Frontend: ${analysis.frameworks.frontend.join(', ')}`);
+        }
+        if (analysis.frameworks.backend.length > 0) {
+            inferred.push(`Backend: ${analysis.frameworks.backend.join(', ')}`);
+        }
+        if (analysis.databases.length > 0) {
+            inferred.push(`Databases: ${analysis.databases.join(', ')}`);
+        }
+        if (analysis.architecture.length > 0 && !analysis.architecture.includes('unknown')) {
+            inferred.push(`Architecture: ${analysis.architecture.join(', ')}`);
+        }
+    }
+    // Infer from previous answers in session
+    for (const answer of session.answers) {
+        for (const option of answer.selectedOptions) {
+            if (!option.includes('Auto-generate') && !option.includes('custom')) {
+                // Use selected options as context for inference
+                inferred.push(option);
+            }
+        }
+    }
+    return inferred;
+}
+/**
+ * Format document content based on section type
+ */
+function formatDocumentContent(section, contentSections, analysis) {
+    const lines = [];
+    // Ensure minimum content for greenfield projects
+    const hasContent = contentSections.length > 0;
+    if (!hasContent) {
+        contentSections.push('To be defined during project setup.');
+    }
+    // Section-specific formatting
+    switch (section) {
+        case 'product':
+            lines.push('# Product Guide', '');
+            lines.push('## Overview', '');
+            lines.push(...contentSections);
+            if (analysis.projectGoal) {
+                lines.push('', `## Project Goal`, '', analysis.projectGoal);
+            }
+            break;
+        case 'guidelines':
+            lines.push('# Product Guidelines', '');
+            lines.push('## Guidelines', '');
+            lines.push(...contentSections);
+            break;
+        case 'tech-stack':
+            lines.push('# Tech Stack', '');
+            lines.push('## Technologies', '');
+            lines.push(...contentSections);
+            break;
+        case 'styleguides':
+            lines.push('# Code Style Guides', '');
+            lines.push('## Style Guidelines', '');
+            lines.push(...contentSections);
+            break;
+        case 'workflow':
+            lines.push('# Workflow', '');
+            lines.push('## Development Workflow', '');
+            lines.push(...contentSections);
+            break;
+        default:
+            lines.push('# Document', '');
+            lines.push(...contentSections);
+    }
+    return lines.join('\n');
+}
+/**
+ * Save document to file and update state
+ */
+export async function saveDocumentState(state) {
+    try {
+        // Ensure directory exists
+        const dir = path.dirname(state.filePath);
+        if (!fs.existsSync(dir)) {
+            fs.mkdirSync(dir, { recursive: true });
+        }
+        // Save document to file
+        fs.writeFileSync(state.filePath, state.content, 'utf-8');
+        // Compute state file path from outputPath (e.g., /path/to/conductor-cdd/product.md → /path/to/conductor-cdd/setup_state.json)
+        const stateFilePath = path.join(path.dirname(state.filePath), 'setup_state.json');
+        // Update state file
+        let setupState = {};
+        if (fs.existsSync(stateFilePath)) {
+            const existingState = fs.readFileSync(stateFilePath, 'utf-8');
+            setupState = JSON.parse(existingState);
+        }
+        const previousCheckpoints = setupState.last_successful_step
+            ? [setupState.last_successful_step]
+            : [];
+        setupState.last_successful_step = state.checkpoint;
+        setupState[`${state.section}_timestamp`] = state.timestamp || new Date().toISOString();
+        fs.writeFileSync(stateFilePath, JSON.stringify(setupState, null, 2), 'utf-8');
+        return {
+            success: true,
+            stateFile: stateFilePath,
+            checkpoint: state.checkpoint,
+            filePath: state.filePath,
+            previousCheckpoints,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}
+/**
+ * Orchestrate full document generation workflow
+ */
+export async function generateDocument(options) {
+    const { section, questions, analysis, responder, approvalFlow, outputPath, maxRevisions = MAX_REVISION_ATTEMPTS, customInputPrompt } = options;
+    try {
+        // Validate questions array
+        if (!questions || questions.length === 0) {
+            return {
+                success: false,
+                error: `No questions generated for section: ${section}`,
+            };
+        }
+        // Step 1: Present questions sequentially
+        const session = await presentQuestionsSequentially(questions, responder, {
+            customInputPrompt,
+        });
+        // Step 2: Draft document from answers
+        let draft = draftDocumentFromAnswers(session, analysis);
+        let revisionCount = 0;
+        let approved = false;
+        let finalContent = draft.content;
+        // Step 3: Approval/revision loop
+        while (!approved && revisionCount < maxRevisions) {
+            const approvalResult = await approvalFlow(draft);
+            if (approvalResult.approved) {
+                approved = true;
+                finalContent = approvalResult.finalContent || draft.content;
+            }
+            else {
+                // Revise based on guidance
+                revisionCount++;
+                if (revisionCount >= maxRevisions) {
+                    return {
+                        success: false,
+                        error: `Max revision attempts (${maxRevisions}) exceeded`,
+                        revisionCount,
+                    };
+                }
+                // Re-draft with revision guidance
+                // In real implementation, this would incorporate the revision guidance
+                draft = draftDocumentFromAnswers(session, analysis);
+            }
+        }
+        // Step 4: Save document and update state
+        const checkpoint = CHECKPOINT_MAP[section];
+        const saveResult = await saveDocumentState({
+            section,
+            checkpoint,
+            content: finalContent,
+            filePath: outputPath,
+            timestamp: new Date().toISOString(),
+        });
+        if (!saveResult.success) {
+            return {
+                success: false,
+                error: `Failed to save document: ${saveResult.error}`,
+            };
+        }
+        return {
+            success: true,
+            checkpoint,
+            autoGenerated: session.autoGenerateRequested,
+            revisionCount,
+        };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : 'Unknown error',
+        };
+    }
+}

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

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