edsger 0.2.2 → 0.2.4

package/dist/phases/technical-design/analyzer-helpers.d.ts

@@ -0,0 +1,37 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { type ChecklistVerificationResult } from '../technical-design-verification/index.js';
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: ChecklistVerificationResult;
+    iterations?: number;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+interface VerificationCycleResult {
+    passed: boolean;
+    verificationResult: ChecklistVerificationResult | null;
+    nextPrompt?: string;
+}
+/**
+ * Perform verification and determine if iteration should continue
+ */
+export declare function performVerificationCycle(technicalDesign: string, checklistContext: ChecklistPhaseContext | null, featureId: string, featureName: string, featureDescription: string | undefined, config: EdsgerConfig, currentIteration: number, maxIterations: number, mcpServerUrl: string, mcpToken: string, verbose?: boolean): Promise<VerificationCycleResult>;
+/**
+ * Build successful design result
+ */
+export declare function buildDesignResult(featureId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
+/**
+ * Build error result when no design was generated
+ */
+export declare function buildNoResultsError(featureId: string): TechnicalDesignResult;
+export {};

package/dist/phases/technical-design/analyzer-helpers.js

@@ -0,0 +1,144 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { processChecklistItemResultsFromResponse, } from '../../services/checklist.js';
+import { verifyTechnicalDesignCompliance, } from '../technical-design-verification/index.js';
+import { createTechnicalDesignImprovementPrompt } from '../../prompts/technical-design-improvement.js';
+import { logFeatureVerificationEvent } from '../../services/audit-logs.js';
+/**
+ * Perform verification and determine if iteration should continue
+ */
+export async function performVerificationCycle(technicalDesign, checklistContext, featureId, featureName, featureDescription, config, currentIteration, maxIterations, mcpServerUrl, mcpToken, verbose) {
+    // No verification needed if no checklist context
+    if (!checklistContext || checklistContext.checklists.length === 0) {
+        return { passed: true, verificationResult: null };
+    }
+    if (verbose) {
+        logInfo('🔍 Starting technical design verification...');
+    }
+    const verificationResult = await verifyTechnicalDesignCompliance({
+        checklistContext,
+        featureId,
+        featureName,
+        featureDescription,
+        technicalDesign,
+        verbose,
+    }, config);
+    // Verification passed
+    if (verificationResult.rejected_count === 0) {
+        if (verbose) {
+            logInfo(`✅ Checklist verification passed: ${verificationResult.confirmed_count} confirmed, ${verificationResult.uncertain_count} uncertain`);
+        }
+        // Log verification success
+        await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+            featureId,
+            phase: 'technical_design',
+            iteration: currentIteration,
+            result: 'success',
+            verificationData: {
+                confirmed_count: verificationResult.confirmed_count,
+                rejected_count: verificationResult.rejected_count,
+                uncertain_count: verificationResult.uncertain_count,
+                summary: verificationResult.summary,
+            },
+        }, verbose);
+        // Create checklist results based on verification result
+        const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+            checklist_item_id: item.checklist_item_id,
+            is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+            value: item.verification_status,
+            notes: item.verification_reason || undefined,
+        }));
+        await processChecklistItemResultsFromResponse({ featureId, mcpServerUrl, mcpToken }, 'technical_design', checklistItemResults, verbose);
+        return { passed: true, verificationResult };
+    }
+    // Verification failed
+    logError(`❌ Iteration ${currentIteration}: Checklist verification FAILED - ${verificationResult.rejected_count} items rejected, ${verificationResult.uncertain_count} uncertain`);
+    // Log verification failure with improvement suggestions
+    await logFeatureVerificationEvent(mcpServerUrl, mcpToken, {
+        featureId,
+        phase: 'technical_design',
+        iteration: currentIteration,
+        result: 'error',
+        verificationData: {
+            confirmed_count: verificationResult.confirmed_count,
+            rejected_count: verificationResult.rejected_count,
+            uncertain_count: verificationResult.uncertain_count,
+            rejected_items: verificationResult.item_verifications
+                .filter((item) => item.verification_status === 'rejected')
+                .map((item) => ({
+                checklist_item_id: item.checklist_item_id,
+                reason: item.verification_reason || 'No reason provided',
+                concerns: item.concerns || [],
+                improvement_suggestions: item.improvement_suggestions || [],
+            })),
+            uncertain_items: verificationResult.item_verifications
+                .filter((item) => item.verification_status === 'uncertain')
+                .map((item) => ({
+                checklist_item_id: item.checklist_item_id,
+                reason: item.verification_reason || 'No reason provided',
+                concerns: item.concerns || [],
+                improvement_suggestions: item.improvement_suggestions || [],
+            })),
+            summary: verificationResult.summary,
+            overall_suggestions: verificationResult.overall_suggestions || [],
+        },
+    }, verbose);
+    // Check if we can iterate again
+    if (currentIteration < maxIterations) {
+        if (verbose) {
+            logInfo(`   Will retry with improvement feedback (${maxIterations - currentIteration} attempts remaining)`);
+        }
+        // Create improvement prompt for next iteration
+        const nextPrompt = createTechnicalDesignImprovementPrompt(verificationResult, technicalDesign);
+        return { passed: false, verificationResult, nextPrompt };
+    }
+    // Max iterations reached - create checklist results based on final verification
+    logError(`❌ Maximum iterations (${maxIterations}) reached. Checklist verification still failing.`);
+    // Create checklist results for all items (both passed and failed)
+    const checklistItemResults = verificationResult.item_verifications.map((item) => ({
+        checklist_item_id: item.checklist_item_id,
+        is_passed: item.is_satisfied && item.verification_status === 'confirmed',
+        value: item.verification_status,
+        notes: item.verification_reason || undefined,
+    }));
+    await processChecklistItemResultsFromResponse({ featureId, mcpServerUrl, mcpToken }, 'technical_design', checklistItemResults, verbose);
+    return { passed: false, verificationResult };
+}
+/**
+ * Build successful design result
+ */
+export function buildDesignResult(featureId, technicalDesign, summary, iterations, checklistItemResults) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'success',
+        summary,
+        iterations,
+        data: checklistItemResults
+            ? { checklist_item_results: checklistItemResults }
+            : undefined,
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, technicalDesign, verificationResult, iterations) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'error',
+        summary: `Checklist verification failed after ${iterations} iterations: ${verificationResult.summary}`,
+        verificationResult,
+        iterations,
+    };
+}
+/**
+ * Build error result when no design was generated
+ */
+export function buildNoResultsError(featureId) {
+    return {
+        featureId,
+        technicalDesign: null,
+        status: 'error',
+        summary: 'Failed to generate technical design - no valid result received',
+    };
+}

package/dist/phases/technical-design/analyzer.d.ts

@@ -5,12 +5,15 @@ export interface TechnicalDesignOptions {
     mcpServerUrl: string;
     mcpToken: string;
     verbose?: boolean;
+    maxVerificationIterations?: number;
 }
 export interface TechnicalDesignResult {
     featureId: string;
     technicalDesign: string | null;
     status: 'success' | 'error';
     summary: string;
+    verificationResult?: any;
+    iterations?: number;
     savedViaHttp?: boolean;
     data?: {
         checklist_item_results?: any[];