opencode-conductor-cdd-plugin 1.0.0-beta.13

package/dist/utils/autogenerateFlow.js

@@ -0,0 +1,391 @@
+import { generateProductGuide, generateProductGuidelines, generateTechStack, generateWorkflow, } from './contentGeneration.js';
+export const MAX_REGENERATION_ATTEMPTS = 3;
+export const MIN_CONTEXT_SIGNALS = 2;
+export const MIN_CONFIDENCE_THRESHOLD = 0.4;
+export function createInitialState(questionId) {
+    return {
+        questionId,
+        attemptNumber: 1,
+        status: 'generating',
+        content: '',
+        userChoice: null,
+        guidanceHistory: [],
+        editHistory: [],
+        timestamp: new Date().toISOString(),
+    };
+}
+export function generateContentForSection(sectionType, context) {
+    try {
+        let generationResult;
+        switch (sectionType) {
+            case 'product_guide':
+                generationResult = generateProductGuide(context);
+                break;
+            case 'product_guidelines':
+                generationResult = generateProductGuidelines(context);
+                break;
+            case 'tech_stack':
+                generationResult = generateTechStack(context);
+                break;
+            case 'workflow':
+                generationResult = generateWorkflow(context);
+                break;
+            default:
+                return { success: false, error: `Unknown section type: ${sectionType}` };
+        }
+        if (generationResult.confidence < MIN_CONFIDENCE_THRESHOLD) {
+            const sufficiency = evaluateContextSufficiency(context);
+            const ambiguity = evaluateAmbiguity(context);
+            const error = 'Insufficient context for reliable autogeneration';
+            const failureSummary = formatAutogenerationFailure(sectionType, error, sufficiency, ambiguity);
+            const fallbackPrompt = formatFallbackPrompt(error, sufficiency.missing);
+            return {
+                success: false,
+                error,
+                failureSummary,
+                fallbackPrompt,
+                fallbackAction: resolveFallbackAction(null),
+                fallbackState: sufficiency,
+                ambiguityState: ambiguity,
+            };
+        }
+        return {
+            success: true,
+            content: generationResult.content,
+        };
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : 'Unknown error during generation';
+        const sufficiency = evaluateContextSufficiency(context);
+        const ambiguity = evaluateAmbiguity(context);
+        const failureSummary = formatAutogenerationFailure(sectionType, message, sufficiency, ambiguity);
+        const fallbackPrompt = formatFallbackPrompt(message, sufficiency.missing);
+        return {
+            success: false,
+            error: message,
+            failureSummary,
+            fallbackPrompt,
+            fallbackAction: resolveFallbackAction(null),
+            fallbackState: sufficiency,
+            ambiguityState: ambiguity,
+        };
+    }
+}
+export function validateContent(content, sectionType) {
+    if (!content || content.trim().length === 0) {
+        return { valid: false, error: 'Content cannot be empty' };
+    }
+    const trimmedContent = content.trim();
+    switch (sectionType) {
+        case 'product_guide':
+        case 'product_guidelines':
+            if (trimmedContent.length < 20) {
+                return { valid: false, error: 'Content must be at least 20 characters' };
+            }
+            if (!/[a-zA-Z]{3,}/.test(trimmedContent)) {
+                return { valid: false, error: 'Content must contain coherent text' };
+            }
+            break;
+        case 'tech_stack':
+            if (trimmedContent.length < 5) {
+                return { valid: false, error: 'Tech stack must mention at least one technology' };
+            }
+            break;
+        case 'workflow':
+            if (trimmedContent.length < 30) {
+                return { valid: false, error: 'Workflow description must be at least 30 characters' };
+            }
+            break;
+    }
+    return { valid: true };
+}
+export function evaluateContextSufficiency(context) {
+    const missing = [];
+    const signals = [];
+    const hasManifests = context.raw.manifests.length > 0;
+    const hasDocs = context.raw.docs.length > 0;
+    const hasGit = context.raw.git.commitCount > 0;
+    const hasStructure = context.raw.structure.structure.length > 0;
+    const hasIgnores = context.raw.ignores.patterns.length > 0;
+    const hasCicd = context.raw.cicd.length > 0;
+    if (!hasManifests)
+        missing.push('manifest files');
+    if (!hasDocs)
+        missing.push('documentation');
+    if (!hasGit)
+        missing.push('git history');
+    if (!hasStructure)
+        missing.push('source structure');
+    if (!hasIgnores)
+        missing.push('ignore patterns');
+    if (!hasCicd)
+        missing.push('CI/CD configuration');
+    if (hasManifests)
+        signals.push('manifests');
+    if (hasDocs)
+        signals.push('docs');
+    if (hasGit)
+        signals.push('git');
+    if (hasStructure)
+        signals.push('structure');
+    if (hasIgnores)
+        signals.push('ignores');
+    if (hasCicd)
+        signals.push('cicd');
+    if (signals.length >= MIN_CONTEXT_SIGNALS) {
+        return {
+            sufficient: true,
+            reason: `Detected ${signals.length} context sources: ${signals.join(', ')}`,
+            missing,
+        };
+    }
+    return {
+        sufficient: false,
+        reason: 'Not enough project context sources to autogenerate reliably',
+        missing,
+    };
+}
+export function formatAutogenerationFailure(sectionType, error, sufficiency, ambiguity) {
+    const missingList = sufficiency.missing.length > 0
+        ? `Missing: ${sufficiency.missing.join(', ')}`
+        : 'Missing: none detected';
+    const ambiguityList = ambiguity.signals.length > 0
+        ? `Ambiguity signals: ${ambiguity.signals.join('; ')}`
+        : 'Ambiguity signals: none';
+    return `Autogeneration failed for ${sectionType}.
+Reason: ${error}
+${sufficiency.reason}
+${missingList}
+${ambiguityList}`;
+}
+export function evaluateAmbiguity(context) {
+    const signals = [];
+    const warnings = context.meta.warnings;
+    if (warnings.some((warning) => warning.toLowerCase().includes('no manifest'))) {
+        signals.push('Missing manifest files');
+    }
+    if (warnings.some((warning) => warning.toLowerCase().includes('no readme'))) {
+        signals.push('Missing README documentation');
+    }
+    if (context.insights.projectType === 'unknown') {
+        signals.push('Unknown project type');
+    }
+    if (context.insights.techStack.languages.length === 0) {
+        signals.push('No dominant language detected');
+    }
+    if (context.meta.filesAnalyzed === 0) {
+        signals.push('No files analyzed');
+    }
+    if (signals.length === 0) {
+        return { ambiguous: false, reason: 'Context appears coherent', signals };
+    }
+    return {
+        ambiguous: true,
+        reason: 'Project context appears ambiguous or incomplete',
+        signals,
+    };
+}
+export function formatFallbackPrompt(reason, missing) {
+    const missingList = missing.length > 0
+        ? `Missing: ${missing.join(', ')}`
+        : 'No specific missing data identified.';
+    return `Autogeneration could not proceed. ${reason}
+
+${missingList}
+
+Please choose how to continue:
+A) Continue with manual Q&A
+B) Provide more context for regeneration
+C) Accept partial results (use what was generated)
+
+Please enter A, B, or C:`;
+}
+export function parseFallbackChoice(input) {
+    const normalized = input.trim().toUpperCase();
+    if (['A', 'MANUAL', 'M'].includes(normalized)) {
+        return 'A';
+    }
+    if (['B', 'CONTEXT', 'REGENERATE', 'R'].includes(normalized)) {
+        return 'B';
+    }
+    if (['C', 'PARTIAL', 'ACCEPT'].includes(normalized)) {
+        return 'C';
+    }
+    return null;
+}
+export function resolveFallbackAction(choice) {
+    switch (choice) {
+        case 'A':
+            return 'manual';
+        case 'B':
+            return 'regenerate';
+        case 'C':
+            return 'accept_partial';
+        default:
+            return 'manual';
+    }
+}
+export function handleAccept(state, sectionType) {
+    const validation = validateContent(state.content, sectionType);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const updatedState = {
+        ...state,
+        status: 'accepted',
+        userChoice: 'A',
+        timestamp: new Date().toISOString(),
+    };
+    return {
+        success: true,
+        content: state.content,
+        state: updatedState,
+    };
+}
+export function handleEdit(state, editedContent, sectionType) {
+    const validation = validateContent(editedContent, sectionType);
+    if (!validation.valid) {
+        return { success: false, error: validation.error };
+    }
+    const updatedState = {
+        ...state,
+        status: 'edited',
+        userChoice: 'B',
+        content: editedContent,
+        editHistory: [...state.editHistory, editedContent],
+        timestamp: new Date().toISOString(),
+    };
+    return {
+        success: true,
+        content: editedContent,
+        state: updatedState,
+    };
+}
+export function handleRegenerate(state, guidance, sectionType, context) {
+    if (!guidance || guidance.trim().length < 5) {
+        return { success: false, error: 'Guidance must be at least 5 characters' };
+    }
+    if (state.attemptNumber >= MAX_REGENERATION_ATTEMPTS) {
+        return {
+            success: false,
+            error: `Maximum regeneration attempts (${MAX_REGENERATION_ATTEMPTS}) reached`,
+        };
+    }
+    const updatedState = {
+        ...state,
+        status: 'regenerating',
+        userChoice: 'C',
+        attemptNumber: state.attemptNumber + 1,
+        guidanceHistory: [...state.guidanceHistory, guidance],
+        timestamp: new Date().toISOString(),
+    };
+    const generationResult = generateContentForSection(sectionType, context);
+    if (!generationResult.success) {
+        return {
+            success: false,
+            error: generationResult.error,
+            state: updatedState,
+        };
+    }
+    const finalState = {
+        ...updatedState,
+        status: 'presented',
+        content: generationResult.content || '',
+    };
+    return {
+        success: true,
+        content: generationResult.content,
+        state: finalState,
+    };
+}
+export function formatPresentationPrompt(content) {
+    return `---
+
+I've analyzed your project and autogenerated the following content:
+
+${content}
+
+---
+
+**Please review the autogenerated content above.**
+
+What would you like to do?
+A) Accept - Use this content and proceed to the next question
+B) Edit - Make manual changes to the generated content
+C) Regenerate - Ask me to generate different content with your guidance
+
+Please enter A, B, or C:`;
+}
+export function formatEditPrompt(content) {
+    return `You selected Edit. I'll present the autogenerated content below. Please provide your edited version.
+
+You can:
+- Modify any part of the content
+- Add new sections
+- Remove sections you don't want
+- Completely rewrite it
+
+---
+Current content:
+${content}
+---
+
+Please paste your edited version below (type 'cancel' to go back to options):`;
+}
+export function formatRegeneratePrompt() {
+    return `You selected Regenerate. To generate better content, please provide guidance.
+
+What would you like me to change or focus on? (Examples: "Focus more on X", "Remove mention of Y", "Use simpler language", "Be more specific about Z")
+
+Your guidance (type 'cancel' to go back):`;
+}
+export function formatMaxAttemptsPrompt() {
+    return `You've regenerated content ${MAX_REGENERATION_ATTEMPTS} times. It seems autogeneration isn't working well for this question. Would you like to:
+
+A) Accept the current version
+B) Edit the current version manually
+C) Switch to manual Q&A for this question (I'll ask specific questions)
+
+Please enter A, B, or C:`;
+}
+export function parseUserChoice(input) {
+    const normalized = input.trim().toUpperCase();
+    if (['A', 'ACCEPT', 'YES', 'Y'].includes(normalized)) {
+        return 'A';
+    }
+    if (['B', 'EDIT', 'E'].includes(normalized)) {
+        return 'B';
+    }
+    if (['C', 'REGENERATE', 'R'].includes(normalized)) {
+        return 'C';
+    }
+    return null;
+}
+export function isCancel(input) {
+    return input.trim().toLowerCase() === 'cancel';
+}
+export function handleFallbackManual(sectionType, reason) {
+    return {
+        success: false,
+        error: `Fallback to manual Q&A: ${reason}`,
+        fallbackAction: 'manual',
+    };
+}
+export function handleFallbackAcceptPartial(partialContent, sectionType, reason) {
+    const validation = validateContent(partialContent, sectionType);
+    if (!validation.valid) {
+        return {
+            success: false,
+            error: `Partial content is invalid: ${validation.error}. Falling back to manual Q&A.`,
+            fallbackAction: 'manual',
+        };
+    }
+    return {
+        success: true,
+        content: partialContent,
+        fallbackAction: 'accept_partial',
+    };
+}
+export function handleFallbackRegenerate(sectionType, context, additionalContext) {
+    return generateContentForSection(sectionType, context);
+}

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

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