edsger 0.23.0 → 0.24.0

package/dist/commands/workflow/config/phase-configs.js

@@ -2,6 +2,8 @@
  * Phase configurations for the pipeline runner
  */
 import { analyseFeature } from '../../../phases/feature-analysis/index.js';
+import { analyseUserStories } from '../../../phases/user-stories-analysis/index.js';
+import { analyseTestCases } from '../../../phases/test-cases-analysis/index.js';
 import { generateTechnicalDesign } from '../../../phases/technical-design/index.js';
 import { planFeatureBranches } from '../../../phases/branch-planning/index.js';
 import { implementFeatureCode } from '../../../phases/code-implementation/index.js';
@@ -73,6 +75,14 @@ export const phaseConfigs = [
         name: 'feature-analysis',
         execute: analyseFeature,
     },
+    {
+        name: 'user-stories-analysis',
+        execute: analyseUserStories,
+    },
+    {
+        name: 'test-cases-analysis',
+        execute: analyseTestCases,
+    },
     {
         name: 'technical-design',
         execute: generateTechnicalDesign,

package/dist/commands/workflow/executors/phase-executor.d.ts

@@ -4,5 +4,5 @@
 import { EdsgerConfig } from '../../../types/index.js';
 import { PipelinePhaseOptions, PipelineResult, PhaseConfig } from '../../../types/pipeline.js';
 export declare const createPhaseRunner: (phaseConfig: PhaseConfig) => (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };
+declare const runFeatureAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runUserStoriesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTestCasesAnalysisPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runTechnicalDesignPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runBranchPlanningPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeImplementationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runFunctionalTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeTestingPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefinePhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeRefineVerificationPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runCodeReviewPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>, runAutonomousPhase: (options: PipelinePhaseOptions, config: EdsgerConfig) => Promise<PipelineResult>;
+export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

package/dist/commands/workflow/executors/phase-executor.js

@@ -262,6 +262,6 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     }
 };
 // Create phase runners using the configuration
-const [runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
+const [runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase,] = phaseConfigs.map(createPhaseRunner);
 // Export individual phase runners for granular control
-export { runFeatureAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };
+export { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runBranchPlanningPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeRefinePhase, runCodeRefineVerificationPhase, runCodeReviewPhase, runAutonomousPhase, };

package/dist/commands/workflow/phase-orchestrator.js

@@ -14,7 +14,7 @@
  * Uses functional programming principles for composability
  */
 import { updateFeatureStatusForPhase, markWorkflowPhaseCompleted, } from '../../api/features/index.js';
-import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
+import { runFeatureAnalysisPhase, runUserStoriesAnalysisPhase, runTestCasesAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../../phases/functional-testing/test-retry-handler.js';
 import { handleCodeRefineWithRetry } from '../../phases/code-refine/retry-handler.js';
@@ -52,12 +52,22 @@ export const runPipelineByMode = async (options, config, executionMode) => {
                 logInfo(`  ➡️ Matched: full_pipeline or from_feature_analysis - running complete pipeline`);
             }
             return await runFromFeatureAnalysis(options, config);
-        // Feature Analysis
+        // Feature Analysis (legacy - generates both user stories and test cases)
         case 'only_feature_analysis':
             if (verbose) {
                 logInfo(`  ➡️ Matched: only_feature_analysis - running analysis only`);
             }
             return await runOnlyFeatureAnalysis(options, config);
+        // User Stories Analysis
+        case 'only_user_stories_analysis':
+            return await runOnlyUserStoriesAnalysis(options, config);
+        case 'from_user_stories_analysis':
+            return await runFromUserStoriesAnalysis(options, config);
+        // Test Cases Analysis
+        case 'only_test_cases_analysis':
+            return await runOnlyTestCasesAnalysis(options, config);
+        case 'from_test_cases_analysis':
+            return await runFromTestCasesAnalysis(options, config);
         // Technical Design
         case 'only_technical_design':
             return await runOnlyTechnicalDesign(options, config);
@@ -120,6 +130,140 @@ const runOnlyFeatureAnalysis = async (options, config) => {
     results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
+/**
+ * Run only user stories analysis phase
+ */
+const runOnlyUserStoriesAnalysis = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const analysisResult = await runUserStoriesAnalysisPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
+    return finalizePipelineExecution(options, results, verbose);
+};
+/**
+ * Run only test cases analysis phase
+ */
+const runOnlyTestCasesAnalysis = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    const analysisResult = await runTestCasesAnalysisPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
+    return finalizePipelineExecution(options, results, verbose);
+};
+/**
+ * Run from user stories analysis to end
+ * Flow: user-stories-analysis → test-cases-analysis → technical-design → code-implementation → ...
+ */
+const runFromUserStoriesAnalysis = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. User Stories Analysis
+    const userStoriesResult = await runUserStoriesAnalysisPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(userStoriesResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 2. Test Cases Analysis
+    const testCasesResult = await runTestCasesAnalysisPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(testCasesResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 3. Technical Design
+    const designResult = await runTechnicalDesignPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(designResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 4. Code Implementation
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 5. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            results,
+            testingResult,
+            verbose,
+        });
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                logInfo('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return finalizePipelineExecution(options, results, verbose);
+};
+/**
+ * Run from test cases analysis to end
+ * Flow: test-cases-analysis → technical-design → code-implementation → ...
+ */
+const runFromTestCasesAnalysis = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // 1. Test Cases Analysis
+    const testCasesResult = await runTestCasesAnalysisPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(testCasesResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 2. Technical Design
+    const designResult = await runTechnicalDesignPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(designResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 3. Code Implementation
+    const implementationResult = await runCodeImplementationPhase(options, config);
+    results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
+    if (!shouldContinuePipeline(results)) {
+        return finalizePipelineExecution(options, results, verbose);
+    }
+    // 4. Functional Testing with retry loop for bug fixes
+    const testingResult = await handleTestFailuresWithRetry({
+        options,
+        config,
+        results,
+        verbose,
+    });
+    const finalStatus = testingResult.status === 'success' ? 'testing_passed' : 'testing_failed';
+    await updateFeatureStatusForPhase(featureId, finalStatus === 'testing_passed' ? 'testing-passed' : 'testing-failed', verbose);
+    if (testingResult.status === 'success') {
+        const prCreated = await handlePullRequestCreation({
+            featureId,
+            results,
+            testingResult,
+            verbose,
+        });
+        if (prCreated) {
+            await continueWithCodeReviewAndRefine(options, config, results, verbose);
+        }
+        else {
+            if (verbose) {
+                logInfo('⚠️ Skipping code review and refine workflow: pull request creation failed');
+            }
+        }
+    }
+    return finalizePipelineExecution(options, results, verbose);
+};
 /**
  * Run only technical design phase
  */

package/dist/config/feature-status.js

@@ -26,6 +26,10 @@ export const STATUS_PROGRESSION_ORDER = [
     'assigned_to_ai',
     'feature_analysis',
     'feature_analysis_verification',
+    'user_stories_analysis',
+    'user_stories_analysis_verification',
+    'test_cases_analysis',
+    'test_cases_analysis_verification',
     'technical_design',
     'technical_design_verification',
     'branch_planning',
@@ -59,6 +63,10 @@ export const STATUS_PROGRESSION_ORDER = [
 export const PHASE_STATUS_MAP = {
     'feature-analysis': 'feature_analysis',
     'feature-analysis-verification': 'feature_analysis_verification',
+    'user-stories-analysis': 'user_stories_analysis',
+    'user-stories-analysis-verification': 'user_stories_analysis_verification',
+    'test-cases-analysis': 'test_cases_analysis',
+    'test-cases-analysis-verification': 'test_cases_analysis_verification',
     'technical-design': 'technical_design',
     'technical-design-verification': 'technical_design_verification',
     'branch-planning': 'branch_planning',
@@ -92,6 +100,8 @@ export const HUMAN_SELECTABLE_STATUSES = [
     'backlog',
     'ready_for_ai',
     'feature_analysis',
+    'user_stories_analysis',
+    'test_cases_analysis',
     'technical_design',
     'branch_planning',
     'code_implementation',

package/dist/phases/feature-analysis/index.js

@@ -5,14 +5,11 @@ import { executeAnalysisQuery } from './agent.js';
 import { performVerificationCycle } from '../feature-analysis-verification/index.js';
 import { deleteArtifacts, deleteSpecificArtifacts, updateArtifactsToReady, saveAnalysisArtifactsAsDraft, buildAnalysisResult, } from './outcome.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
 export const analyseFeature = async (options, config, checklistContext) => {
     const { featureId, verbose } = options;
     if (verbose) {
         logInfo(`Starting feature analysis for feature ID: ${featureId}`);
     }
-    // Prepare git environment: switch to feature branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
         const context = await prepareAnalysisContext(featureId, checklistContext, verbose);
         const systemPrompt = createFeatureAnalysisSystemPrompt();
@@ -157,8 +154,4 @@ export const analyseFeature = async (options, config, checklistContext) => {
             status: 'error',
         };
     }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
 };

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

@@ -10,7 +10,6 @@ import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services
 import { buildDesignResult, buildVerificationFailureResult, buildNoResultsError, } from './outcome.js';
 import { performVerificationCycle } from '../technical-design-verification/index.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
-import { preparePhaseGitEnvironment } from '../../utils/git-branch-manager.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -26,8 +25,6 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
     if (verbose) {
         logInfo(`Starting technical design generation for feature ID: ${featureId}`);
     }
-    // Prepare git environment: switch to feature branch and rebase with main
-    const cleanupGit = preparePhaseGitEnvironment(featureId, 'main', verbose);
     try {
         // Fetch and prepare context
         const context = await prepareDesignContext(featureId, checklistContext, verbose);
@@ -143,10 +140,6 @@ export const generateTechnicalDesign = async (options, config, checklistContext)
             summary: `Generation failed: ${error instanceof Error ? error.message : String(error)}`,
         };
     }
-    finally {
-        // Always return to main branch after phase completion
-        cleanupGit();
-    }
 };
 /**
  * Prepare all context information needed for design

package/dist/phases/test-cases-analysis/agent.d.ts

@@ -0,0 +1,2 @@
+import { EdsgerConfig } from '../../types/index.js';
+export declare function executeTestCasesAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<any | null>;

package/dist/phases/test-cases-analysis/agent.js

@@ -0,0 +1,102 @@
+import { query } from '@anthropic-ai/claude-agent-sdk';
+import { DEFAULT_MODEL } from '../../constants.js';
+import { logInfo, logError } from '../../utils/logger.js';
+function parseAnalysisResult(responseText) {
+    try {
+        let jsonResult = null;
+        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
+        if (jsonBlockMatch) {
+            jsonResult = JSON.parse(jsonBlockMatch[1]);
+        }
+        else {
+            jsonResult = JSON.parse(responseText);
+        }
+        if (jsonResult && jsonResult.analysis) {
+            return { analysis: jsonResult.analysis };
+        }
+        else {
+            return { error: 'Invalid JSON structure' };
+        }
+    }
+    catch (error) {
+        return {
+            error: `JSON parsing failed: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+}
+function userMessage(content) {
+    return {
+        type: 'user',
+        message: { role: 'user', content: content },
+    };
+}
+async function* prompt(analysisPrompt) {
+    yield userMessage(analysisPrompt);
+}
+export async function executeTestCasesAnalysisQuery(currentPrompt, systemPrompt, config, verbose) {
+    let lastAssistantResponse = '';
+    let structuredAnalysisResult = null;
+    for await (const message of query({
+        prompt: prompt(currentPrompt),
+        options: {
+            systemPrompt: {
+                type: 'preset',
+                preset: 'claude_code',
+                append: systemPrompt,
+            },
+            model: DEFAULT_MODEL,
+            maxTurns: 1000,
+            permissionMode: 'bypassPermissions',
+        },
+    })) {
+        if (verbose) {
+            logInfo(`Received message type: ${message.type}`);
+        }
+        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📊 Test cases analysis completed, parsing results...');
+                const responseText = message.result || lastAssistantResponse;
+                const parsed = parseAnalysisResult(responseText);
+                if (parsed.error) {
+                    logError(`Failed to parse structured analysis result: ${parsed.error}`);
+                    structuredAnalysisResult = {
+                        status: 'error',
+                        summary: 'Failed to parse analysis results from Claude Code response',
+                        created_test_cases: [],
+                    };
+                }
+                else {
+                    structuredAnalysisResult = parsed.analysis;
+                }
+            }
+            else {
+                logError(`\n⚠️ Analysis incomplete: ${message.subtype}`);
+                if (message.subtype === 'error_max_turns') {
+                    logError('💡 Try increasing timeout or reducing complexity');
+                }
+                if (lastAssistantResponse) {
+                    const parsed = parseAnalysisResult(lastAssistantResponse);
+                    if (!parsed.error) {
+                        structuredAnalysisResult = parsed.analysis;
+                    }
+                }
+            }
+        }
+    }
+    return structuredAnalysisResult;
+}

package/dist/phases/test-cases-analysis/context.d.ts

@@ -0,0 +1,14 @@
+import type { FeatureInfo, UserStory, TestCase } from '../../types/features.js';
+import { type ProductInfo } from '../../api/products.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface TestCasesAnalysisContext {
+    feature: FeatureInfo;
+    product: ProductInfo;
+    existing_user_stories: UserStory[];
+    existing_test_cases: TestCase[];
+}
+export declare function fetchTestCasesAnalysisContext(featureId: string, verbose?: boolean): Promise<TestCasesAnalysisContext>;
+export declare function prepareTestCasesAnalysisContext(featureId: string, checklistContext: ChecklistPhaseContext | null | undefined, verbose?: boolean): Promise<{
+    featureContext: TestCasesAnalysisContext;
+    analysisPrompt: string;
+}>;

package/dist/phases/test-cases-analysis/context.js

@@ -0,0 +1,78 @@
+import { logInfo, logError } from '../../utils/logger.js';
+import { getFeature, getUserStories, getTestCases, } from '../../api/features/index.js';
+import { getProduct } from '../../api/products.js';
+import { formatChecklistsForContext, } from '../../services/checklist.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
+import { formatTestCasesAnalysisContext } from './formatters.js';
+import { createTestCasesAnalysisPromptWithContext } from './prompts.js';
+export async function fetchTestCasesAnalysisContext(featureId, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`Fetching test cases analysis context for feature: ${featureId}`);
+        }
+        const [feature, existing_user_stories, existing_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(`✅ Test cases analysis context fetched successfully:`);
+            logInfo(`   Feature: ${feature.name}`);
+            logInfo(`   Product: ${product.name}`);
+            logInfo(`   User Stories: ${existing_user_stories.length}`);
+            logInfo(`   Existing Test Cases: ${existing_test_cases.length}`);
+        }
+        return {
+            feature,
+            product,
+            existing_user_stories,
+            existing_test_cases,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        logError(`Failed to fetch test cases analysis context: ${errorMessage}`);
+        throw new Error(`Context fetch failed: ${errorMessage}`);
+    }
+}
+export async function prepareTestCasesAnalysisContext(featureId, checklistContext, verbose) {
+    if (verbose) {
+        logInfo('Fetching test cases analysis context via MCP endpoints...');
+    }
+    const featureContext = await fetchTestCasesAnalysisContext(featureId, verbose);
+    const { content: contextInfo, downloadedImages } = await formatTestCasesAnalysisContext(featureContext);
+    if (verbose && downloadedImages.length > 0) {
+        logInfo(`Downloaded ${downloadedImages.length} images for Claude Code:`);
+        downloadedImages.forEach((img) => {
+            logInfo(`  - ${img.url} -> ${img.localPath}`);
+        });
+    }
+    let finalContextInfo = contextInfo;
+    // Add feedbacks context
+    try {
+        const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'test-cases-analysis');
+        if (feedbacksContext.feedbacks.length > 0) {
+            const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
+            finalContextInfo = finalContextInfo + '\n\n' + feedbacksInfo;
+            if (verbose) {
+                logInfo(`Added ${feedbacksContext.feedbacks.length} human feedbacks to context`);
+            }
+        }
+    }
+    catch (error) {
+        if (verbose) {
+            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
+        }
+    }
+    // Add checklist context
+    if (checklistContext && checklistContext.checklists.length > 0) {
+        const checklistInfo = formatChecklistsForContext(checklistContext);
+        finalContextInfo = finalContextInfo + '\n\n' + checklistInfo;
+        if (verbose) {
+            logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
+        }
+    }
+    const analysisPrompt = createTestCasesAnalysisPromptWithContext(featureId, finalContextInfo);
+    return { featureContext, analysisPrompt };
+}

package/dist/phases/test-cases-analysis/formatters.d.ts

@@ -0,0 +1,6 @@
+import { type DownloadedImage } from '../../utils/image-downloader.js';
+import { TestCasesAnalysisContext } from './context.js';
+export declare function formatTestCasesAnalysisContext(context: TestCasesAnalysisContext): Promise<{
+    content: string;
+    downloadedImages: DownloadedImage[];
+}>;

package/dist/phases/test-cases-analysis/formatters.js

@@ -0,0 +1,35 @@
+import { downloadImagesForClaudeCode, } from '../../utils/image-downloader.js';
+import { formatUserStories, formatTestCases } from '../../utils/formatters.js';
+export async function formatTestCasesAnalysisContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id);
+    const content = `# Test Cases Analysis Context
+
+## Feature Information
+- **ID**: ${context.feature.id}
+- **Name**: ${context.feature.name}
+- **Description**:
+${processedMarkdown}
+
+${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
+
+- **Current Status**: ${context.feature.status}
+
+## Product Information
+- **Product**: ${context.product.name}
+- **Product ID**: ${context.product.id}
+- **Description**: ${context.product.description || 'No product description'}
+
+## User Stories (${context.existing_user_stories.length})
+${formatUserStories(context.existing_user_stories)}
+
+## Existing Test Cases (${context.existing_test_cases.length})
+${formatTestCases(context.existing_test_cases)}
+
+## Current Technical Design
+${context.feature.technical_design || 'No technical design available yet'}
+
+---
+
+**Analysis Instructions**: Based on the above feature information, user stories, and existing test cases, create comprehensive test cases that ensure thorough testing coverage.`;
+    return { content, downloadedImages };
+}

package/dist/phases/test-cases-analysis/index.d.ts

@@ -0,0 +1,9 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+import { TestCasesAnalysisResult } from './outcome.js';
+export interface TestCasesAnalysisOptions {
+    featureId: string;
+    verbose?: boolean;
+    maxVerificationIterations?: number;
+}
+export declare const analyseTestCases: (options: TestCasesAnalysisOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TestCasesAnalysisResult>;