edsger 0.41.2 → 0.42.0

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

@@ -1,461 +0,0 @@
-import { query } from '@anthropic-ai/claude-code';
-import { logInfo, logError } from '../../utils/logger.js';
-import { saveTechnicalDesignViaHttp } from './http-fallback.js';
-import { fetchTechnicalDesignContext } from './context-fetcher.js';
-import { updateTechnicalDesign } from '../../api/features/index.js';
-import { formatTechnicalDesignContext } from '../../utils/formatters.js';
-import { createTechnicalDesignSystemPrompt, createTechnicalDesignPromptWithContext, } from './prompts.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
-import { performVerificationCycle, buildDesignResult, buildVerificationFailureResult, buildNoResultsError, } from './analyzer-helpers.js';
-import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
-function userMessage(content) {
-    return {
-        type: 'user',
-        message: { role: 'user', content: content },
-    };
-}
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-    await new Promise((res) => setTimeout(res, 10000));
-}
-export const generateTechnicalDesign = async (options, config, checklistContext) => {
-    const { featureId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting technical design generation for feature ID: ${featureId}`);
-    }
-    try {
-        // Fetch and prepare context
-        const context = await prepareDesignContext(featureId, checklistContext, verbose);
-        const systemPrompt = createTechnicalDesignSystemPrompt(config, featureId);
-        const initialDesignPrompt = context.designPrompt;
-        const maxIterations = options.maxVerificationIterations || 10;
-        let currentIteration = 0;
-        let currentPrompt = initialDesignPrompt;
-        let structuredDesignResult = null;
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('Starting Claude Code query with pre-fetched information...');
-        }
-        // Iterative improvement loop: design → verification → improve → re-design
-        while (currentIteration < maxIterations) {
-            currentIteration++;
-            if (verbose && currentIteration > 1) {
-                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving design based on verification feedback...`);
-            }
-            // Log iteration start (for iterations after the first)
-            if (currentIteration > 1) {
-                await logFeaturePhaseEvent({
-                    featureId,
-                    eventType: 'phase_started',
-                    phase: 'technical_design',
-                    result: 'info',
-                    metadata: {
-                        iteration: currentIteration,
-                        max_iterations: maxIterations,
-                        re_design: true,
-                        timestamp: new Date().toISOString(),
-                    },
-                }, verbose);
-            }
-            // Execute design query
-            const newDesignResult = await executeDesignQuery(currentPrompt, systemPrompt, config, verbose);
-            // No result produced, break out
-            if (!newDesignResult?.technical_design) {
-                if (verbose) {
-                    logError('⚠️  Design generation failed in this iteration');
-                }
-                break;
-            }
-            // Update with new design result
-            structuredDesignResult = newDesignResult;
-            // Log design completion for this iteration
-            await logFeaturePhaseEvent({
-                featureId,
-                eventType: 'phase_completed',
-                phase: 'technical_design',
-                result: 'success',
-                metadata: {
-                    iteration: currentIteration,
-                    max_iterations: maxIterations,
-                    design_step: 'completed',
-                    timestamp: new Date().toISOString(),
-                },
-            }, verbose);
-            // Save technical design immediately after generation
-            if (verbose) {
-                logInfo(`💾 Saving technical design (iteration ${currentIteration})...`);
-            }
-            await saveTechnicalDesign(featureId, structuredDesignResult.technical_design, verbose);
-            // Perform verification cycle
-            const verificationCycle = await performVerificationCycle(structuredDesignResult.technical_design, checklistContext || null, context.feedbacksContext, featureId, context.featureName, context.featureDescription, config, currentIteration, maxIterations, verbose);
-            verificationResult = verificationCycle.verificationResult;
-            // If verification passed, exit
-            if (verificationCycle.passed) {
-                if (verbose) {
-                    logInfo('✅ Verification passed! Technical design saved.');
-                }
-                break;
-            }
-            // Verification failed
-            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
-                // We have more iterations - retry with improvement prompt
-                if (verbose) {
-                    logInfo(`🔄 Will improve and save design in next iteration (${maxIterations - currentIteration} attempts remaining)`);
-                }
-                currentPrompt = verificationCycle.nextPrompt;
-            }
-            else {
-                // Max iterations reached or no next prompt - exit loop
-                if (verbose) {
-                    logInfo('⚠️  Max iterations reached. Last design version saved.');
-                }
-                break;
-            }
-        }
-        // Handle results
-        if (!structuredDesignResult?.technical_design) {
-            return buildNoResultsError(featureId);
-        }
-        // Check if verification failed after all iterations
-        if (verificationResult &&
-            verificationResult.rejected_count > 0 &&
-            checklistContext &&
-            checklistContext.checklists.length > 0) {
-            logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
-            logError(`   Technical design saved for manual review`);
-            return buildVerificationFailureResult(featureId, structuredDesignResult.technical_design, verificationResult, currentIteration);
-        }
-        // Return success result
-        return buildDesignResult(featureId, structuredDesignResult.technical_design, structuredDesignResult.summary ||
-            'Technical design generated successfully', currentIteration);
-    }
-    catch (error) {
-        logError(`Technical design generation failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            featureId,
-            technicalDesign: null,
-            status: 'error',
-            summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
-        };
-    }
-};
-/**
- * Prepare all context information needed for design
- */
-async function prepareDesignContext(featureId, checklistContext, verbose) {
-    if (verbose) {
-        logInfo('Fetching technical design context via MCP endpoints...');
-    }
-    const context = await fetchTechnicalDesignContext(featureId, verbose);
-    const { content: contextInfo, downloadedImages } = await formatTechnicalDesignContext(context);
-    if (verbose && downloadedImages.length > 0) {
-        logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
-        downloadedImages.forEach((img) => {
-            logInfo(`  - ${img.url} -> ${img.localPath}`);
-        });
-    }
-    let finalContextInfo = contextInfo;
-    let hasFeedbacks = false;
-    let feedbacksContext = null;
-    // Check if there's existing technical design
-    const existingTechnicalDesign = context.feature.technical_design;
-    const hasExistingDesign = !!existingTechnicalDesign && existingTechnicalDesign.trim().length > 0;
-    // Add existing technical design to context if it exists
-    if (hasExistingDesign && verbose) {
-        logInfo('📋 Found existing technical design - will perform incremental update if feedbacks exist');
-    }
-    // Add feedbacks context to the design prompt
-    try {
-        feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'technical-design');
-        if (verbose) {
-            logInfo(`📋 Feedbacks fetched successfully: ${feedbacksContext.feedbacks.length} feedbacks found`);
-            if (feedbacksContext.feedbacks.length > 0) {
-                logInfo('📝 Feedbacks details:');
-                feedbacksContext.feedbacks.forEach((fb, idx) => {
-                    logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title} (priority: ${fb.priority}, resolved: ${fb.is_resolved || false})`);
-                    logInfo(`      Content: ${fb.content.substring(0, 150)}...`);
-                    if (fb.target_type) {
-                        logInfo(`      🎯 Target Type: ${fb.target_type}`);
-                    }
-                    if (fb.document_type) {
-                        logInfo(`      📄 Document: ${fb.document_type}`);
-                    }
-                    if (fb.line_number) {
-                        logInfo(`      📏 Line: ${fb.line_number}`);
-                    }
-                    else if (fb.line_range_start && fb.line_range_end) {
-                        logInfo(`      📏 Lines: ${fb.line_range_start}-${fb.line_range_end}`);
-                    }
-                    if (fb.context_snippet) {
-                        logInfo(`      Referenced: ${fb.context_snippet.substring(0, 100)}...`);
-                    }
-                });
-            }
-        }
-        if (feedbacksContext.feedbacks.length > 0) {
-            hasFeedbacks = true;
-            const feedbacksInfo = formatFeedbacksForContext(feedbacksContext);
-            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
-            if (verbose) {
-                logInfo(`✅ Added ${feedbacksContext.feedbacks.length} human feedbacks to design context`);
-                logInfo(`📄 Feedbacks section length: ${feedbacksInfo.length} characters`);
-            }
-        }
-        else {
-            if (verbose) {
-                logInfo('ℹ️  No unresolved feedbacks found for this phase');
-            }
-        }
-    }
-    catch (error) {
-        // Don't fail if feedbacks fetch fails - just log and continue
-        if (verbose) {
-            logError(`❌ Failed to fetch feedbacks: ${error instanceof Error ? error.message : String(error)}`);
-            if (error instanceof Error && error.stack) {
-                logError(`   Stack: ${error.stack}`);
-            }
-        }
-    }
-    // Add checklist context to the design prompt
-    if (checklistContext && checklistContext.checklists.length > 0) {
-        const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
-        if (verbose) {
-            logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
-        }
-    }
-    // Decide on prompt mode based on existing design and feedbacks
-    const isIncrementalUpdate = hasExistingDesign && hasFeedbacks;
-    if (verbose) {
-        logInfo('\n📋 Design Mode Decision:');
-        logInfo(`   - Has existing design: ${hasExistingDesign}`);
-        logInfo(`   - Has feedbacks: ${hasFeedbacks} (${feedbacksContext?.feedbacks.length || 0} feedbacks)`);
-        logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : hasExistingDesign ? '🔄 Full Redesign' : '✨ New Design'}`);
-        if (isIncrementalUpdate && feedbacksContext) {
-            logInfo('\n🎯 Feedbacks that will be addressed:');
-            feedbacksContext.feedbacks.forEach((fb, idx) => {
-                const priorityBadge = fb.priority >= 9
-                    ? '🔴'
-                    : fb.priority >= 7
-                        ? '🟠'
-                        : fb.priority >= 5
-                            ? '🟡'
-                            : '🟢';
-                logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title} ${priorityBadge}`);
-                logInfo(`      ${fb.content.substring(0, 100)}${fb.content.length > 100 ? '...' : ''}`);
-            });
-        }
-    }
-    const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo, existingTechnicalDesign, isIncrementalUpdate);
-    return {
-        featureName: context.feature.name,
-        featureDescription: context.feature.description || undefined,
-        designPrompt,
-        hasExistingDesign,
-        hasFeedbacks,
-        feedbacksContext,
-    };
-}
-/**
- * Execute design query and parse result
- */
-async function executeDesignQuery(designPrompt, systemPrompt, config, verbose) {
-    let lastAssistantResponse = '';
-    let structuredDesignResult = null;
-    if (verbose) {
-        logInfo('🤖 Starting design agent query...');
-    }
-    // Use Claude Code SDK without MCP servers - all info is pre-fetched
-    for await (const message of query({
-        prompt: prompt(designPrompt),
-        options: {
-            appendSystemPrompt: systemPrompt,
-            model: config.claude.model || 'sonnet',
-            maxTurns: 1000,
-            permissionMode: 'bypassPermissions',
-        },
-    })) {
-        if (verbose) {
-            logInfo(`   Received message type: ${message.type}`);
-        }
-        // Stream the technical design generation process
-        if (message.type === 'assistant' && message.message?.content) {
-            for (const content of message.message.content) {
-                if (content.type === 'text') {
-                    lastAssistantResponse += content.text + '\n';
-                    if (verbose) {
-                        console.log(`\n🤖 ${content.text}`);
-                    }
-                }
-                else if (content.type === 'tool_use') {
-                    if (verbose) {
-                        console.log(`\n🔧 ${content.name}: ${content.input.description || 'Running...'}`);
-                    }
-                }
-            }
-        }
-        if (message.type === 'result') {
-            if (message.subtype === 'success') {
-                logInfo('\n🎨 Technical design generation completed, parsing results...');
-                try {
-                    // Try to extract JSON from markdown code block or parse directly
-                    const responseText = message.result || lastAssistantResponse;
-                    let jsonResult = null;
-                    // First try to extract JSON from markdown code block
-                    const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-                    if (jsonBlockMatch) {
-                        jsonResult = JSON.parse(jsonBlockMatch[1]);
-                    }
-                    else {
-                        // Try to find JSON object containing "technical_design_result"
-                        let jsonStartIndex = -1;
-                        // Find the position of "technical_design_result" and work backwards to find the opening brace
-                        if (responseText.includes('"technical_design_result"')) {
-                            const targetIndex = responseText.indexOf('"technical_design_result"');
-                            // Work backwards from "technical_design_result" to find the opening '{'
-                            for (let i = targetIndex; i >= 0; i--) {
-                                if (responseText[i] === '{') {
-                                    jsonStartIndex = i;
-                                    break;
-                                }
-                            }
-                        }
-                        if (jsonStartIndex !== -1) {
-                            // Find the complete JSON object starting from this position
-                            let braceCount = 0;
-                            let endIndex = jsonStartIndex;
-                            let inString = false;
-                            let escapeNext = false;
-                            for (let i = jsonStartIndex; i < responseText.length; i++) {
-                                const char = responseText[i];
-                                if (escapeNext) {
-                                    escapeNext = false;
-                                    continue;
-                                }
-                                if (char === '\\' && inString) {
-                                    escapeNext = true;
-                                    continue;
-                                }
-                                if (char === '"') {
-                                    inString = !inString;
-                                    continue;
-                                }
-                                if (!inString) {
-                                    if (char === '{') {
-                                        braceCount++;
-                                    }
-                                    else if (char === '}') {
-                                        braceCount--;
-                                        if (braceCount === 0) {
-                                            endIndex = i;
-                                            break;
-                                        }
-                                    }
-                                }
-                            }
-                            const jsonStr = responseText.substring(jsonStartIndex, endIndex + 1);
-                            try {
-                                jsonResult = JSON.parse(jsonStr);
-                            }
-                            catch (parseError) {
-                                logError(`Failed to parse extracted JSON: ${parseError}`);
-                                // Try to parse the entire response as JSON as fallback
-                                jsonResult = JSON.parse(responseText);
-                            }
-                        }
-                        else {
-                            // Try to parse the entire response as JSON
-                            jsonResult = JSON.parse(responseText);
-                        }
-                    }
-                    if (jsonResult && jsonResult.technical_design_result) {
-                        structuredDesignResult = jsonResult.technical_design_result;
-                    }
-                    else {
-                        throw new Error('Invalid JSON structure');
-                    }
-                }
-                catch (error) {
-                    logError(`Failed to parse structured design result: ${error}`);
-                    // Extract technical design from response if JSON parsing fails
-                    const extractedDesign = extractTechnicalDesignFromResponse(message.result || lastAssistantResponse);
-                    structuredDesignResult = {
-                        status: extractedDesign ? 'success' : 'error',
-                        technical_design: extractedDesign,
-                        summary: extractedDesign
-                            ? 'Technical design generated successfully'
-                            : 'Failed to generate technical design',
-                    };
-                }
-            }
-            else {
-                logError(`\n⚠️  Technical design generation incomplete: ${message.subtype}`);
-                if (message.subtype === 'error_max_turns') {
-                    logError('💡 Try increasing timeout or reducing complexity');
-                }
-            }
-        }
-    }
-    return structuredDesignResult;
-}
-/**
- * Save technical design document
- */
-async function saveTechnicalDesign(featureId, technicalDesign, verbose) {
-    if (verbose) {
-        logInfo('Saving technical design...');
-    }
-    const designSaved = await updateTechnicalDesign(featureId, technicalDesign, verbose);
-    // Try HTTP fallback if direct update failed
-    if (!designSaved) {
-        if (verbose) {
-            logInfo('Direct update failed, trying HTTP fallback...');
-        }
-        const fallbackSaved = await saveTechnicalDesignViaHttp({
-            featureId,
-            technicalDesign,
-            verbose,
-        });
-        if (!fallbackSaved && verbose) {
-            logError('⚠️  Both direct update and HTTP fallback failed');
-        }
-    }
-}
-const extractTechnicalDesignFromResponse = (response) => {
-    // Try to extract technical design content from the response
-    // Look for markdown sections that contain technical design
-    const lines = response.split('\n');
-    let inTechnicalDesign = false;
-    const technicalDesignLines = [];
-    for (let i = 0; i < lines.length; i++) {
-        const line = lines[i].toLowerCase();
-        // Look for technical design section headers
-        if (line.includes('technical design') ||
-            line.includes('architecture') ||
-            line.includes('# design') ||
-            line.includes('## technical')) {
-            inTechnicalDesign = true;
-            technicalDesignLines.push(lines[i]);
-            continue;
-        }
-        if (inTechnicalDesign) {
-            // Continue until we hit another major section or JSON
-            if (line.startsWith('{') && line.includes('"technical_design_result"')) {
-                break;
-            }
-            technicalDesignLines.push(lines[i]);
-        }
-    }
-    if (technicalDesignLines.length > 0) {
-        return technicalDesignLines.join('\n').trim();
-    }
-    // Ultimate fallback: return the whole response if it seems to contain design content
-    if (response.length > 100 &&
-        (response.toLowerCase().includes('architecture') ||
-            response.toLowerCase().includes('component') ||
-            response.toLowerCase().includes('database'))) {
-        return response.trim();
-    }
-    return null;
-};

package/dist/phases/technical-design/context-fetcher.d.ts

@@ -1,12 +0,0 @@
-import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
-import { type ProductInfo } from '../../api/products.js';
-export interface TechnicalDesignContext {
-    feature: FeatureInfo;
-    product: ProductInfo;
-    user_stories: UserStory[];
-    test_cases: TestCase[];
-}
-/**
- * Fetch all technical design context information via MCP endpoints
- */
-export declare function fetchTechnicalDesignContext(featureId: string, verbose?: boolean): Promise<TechnicalDesignContext>;

package/dist/phases/technical-design/context-fetcher.js

@@ -1,39 +0,0 @@
-import { logInfo, logError } from '../../utils/logger.js';
-import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
-import { getProduct } from '../../api/products.js';
-/**
- * Fetch all technical design context information via MCP endpoints
- */
-export async function fetchTechnicalDesignContext(featureId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete technical design context for feature: ${featureId}`);
-        }
-        // Fetch all required data in parallel for better performance
-        const [feature, user_stories, test_cases] = await Promise.all([
-            getFeature(featureId, verbose),
-            getUserStories(featureId, verbose),
-            getTestCases(featureId, verbose),
-        ]);
-        const product = await getProduct(feature.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Technical design context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${user_stories.length}`);
-            logInfo(`   Test Cases: ${test_cases.length} (${test_cases.filter((tc) => tc.is_critical).length} critical)`);
-            logInfo(`   Existing Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
-        }
-        return {
-            feature,
-            product,
-            user_stories,
-            test_cases,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch technical design context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}

package/dist/phases/technical-design/http-fallback.d.ts

@@ -1,17 +0,0 @@
-export interface HttpFallbackOptions {
-    featureId: string;
-    technicalDesign: string;
-    verbose?: boolean;
-}
-/**
- * Save technical design via HTTP as a fallback when MCP server fails
- */
-export declare function saveTechnicalDesignViaHttp(options: HttpFallbackOptions): Promise<boolean>;
-/**
- * Verify that technical design was saved by retrieving it and optionally comparing content
- */
-export declare function verifyTechnicalDesignSaved(featureId: string, verbose?: boolean, expectedContent?: string): Promise<boolean>;
-/**
- * Enhanced save with retry logic and verification
- */
-export declare function saveTechnicalDesignWithRetry(options: HttpFallbackOptions, maxRetries?: number): Promise<boolean>;

package/dist/phases/technical-design/http-fallback.js

@@ -1,151 +0,0 @@
-import { logInfo, logError } from '../../utils/logger.js';
-/**
- * Save technical design via HTTP as a fallback when MCP server fails
- */
-export async function saveTechnicalDesignViaHttp(options) {
-    const { featureId, technicalDesign, verbose } = options;
-    const mcpServerUrl = process.env.MCP_SERVER_URL;
-    const mcpToken = process.env.MCP_TOKEN;
-    try {
-        if (verbose) {
-            logInfo('🔄 Attempting to save technical design via HTTP fallback...');
-        }
-        // Make direct HTTP call to the MCP server endpoint
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'features/update',
-                params: {
-                    feature_id: featureId,
-                    technical_design: technicalDesign,
-                },
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'HTTP call failed');
-        }
-        if (verbose) {
-            logInfo('✅ Technical design saved successfully via HTTP fallback');
-        }
-        return true;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`❌ HTTP fallback failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return false;
-    }
-}
-/**
- * Verify that technical design was saved by retrieving it and optionally comparing content
- */
-export async function verifyTechnicalDesignSaved(featureId, verbose, expectedContent) {
-    try {
-        if (verbose) {
-            logInfo('🔍 Verifying technical design was saved...');
-        }
-        const mcpServerUrl = process.env.MCP_SERVER_URL;
-        const mcpToken = process.env.MCP_TOKEN;
-        const response = await fetch(`${mcpServerUrl}/mcp`, {
-            method: 'POST',
-            headers: {
-                'Content-Type': 'application/json',
-                Authorization: `Bearer ${mcpToken}`,
-            },
-            body: JSON.stringify({
-                jsonrpc: '2.0',
-                method: 'features/get',
-                params: {
-                    feature_id: featureId,
-                },
-                id: Math.random().toString(36).substring(7),
-            }),
-        });
-        if (!response.ok) {
-            throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-        }
-        const data = await response.json();
-        if (data.error) {
-            throw new Error(data.error.message || 'Verification failed');
-        }
-        const feature = data.result?.features?.[0];
-        const actualTechnicalDesign = feature?.technical_design;
-        const hasTechnicalDesign = actualTechnicalDesign && actualTechnicalDesign.trim().length > 0;
-        // If expected content is provided, compare it with actual content
-        if (expectedContent && hasTechnicalDesign) {
-            const contentMatches = actualTechnicalDesign.trim() === expectedContent.trim();
-            if (verbose) {
-                if (contentMatches) {
-                    logInfo('✅ Technical design verified - content matches expected');
-                }
-                else {
-                    logInfo('⚠️ Technical design exists but content differs from expected');
-                    logInfo(`Expected length: ${expectedContent.length}, Actual length: ${actualTechnicalDesign.length}`);
-                }
-            }
-            return contentMatches;
-        }
-        if (verbose) {
-            if (hasTechnicalDesign) {
-                logInfo('✅ Technical design verified - successfully saved');
-            }
-            else {
-                logInfo('⚠️ Technical design verification failed - not found');
-            }
-        }
-        return hasTechnicalDesign;
-    }
-    catch (error) {
-        if (verbose) {
-            logError(`❌ Verification failed: ${error instanceof Error ? error.message : String(error)}`);
-        }
-        return false;
-    }
-}
-/**
- * Enhanced save with retry logic and verification
- */
-export async function saveTechnicalDesignWithRetry(options, maxRetries = 3) {
-    const { verbose } = options;
-    for (let attempt = 1; attempt <= maxRetries; attempt++) {
-        if (verbose && attempt > 1) {
-            logInfo(`🔄 Retry attempt ${attempt} of ${maxRetries}...`);
-        }
-        const saved = await saveTechnicalDesignViaHttp(options);
-        if (saved) {
-            // Verify the save was successful
-            const verified = await verifyTechnicalDesignSaved(options.featureId, verbose);
-            if (verified) {
-                if (verbose) {
-                    logInfo(`✅ Technical design successfully saved and verified (attempt ${attempt})`);
-                }
-                return true;
-            }
-            else if (verbose) {
-                logError(`❌ Save appeared successful but verification failed (attempt ${attempt})`);
-            }
-        }
-        if (attempt < maxRetries) {
-            // Wait before retrying
-            const delay = Math.min(1000 * Math.pow(2, attempt - 1), 5000); // Exponential backoff
-            if (verbose) {
-                logInfo(`⏳ Waiting ${delay}ms before retry...`);
-            }
-            await new Promise((resolve) => setTimeout(resolve, delay));
-        }
-    }
-    if (verbose) {
-        logError(`❌ Failed to save technical design after ${maxRetries} attempts`);
-    }
-    return false;
-}