edsger 0.2.1 → 0.2.3

package/dist/{pull-request → phases/pull-request}/creator.js

@@ -91,7 +91,7 @@ export async function createPullRequest(config, feature) {
         const octokit = new Octokit({
             auth: githubToken,
         });
-        // Get current branch
+        // Get current branch (should be dev/feature-id)
         const currentBranch = getCurrentBranch();
         if (verbose) {
             console.log(`🔍 Current branch: ${currentBranch}`);
@@ -103,22 +103,63 @@ export async function createPullRequest(config, feature) {
                 error: `Cannot create PR: already on ${baseBranch} branch`,
             };
         }
-        // Push current branch to remote
-        pushBranch(currentBranch, verbose);
+        // Extract feature ID from current branch (dev/feature-id)
+        let targetBranch = baseBranch;
+        if (currentBranch.startsWith('dev/')) {
+            const featureId = currentBranch.replace('dev/', '');
+            targetBranch = `feat/${featureId}`;
+            // Create the feat/ branch from base branch (main)
+            if (verbose) {
+                console.log(`📝 Creating target branch: ${targetBranch} from ${baseBranch}`);
+            }
+            try {
+                // Push current branch to remote first
+                pushBranch(currentBranch, verbose);
+                // Get the base branch (main) SHA to create feat/ branch from
+                const { data: baseBranchData } = await octokit.repos.getBranch({
+                    owner,
+                    repo,
+                    branch: baseBranch,
+                });
+                // Create the feat/ branch from main
+                await octokit.git.createRef({
+                    owner,
+                    repo,
+                    ref: `refs/heads/${targetBranch}`,
+                    sha: baseBranchData.commit.sha,
+                });
+                if (verbose) {
+                    console.log(`✅ Created target branch: ${targetBranch} from ${baseBranch}`);
+                }
+            }
+            catch (error) {
+                // If branch already exists, that's fine
+                if (!error.message?.includes('Reference already exists')) {
+                    throw error;
+                }
+                if (verbose) {
+                    console.log(`ℹ️ Target branch ${targetBranch} already exists`);
+                }
+            }
+        }
+        else {
+            // If not a dev/ branch, push it normally
+            pushBranch(currentBranch, verbose);
+        }
         // Generate PR title and body
         const title = generatePRTitle(feature.name);
         const body = generatePRBody(feature);
         if (verbose) {
-            console.log(`📝 Creating pull request: ${title}`);
+            console.log(`📝 Creating pull request: ${title} from ${currentBranch} to ${targetBranch}`);
         }
-        // Create the pull request
+        // Create the pull request from dev/ to feat/
         const { data: pullRequest } = await octokit.pulls.create({
             owner,
             repo,
             title,
             body,
             head: currentBranch,
-            base: baseBranch,
+            base: targetBranch,
             draft: false,
         });
         if (verbose) {

package/dist/phases/pull-request/handler.d.ts

@@ -0,0 +1,16 @@
+/**
+ * Pull request creation handler for pipeline execution
+ */
+import { PipelineResult } from '../../types/pipeline.js';
+export interface PullRequestHandlerOptions {
+    featureId: string;
+    mcpServerUrl: string;
+    mcpToken: string;
+    results: readonly PipelineResult[];
+    testingResult: PipelineResult;
+    verbose?: boolean;
+}
+/**
+ * Create pull request for successful feature implementation
+ */
+export declare function handlePullRequestCreation({ featureId, mcpServerUrl, mcpToken, results, testingResult, verbose, }: PullRequestHandlerOptions): Promise<void>;

package/dist/phases/pull-request/handler.js

@@ -0,0 +1,60 @@
+/**
+ * Pull request creation handler for pipeline execution
+ */
+import { getFeature } from '../../api/features/index.js';
+import { createPullRequest, updateFeatureWithPullRequest } from './creator.js';
+/**
+ * Create pull request for successful feature implementation
+ */
+export async function handlePullRequestCreation({ featureId, mcpServerUrl, mcpToken, results, testingResult, verbose, }) {
+    if (verbose) {
+        console.log('🔄 Creating pull request for successful feature...');
+    }
+    // Get feature details for PR creation
+    const feature = await getFeature(mcpServerUrl, mcpToken, featureId, verbose);
+    if (!feature) {
+        if (verbose) {
+            console.log('⚠️ Could not fetch feature details for pull request creation');
+        }
+        return;
+    }
+    // Get GitHub configuration from environment
+    const githubToken = process.env.GITHUB_TOKEN || process.env.GITHUB_ACCESS_TOKEN;
+    const githubOwner = process.env.GITHUB_OWNER;
+    const githubRepo = process.env.GITHUB_REPO;
+    if (!githubToken || !githubOwner || !githubRepo) {
+        if (verbose) {
+            console.log('⚠️ GitHub configuration not found. Skipping pull request creation.');
+            console.log('   Set GITHUB_TOKEN, GITHUB_OWNER, and GITHUB_REPO environment variables.');
+        }
+        return;
+    }
+    const prResult = await createPullRequest({
+        githubToken,
+        owner: githubOwner,
+        repo: githubRepo,
+        baseBranch: 'main',
+        verbose,
+    }, {
+        id: feature.id,
+        name: feature.name,
+        description: feature.description || '',
+        productId: feature.product_id,
+        // Get technical design and test result from previous phases
+        technicalDesign: results.find((r) => r.phase === 'technical-design')?.data?.technicalDesign,
+        testResult: testingResult.data?.testResult,
+        testReportUrl: testingResult.data?.testReport?.testReportUrl,
+    });
+    if (prResult.success && prResult.pullRequestUrl) {
+        // Update feature with PR URL and status
+        await updateFeatureWithPullRequest(mcpServerUrl, mcpToken, featureId, prResult.pullRequestUrl, verbose);
+        if (verbose) {
+            console.log(`✅ Pull request created and feature updated to ready_for_review`);
+        }
+    }
+    else {
+        if (verbose) {
+            console.log(`⚠️ Pull request creation failed: ${prResult.error}`);
+        }
+    }
+}

package/dist/{technical-design → phases/technical-design}/analyzer.d.ts

@@ -1,4 +1,5 @@
-import { EdsgerConfig } from '../types.js';
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
 export interface TechnicalDesignOptions {
     featureId: string;
     mcpServerUrl: string;
@@ -11,6 +12,10 @@ export interface TechnicalDesignResult {
     status: 'success' | 'error';
     summary: string;
     savedViaHttp?: boolean;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
 }
-export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig) => Promise<TechnicalDesignResult>;
+export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TechnicalDesignResult>;
 export declare const checkTechnicalDesignRequirements: () => Promise<boolean>;

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

@@ -0,0 +1,424 @@
+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 '../../prompts/formatters.js';
+import { createTechnicalDesignSystemPrompt, createTechnicalDesignPromptWithContext, } from '../../prompts/technical-design.js';
+import { formatChecklistsForContext, } from '../../services/checklist.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, mcpServerUrl, mcpToken, verbose } = options;
+    if (verbose) {
+        logInfo(`Starting technical design generation for feature ID: ${featureId}`);
+        logInfo(`Using MCP server: ${mcpServerUrl}`);
+    }
+    try {
+        // Fetch all required context information via MCP endpoints
+        if (verbose) {
+            logInfo('Fetching technical design context via MCP endpoints...');
+        }
+        const context = await fetchTechnicalDesignContext(mcpServerUrl, mcpToken, featureId, verbose);
+        const systemPrompt = createTechnicalDesignSystemPrompt(config, mcpServerUrl, mcpToken, featureId);
+        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}`);
+            });
+        }
+        // Add checklist context to the design prompt
+        let finalContextInfo = contextInfo;
+        if (checklistContext && checklistContext.checklists.length > 0) {
+            const checklistInfo = formatChecklistsForContext(checklistContext);
+            finalContextInfo = contextInfo + '\n\n' + checklistInfo;
+            if (verbose) {
+                logInfo(`Added ${checklistContext.checklists.length} checklists to design context`);
+            }
+        }
+        const designPrompt = createTechnicalDesignPromptWithContext(featureId, finalContextInfo);
+        let lastAssistantResponse = '';
+        let structuredDesignResult = null;
+        if (verbose) {
+            logInfo('Starting Claude Code query with pre-fetched information...');
+        }
+        // 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;
+                        // DEBUG: Log response text details
+                        console.log('=== DEBUG: Response Text Analysis ===');
+                        console.log('message.result exists:', !!message.result);
+                        console.log('lastAssistantResponse exists:', !!lastAssistantResponse);
+                        console.log('responseText length:', responseText.length);
+                        console.log('responseText first 200 chars:', JSON.stringify(responseText.substring(0, 200)));
+                        console.log('responseText last 200 chars:', JSON.stringify(responseText.substring(responseText.length - 200)));
+                        console.log('Contains ```json:', responseText.includes('```json'));
+                        console.log('Contains technical_design_result:', responseText.includes('"technical_design_result"'));
+                        // First try to extract JSON from markdown code block
+                        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                        console.log('=== DEBUG: Markdown Block Match ===');
+                        console.log('jsonBlockMatch found:', !!jsonBlockMatch);
+                        if (jsonBlockMatch) {
+                            console.log('Matched JSON length:', jsonBlockMatch[1].length);
+                            console.log('Matched JSON first 100 chars:', JSON.stringify(jsonBlockMatch[1].substring(0, 100)));
+                            jsonResult = JSON.parse(jsonBlockMatch[1]);
+                        }
+                        else {
+                            console.log('=== DEBUG: JSON Object Search ===');
+                            // Try to find JSON object containing "technical_design_result"
+                            const lines = responseText.split('\n');
+                            let jsonStartIndex = -1;
+                            console.log('Total lines:', lines.length);
+                            console.log('Lines preview:', lines
+                                .slice(0, 10)
+                                .map((line, i) => `${i}: ${JSON.stringify(line.substring(0, 50))}`));
+                            // Find the line that contains the start of a JSON object with "technical_design_result"
+                            for (let i = 0; i < lines.length; i++) {
+                                const line = lines[i].trim();
+                                if (line.startsWith('{') &&
+                                    responseText.includes('"technical_design_result"')) {
+                                    console.log(`Found { at line ${i}: ${JSON.stringify(line)}`);
+                                    const fromThisLine = lines.slice(i).join('\n');
+                                    if (fromThisLine.includes('"technical_design_result"')) {
+                                        jsonStartIndex = responseText.indexOf(lines[i]);
+                                        console.log(`JSON start found at line ${i}, responseText index: ${jsonStartIndex}`);
+                                        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);
+                                console.log('=== DEBUG: JSON Extraction ===');
+                                console.log('JSON start index:', jsonStartIndex);
+                                console.log('JSON end index:', endIndex);
+                                console.log('Extracted JSON length:', jsonStr.length);
+                                console.log('Extracted JSON first 100 chars:', JSON.stringify(jsonStr.substring(0, 100)));
+                                console.log('Extracted JSON last 100 chars:', JSON.stringify(jsonStr.substring(jsonStr.length - 100)));
+                                try {
+                                    jsonResult = JSON.parse(jsonStr);
+                                    console.log('JSON parsing succeeded!');
+                                }
+                                catch (parseError) {
+                                    console.log('Failed to parse extracted JSON:', parseError);
+                                    console.log('Extracted JSON string:', jsonStr.substring(0, 200) + '...');
+                                    console.log('=== DEBUG: Fallback to full response ===');
+                                    console.log('Attempting to parse entire responseText as JSON');
+                                    // Try to parse the entire response as JSON as fallback
+                                    jsonResult = JSON.parse(responseText);
+                                }
+                            }
+                            else {
+                                console.log('=== DEBUG: No JSON start found ===');
+                                console.log('Falling back to parse entire responseText as JSON');
+                                // Try to parse the entire response as JSON
+                                jsonResult = JSON.parse(responseText);
+                            }
+                        }
+                        console.log('=== DEBUG: Final Result Processing ===');
+                        console.log('jsonResult exists:', !!jsonResult);
+                        console.log('jsonResult has technical_design_result:', !!(jsonResult && jsonResult.technical_design_result));
+                        if (jsonResult && jsonResult.technical_design_result) {
+                            console.log('checklist_item_results in parsed JSON:', !!jsonResult.technical_design_result.checklist_item_results);
+                            if (jsonResult.technical_design_result.checklist_item_results) {
+                                console.log('checklist_item_results length:', jsonResult.technical_design_result.checklist_item_results
+                                    .length);
+                            }
+                            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');
+                    }
+                    // Try to parse results from the last assistant response
+                    if (lastAssistantResponse) {
+                        try {
+                            const responseText = lastAssistantResponse;
+                            let jsonResult = null;
+                            const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+                            if (jsonBlockMatch) {
+                                jsonResult = JSON.parse(jsonBlockMatch[1]);
+                                if (jsonResult && jsonResult.technical_design_result) {
+                                    structuredDesignResult = jsonResult.technical_design_result;
+                                }
+                            }
+                            else {
+                                // Try to find JSON object containing "technical_design_result"
+                                const lines = responseText.split('\n');
+                                let jsonStartIndex = -1;
+                                // Find the line that contains the start of a JSON object with "technical_design_result"
+                                for (let i = 0; i < lines.length; i++) {
+                                    const line = lines[i].trim();
+                                    if (line.startsWith('{') &&
+                                        responseText.includes('"technical_design_result"')) {
+                                        const fromThisLine = lines.slice(i).join('\n');
+                                        if (fromThisLine.includes('"technical_design_result"')) {
+                                            jsonStartIndex = responseText.indexOf(lines[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);
+                                        if (jsonResult && jsonResult.technical_design_result) {
+                                            structuredDesignResult =
+                                                jsonResult.technical_design_result;
+                                        }
+                                    }
+                                    catch (parseError) {
+                                        logError(`Failed to parse extracted JSON: ${parseError}`);
+                                    }
+                                }
+                                if (!structuredDesignResult) {
+                                    const extractedDesign = extractTechnicalDesignFromResponse(lastAssistantResponse);
+                                    if (extractedDesign) {
+                                        structuredDesignResult = {
+                                            status: 'success',
+                                            technical_design: extractedDesign,
+                                            summary: 'Technical design generated successfully',
+                                        };
+                                    }
+                                }
+                            }
+                        }
+                        catch (error) {
+                            logError(`Failed to parse assistant response: ${error}`);
+                        }
+                    }
+                }
+            }
+        }
+        // Save the technical design if we have it
+        if (structuredDesignResult?.technical_design) {
+            if (verbose) {
+                logInfo('Saving technical design...');
+            }
+            const designSaved = await updateTechnicalDesign(mcpServerUrl, mcpToken, featureId, structuredDesignResult.technical_design, verbose);
+            // Try HTTP fallback if direct update failed
+            if (!designSaved) {
+                if (verbose) {
+                    logInfo('Direct update failed, trying HTTP fallback...');
+                }
+                const fallbackSaved = await saveTechnicalDesignViaHttp({
+                    mcpServerUrl,
+                    mcpToken,
+                    featureId,
+                    technicalDesign: structuredDesignResult.technical_design,
+                    verbose,
+                });
+                if (!fallbackSaved && verbose) {
+                    logError('⚠️  Both direct update and HTTP fallback failed');
+                }
+                return {
+                    featureId,
+                    technicalDesign: structuredDesignResult.technical_design,
+                    status: fallbackSaved ? 'success' : 'error',
+                    summary: fallbackSaved
+                        ? 'Technical design generated and saved via HTTP fallback'
+                        : 'Technical design generated but failed to save',
+                    savedViaHttp: fallbackSaved,
+                    data: {
+                        checklist_item_results: structuredDesignResult.checklist_item_results || [],
+                    },
+                };
+            }
+            return {
+                featureId,
+                technicalDesign: structuredDesignResult.technical_design,
+                status: 'success',
+                summary: 'Technical design generated and saved successfully',
+                data: {
+                    checklist_item_results: structuredDesignResult.checklist_item_results || [],
+                },
+            };
+        }
+        return {
+            featureId,
+            technicalDesign: null,
+            status: 'error',
+            summary: 'No technical design was generated',
+        };
+    }
+    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)}`,
+        };
+    }
+};
+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;
+};
+export const checkTechnicalDesignRequirements = async () => {
+    try {
+        // Check if Claude Code SDK is available
+        const claudeCode = await import('@anthropic-ai/claude-code');
+        return claudeCode && typeof claudeCode.query === 'function';
+    }
+    catch (error) {
+        console.log('Technical design requirements check failed:', error instanceof Error ? error.message : error);
+        return false;
+    }
+};

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

@@ -0,0 +1,12 @@
+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(mcpServerUrl: string, mcpToken: string, featureId: string, verbose?: boolean): Promise<TechnicalDesignContext>;

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

@@ -0,0 +1,39 @@
+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(mcpServerUrl, mcpToken, 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(mcpServerUrl, mcpToken, featureId, verbose),
+            getUserStories(mcpServerUrl, mcpToken, featureId, verbose),
+            getTestCases(mcpServerUrl, mcpToken, featureId, verbose),
+        ]);
+        const product = await getProduct(mcpServerUrl, mcpToken, 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/{technical-design → phases/technical-design}/http-fallback.js

@@ -1,4 +1,4 @@
-import { logInfo, logError } from '../logger.js';
+import { logInfo, logError } from '../../utils/logger.js';
 /**
  * Save technical design via HTTP as a fallback when MCP server fails
  */