edsger 0.77.0 → 0.78.0

package/dist/phases/technical-design-verification/prompts.js

@@ -1,143 +0,0 @@
-import { resolveSkill } from '../../services/skill-resolver.js';
-import { downloadImagesForClaudeCode } from '../../utils/image-downloader.js';
-import { OUTPUT_CONTRACTS } from '../output-contracts.js';
-export const createTechnicalDesignVerificationSystemPrompt = async (projectDir) => {
-    const skill = await resolveSkill('phase/technical-design-verification', {
-        projectDir,
-    });
-    if (!skill) {
-        throw new Error('Failed to load skill: phase/technical-design-verification');
-    }
-    return `${skill.prompt}
-
-${OUTPUT_CONTRACTS['technical-design-verification']}`;
-};
-export const createTechnicalDesignVerificationPrompt = async (options) => {
-    const { checklistContext, feedbacksContext, issueId, issueName, issueDescription, technicalDesign, } = options;
-    // Format all checklist items with their requirements
-    const checklistItemsSection = checklistContext.checklists
-        .flatMap((checklist) => checklist.items.map((item) => {
-        return `### Checklist Item: ${item.title}
-**ID**: ${item.id}
-**Checklist**: ${checklist.name} (${checklist.role})
-**Requirement**: ${item.description}
-**Required**: ${item.is_required ? 'Yes' : 'No'}
-**Type**: ${item.item_type}
-`;
-    }))
-        .join('\n---\n');
-    const totalChecklistItems = checklistContext.checklists.reduce((sum, checklist) => sum + checklist.items.length, 0);
-    // Format feedbacks section if provided (with image processing)
-    let feedbacksSection = '';
-    let totalFeedbacks = 0;
-    if (feedbacksContext && feedbacksContext.feedbacks.length > 0) {
-        totalFeedbacks = feedbacksContext.feedbacks.length;
-        // Process images in feedback contents
-        const processedFeedbacks = await Promise.all(feedbacksContext.feedbacks.map(async (feedback) => {
-            if (!feedback.content) {
-                return feedback;
-            }
-            const { processedMarkdown } = await downloadImagesForClaudeCode(feedback.content, issueId);
-            return { ...feedback, content: processedMarkdown };
-        }));
-        feedbacksSection = `
-
-## Human Feedbacks to Verify (${totalFeedbacks})
-
-${processedFeedbacks
-            .map((feedback, idx) => {
-            const lowPriorityBadge = feedback.priority >= 5 ? '🟡' : '🟢';
-            const midPriorityBadge = feedback.priority >= 7 ? '🟠' : lowPriorityBadge;
-            const priorityBadge = feedback.priority >= 9 ? '🔴' : midPriorityBadge;
-            return `### Feedback ${idx + 1}: ${feedback.title} ${priorityBadge}
-**ID**: ${feedback.id}
-**Type**: ${feedback.feedback_type}
-**Priority**: ${feedback.priority}
-**Content**: ${feedback.content}
-`;
-        })
-            .join('\n---\n')}
-
-`;
-    }
-    return `# Technical Design Verification Task
-
-You are verifying that a technical design document satisfies checklist requirements${totalFeedbacks > 0 ? ' and addresses human feedbacks' : ''}.
-
-## Issue Context
-
-**Issue**: ${issueName}
-**Issue ID**: ${issueId}
-**Description**: ${issueDescription || 'No description'}
-
-## Technical Design Document
-
-${technicalDesign}
-
-## Checklist Requirements to Verify (${totalChecklistItems})
-
-${checklistItemsSection}${feedbacksSection}
-
----
-
-## Your Verification Task
-
-### Part 1: Checklist Verification
-
-For EACH checklist item above:
-
-1. **Understand the Requirement**: What does this checklist item require?
-
-2. **Examine the Design**: Look at the technical design document above
-
-3. **Determine Coverage**: Does the design adequately address this requirement?
-   - Does it directly address the requirement?
-   - Is the coverage concrete and specific?
-   - Is there sufficient technical depth and detail?
-   - Are there any gaps or missing elements?
-
-4. **Make Your Determination**:
-   - **CONFIRMED** (is_satisfied: true): The design clearly and adequately satisfies this requirement
-   - **REJECTED** (is_satisfied: false): The requirement is not addressed, or addressed insufficiently
-   - **UNCERTAIN** (is_satisfied: false): The design partially addresses the requirement but with gaps
-
-5. **Document Your Reasoning**: Provide specific, detailed reasons for your decision
-
-6. **Provide Improvement Suggestions** (for rejected/uncertain items):
-   - Be specific and actionable
-   - Suggest what sections or details should be added to the design
-   - Indicate what should be expanded or modified
-   - Give concrete examples when possible
-${totalFeedbacks > 0
-        ? `
-
-### Part 2: Feedback Verification
-
-For EACH feedback above:
-
-1. **Understand the Feedback**: What specific concern, requirement, or suggestion does this feedback provide?
-
-2. **Examine the Design**: Look at the technical design document to see if this feedback was addressed
-
-3. **Determine if Addressed**: Was the feedback properly incorporated into the design?
-   - Does the design explicitly address this feedback?
-   - Are the changes requested in the feedback reflected in the design?
-   - Is the implementation aligned with the feedback's intent?
-
-4. **Make Your Determination**:
-   - **CONFIRMED** (is_addressed: true): The design clearly addresses this feedback
-   - **REJECTED** (is_addressed: false): The feedback was not addressed or was ignored
-   - **UNCERTAIN** (is_addressed: false): The design partially addresses the feedback but incompletely
-
-5. **Document Your Reasoning**: Explain whether and how the feedback was addressed
-
-6. **Provide Improvement Suggestions** (for rejected/uncertain feedbacks):
-   - Explain how the feedback should be incorporated
-   - Suggest specific modifications to address the feedback
-   - Provide concrete examples of what should be added or changed`
-        : ''}
-
-Remember: Focus on what the design actually contains, not on claims. Be thorough and fair.
-
-Provide your verification results in the required JSON format with improvement_suggestions for any rejected or uncertain items${totalFeedbacks > 0 ? ' or feedbacks' : ''}.`;
-};

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

@@ -1,9 +0,0 @@
-import { type EdsgerConfig, type WithExecutionSessionId } from '../../types/index.js';
-interface ParsedAnalysisResult {
-    analysis?: any;
-    error?: string;
-}
-export type AnalysisQueryResult = Record<string, unknown> & WithExecutionSessionId;
-export declare function parseAnalysisResult(responseText: string): ParsedAnalysisResult;
-export declare function executeTestCasesAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<AnalysisQueryResult | null>;
-export {};

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

@@ -1,105 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-export function parseAnalysisResult(responseText) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        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 };
-        }
-        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 },
-    };
-}
-// eslint-disable-next-line @typescript-eslint/require-await -- async generator required by SDK interface
-async function* prompt(analysisPrompt) {
-    yield userMessage(analysisPrompt);
-}
-export async function executeTestCasesAnalysisQuery(currentPrompt, systemPrompt, config, verbose) {
-    let lastAssistantResponse = '';
-    let structuredAnalysisResult = null;
-    let executionSessionId = '';
-    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`;
-                    logDebug(`🤖 ${content.text}`, verbose);
-                }
-                else if (content.type === 'tool_use') {
-                    const input = (content.input ?? {});
-                    logDebug(`🔧 ${content.name}: ${input.description ?? 'Running...'}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            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;
-                    }
-                }
-            }
-        }
-    }
-    if (structuredAnalysisResult) {
-        structuredAnalysisResult.execution_session_id =
-            executionSessionId || undefined;
-    }
-    return structuredAnalysisResult;
-}

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

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

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

@@ -1,86 +0,0 @@
-import { getIssue, getTestCases, getUserStories, } from '../../api/issues/index.js';
-import { getProduct } from '../../api/products.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { formatTestCasesAnalysisContext } from './formatters.js';
-import { createTestCasesAnalysisPromptWithContext, createTestCasesFeedbackFocusedPromptWithContext, } from './prompts.js';
-export async function fetchTestCasesAnalysisContext(issueId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching test cases analysis context for issue: ${issueId}`);
-        }
-        const [issue, existingUserStories, existingTestCases] = await Promise.all([
-            getIssue(issueId, verbose),
-            getUserStories(issueId, verbose),
-            getTestCases(issueId, verbose),
-        ]);
-        const product = await getProduct(issue.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Test cases analysis context fetched successfully:`);
-            logInfo(`   Issue: ${issue.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   User Stories: ${existingUserStories.length}`);
-            logInfo(`   Existing Test Cases: ${existingTestCases.length}`);
-        }
-        return {
-            issue,
-            product,
-            existing_user_stories: existingUserStories,
-            existing_test_cases: existingTestCases,
-        };
-    }
-    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(issueId, checklistContext, verbose) {
-    if (verbose) {
-        logInfo('Fetching test cases analysis context via MCP endpoints...');
-    }
-    const issueContext = await fetchTestCasesAnalysisContext(issueId, verbose);
-    const { content: contextInfo, downloadedImages } = await formatTestCasesAnalysisContext(issueContext);
-    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;
-    // Add feedbacks context
-    try {
-        const feedbacksContext = await getFeedbacksForPhase({ issueId, verbose }, 'test-cases-analysis');
-        if (feedbacksContext.feedbacks.length > 0) {
-            hasFeedbacks = true;
-            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 hasExistingArtifacts = issueContext.existing_test_cases.length > 0;
-    const analysisPrompt = hasFeedbacks && hasExistingArtifacts
-        ? createTestCasesFeedbackFocusedPromptWithContext(issueId, finalContextInfo)
-        : createTestCasesAnalysisPromptWithContext(issueId, finalContextInfo);
-    if (verbose && hasFeedbacks && hasExistingArtifacts) {
-        logInfo('Using feedback-focused prompt (re-run with human feedbacks detected)');
-    }
-    return { issueContext, analysisPrompt, hasFeedbacks };
-}

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

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

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

@@ -1,35 +0,0 @@
-import { formatTestCases, formatUserStories } from '../../utils/formatters.js';
-import { downloadImagesForClaudeCode, } from '../../utils/image-downloader.js';
-export async function formatTestCasesAnalysisContext(context) {
-    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.issue.description || 'No description provided', context.issue.id);
-    const content = `# Test Cases Analysis Context
-
-## Issue Information
-- **ID**: ${context.issue.id}
-- **Name**: ${context.issue.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.issue.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.issue.technical_design || 'No technical design available yet'}
-
----
-
-**Analysis Instructions**: Based on the above issue 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

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

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

@@ -1,175 +0,0 @@
-import { logIssuePhaseEvent } from '../../services/audit-logs.js';
-import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { performVerificationCycle } from '../issue-analysis-verification/index.js';
-import { executeTestCasesAnalysisQuery, parseAnalysisResult } from './agent.js';
-import { prepareTestCasesAnalysisContext } from './context.js';
-import { buildTestCasesAnalysisResult, deleteSpecificTestCases, deleteTestCaseArtifacts, getAllDraftTestCaseIds, resetReadyTestCasesToDraft, saveTestCasesAsDraft, updateTestCasesToReady, } from './outcome.js';
-import { createTestCasesAnalysisSystemPrompt } from './prompts.js';
-export const analyseTestCases = async (options, config, checklistContext) => {
-    const { issueId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting test cases analysis for issue ID: ${issueId}`);
-    }
-    try {
-        // Reset pending_approval test cases to draft so AI can manage them on re-run
-        const resetCount = await resetReadyTestCasesToDraft(issueId, verbose);
-        if (verbose && resetCount > 0) {
-            logInfo(`✅ Reset ${resetCount} pending_approval test cases to draft for re-analysis`);
-        }
-        const context = await prepareTestCasesAnalysisContext(issueId, checklistContext, verbose);
-        const systemPrompt = await createTestCasesAnalysisSystemPrompt();
-        const initialAnalysisPrompt = context.analysisPrompt;
-        const maxIterations = options.maxVerificationIterations || 10;
-        let currentIteration = 0;
-        let currentPrompt = initialAnalysisPrompt;
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let structuredAnalysisResult = null;
-        let verificationResult = null;
-        if (verbose) {
-            logInfo('Starting Claude Code query for test cases analysis...');
-        }
-        let currentDraftTestCaseIds = [];
-        while (currentIteration < maxIterations) {
-            currentIteration++;
-            if (verbose && currentIteration > 1) {
-                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving test cases based on verification feedback...`);
-            }
-            if (currentIteration > 1) {
-                await logIssuePhaseEvent({
-                    issueId,
-                    eventType: 'phase_started',
-                    phase: 'test_cases_analysis',
-                    result: 'info',
-                    metadata: {
-                        iteration: currentIteration,
-                        max_iterations: maxIterations,
-                        re_analysis: true,
-                        timestamp: new Date().toISOString(),
-                    },
-                }, verbose);
-            }
-            structuredAnalysisResult = await executeTestCasesAnalysisQuery(currentPrompt, systemPrompt, config, verbose);
-            if (!structuredAnalysisResult) {
-                break;
-            }
-            await logIssuePhaseEvent({
-                issueId,
-                eventType: 'phase_completed',
-                phase: 'test_cases_analysis',
-                result: 'success',
-                metadata: {
-                    iteration: currentIteration,
-                    max_iterations: maxIterations,
-                    analysis_step: 'completed',
-                    test_cases_count: structuredAnalysisResult.created_test_cases?.length || 0,
-                    deleted_test_cases_count: structuredAnalysisResult.deleted_test_case_ids?.length || 0,
-                    timestamp: new Date().toISOString(),
-                },
-            }, verbose);
-            // Handle deletions identified by AI
-            if (structuredAnalysisResult.deleted_test_case_ids?.length > 0) {
-                if (verbose) {
-                    logInfo('🗑️  Processing test case deletions identified by AI...');
-                }
-                await deleteSpecificTestCases(issueId, structuredAnalysisResult.deleted_test_case_ids || [], structuredAnalysisResult.deletion_reasons || {}, verbose);
-            }
-            // Save test cases as draft
-            const { testCaseIds } = await saveTestCasesAsDraft(issueId, structuredAnalysisResult.created_test_cases || [], verbose);
-            currentDraftTestCaseIds = testCaseIds;
-            // Coaching loop between execute and verify
-            await runPhaseCoaching({
-                issueId,
-                phase: 'test_cases_analysis',
-                phaseResult: structuredAnalysisResult,
-                checklistItems: extractChecklistItems(checklistContext),
-                onImproved: async (_sessionId, responseText) => {
-                    const parsed = parseAnalysisResult(responseText);
-                    if (parsed.analysis) {
-                        await deleteTestCaseArtifacts(currentDraftTestCaseIds, verbose);
-                        const { testCaseIds: newTestCaseIds } = await saveTestCasesAsDraft(issueId, parsed.analysis.created_test_cases || [], verbose);
-                        currentDraftTestCaseIds = newTestCaseIds;
-                        structuredAnalysisResult = parsed.analysis;
-                    }
-                    else {
-                        logWarning(`Coaching improvement response could not be parsed for test-cases-analysis. Keeping previous drafts. ${parsed.error || ''}`);
-                    }
-                },
-                verbose,
-            });
-            // Perform verification cycle
-            const verificationCycle = await performVerificationCycle({
-                structuredAnalysisResult: {
-                    ...structuredAnalysisResult,
-                    created_user_stories: [],
-                },
-                checklistContext: checklistContext || null,
-                context: context.issueContext,
-                config,
-                currentIteration,
-                maxIterations,
-                issueId,
-                verbose,
-            });
-            ({ verificationResult } = verificationCycle);
-            if (verificationCycle.passed) {
-                if (verbose) {
-                    logInfo('✅ Verification passed! Updating all draft test cases to pending_approval status...');
-                }
-                // Update ALL remaining draft test cases (both kept old ones and newly created)
-                const allDraftIds = await getAllDraftTestCaseIds(issueId, verbose);
-                await updateTestCasesToReady(allDraftIds, verbose);
-                break;
-            }
-            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
-                if (verbose) {
-                    logInfo('🗑️  Deleting draft test cases for re-analysis...');
-                }
-                await deleteTestCaseArtifacts(currentDraftTestCaseIds, verbose);
-                currentPrompt = verificationCycle.nextPrompt;
-            }
-            else {
-                if (verbose) {
-                    logInfo('⚠️  Max iterations reached. Draft test cases kept for manual review.');
-                }
-                break;
-            }
-        }
-        if (!structuredAnalysisResult) {
-            throw new Error('No analysis results received');
-        }
-        // If no checklist was used, update all draft artifacts to pending_approval
-        if (!checklistContext ||
-            checklistContext.checklists.length === 0 ||
-            !verificationResult) {
-            const allDraftIds = await getAllDraftTestCaseIds(issueId, verbose);
-            if (allDraftIds.length > 0) {
-                if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating all draft test cases to pending_approval status...');
-                }
-                await updateTestCasesToReady(allDraftIds, verbose);
-            }
-        }
-        if (verificationResult &&
-            verificationResult.rejected_count > 0 &&
-            checklistContext &&
-            checklistContext.checklists.length > 0) {
-            logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
-            logError(`   Draft test cases (${currentDraftTestCaseIds.length}) kept for manual review`);
-            throw new Error(`Checklist verification failed after ${currentIteration} iterations`);
-        }
-        return buildTestCasesAnalysisResult(issueId, context.issueContext, structuredAnalysisResult, currentIteration);
-    }
-    catch (error) {
-        logError(`Test cases analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            issueId,
-            productInfo: null,
-            issueInfo: null,
-            existingTestCases: [],
-            createdTestCases: [],
-            summary: `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
-            status: 'error',
-        };
-    }
-};

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

@@ -1,27 +0,0 @@
-import { type TestCasesAnalysisContext } from './context.js';
-export declare function resetReadyTestCasesToDraft(issueId: string, verbose?: boolean): Promise<number>;
-export declare function getAllDraftTestCaseIds(issueId: string, verbose?: boolean): Promise<string[]>;
-export declare function deleteTestCaseArtifacts(testCaseIds: string[], verbose?: boolean): Promise<void>;
-export declare function deleteSpecificTestCases(issueId: string, deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
-export declare function updateTestCasesToReady(testCaseIds: string[], verbose?: boolean): Promise<void>;
-export declare function saveTestCasesAsDraft(issueId: string, createdTestCases: any[], verbose?: boolean): Promise<{
-    testCaseIds: string[];
-}>;
-export interface TestCasesAnalysisResult {
-    issueId: string;
-    productInfo: unknown;
-    issueInfo: unknown;
-    existingTestCases: any[];
-    createdTestCases: any[];
-    summary: string;
-    status: 'pending' | 'success' | 'error';
-    data?: {
-        checklist_results?: any[];
-        checklist_item_results?: any[];
-        verification_result?: any;
-        iterations?: number;
-        deleted_test_case_ids?: string[];
-        deletion_reasons?: Record<string, string>;
-    };
-}
-export declare function buildTestCasesAnalysisResult(issueId: string, context: TestCasesAnalysisContext, structuredAnalysisResult: any, currentIteration: number): TestCasesAnalysisResult;