edsger 0.51.0 → 0.52.0

package/dist/phases/code-review/__tests__/diff-utils.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/phases/code-review/__tests__/diff-utils.test.js

@@ -1,101 +0,0 @@
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { buildLineToPositionMap, findClosestPosition } from '../diff-utils.js';
-void describe('buildLineToPositionMap', () => {
-    void it('maps simple additions correctly', () => {
-        const patch = `@@ -1,3 +1,4 @@
- line 1
-+new line
- line 2
- line 3`;
-        const map = buildLineToPositionMap(patch);
-        // line 1 is at position 1 (new file line 1)
-        assert.strictEqual(map.get(1), 1);
-        // new line is at position 2 (new file line 2)
-        assert.strictEqual(map.get(2), 2);
-        // line 2 is at position 3 (new file line 3)
-        assert.strictEqual(map.get(3), 3);
-        // line 3 is at position 4 (new file line 4)
-        assert.strictEqual(map.get(4), 4);
-    });
-    void it('handles deletions - deleted lines have no new file line number', () => {
-        const patch = `@@ -1,3 +1,2 @@
- line 1
--deleted line
- line 3`;
-        const map = buildLineToPositionMap(patch);
-        assert.strictEqual(map.get(1), 1);
-        // deleted line takes position 2 but no new line
-        // line 3 in old file becomes line 2 in new file, position 3
-        assert.strictEqual(map.get(2), 3);
-    });
-    void it('handles multiple hunks', () => {
-        const patch = `@@ -1,2 +1,2 @@
- line 1
-+added
-@@ -10,2 +10,2 @@
- line 10
-+added at 11`;
-        const map = buildLineToPositionMap(patch);
-        // First hunk: line 1 -> pos 1, added -> pos 2
-        assert.strictEqual(map.get(1), 1);
-        assert.strictEqual(map.get(2), 2);
-        // Second hunk: line 10 -> pos 3, added at 11 -> pos 4
-        assert.strictEqual(map.get(10), 3);
-        assert.strictEqual(map.get(11), 4);
-    });
-    void it('returns empty map for patch with only hunk header', () => {
-        const patch = '@@ -0,0 +1 @@';
-        const map = buildLineToPositionMap(patch);
-        // Hunk header only, no content lines
-        assert.strictEqual(map.size, 0);
-    });
-    void it('handles hunk starting at line other than 1', () => {
-        const patch = `@@ -50,3 +50,3 @@
- context
--old
-+new`;
-        const map = buildLineToPositionMap(patch);
-        assert.strictEqual(map.get(50), 1);
-        // -old takes position 2 (no new line)
-        // +new takes position 3, new file line 51
-        assert.strictEqual(map.get(51), 3);
-    });
-});
-void describe('findClosestPosition', () => {
-    void it('returns exact match when available', () => {
-        const map = new Map([
-            [10, 5],
-            [11, 6],
-            [12, 7],
-        ]);
-        const result = findClosestPosition(11, map);
-        assert.deepStrictEqual(result, { position: 6, actualLine: 11 });
-    });
-    void it('returns nearby line below first', () => {
-        const map = new Map([
-            [10, 5],
-            [15, 8],
-        ]);
-        // Line 12 not in map, closest below is 15 (offset 3)
-        // closest above is 10 (offset 2) - but we check below first at each offset
-        // offset 1: check 13 (no), check 11 (no)
-        // offset 2: check 14 (no), check 10 (yes!)
-        const result = findClosestPosition(12, map);
-        assert.deepStrictEqual(result, { position: 5, actualLine: 10 });
-    });
-    void it('returns null when no line within range', () => {
-        const map = new Map([
-            [1, 1],
-            [100, 50],
-        ]);
-        // Line 50 is too far from both 1 and 100
-        const result = findClosestPosition(50, map);
-        assert.strictEqual(result, null);
-    });
-    void it('returns null for empty map', () => {
-        const map = new Map();
-        const result = findClosestPosition(5, map);
-        assert.strictEqual(result, null);
-    });
-});

package/dist/phases/feature-analysis/agent.d.ts

@@ -1,13 +0,0 @@
-import { type EdsgerConfig, type WithExecutionSessionId } from '../../types/index.js';
-interface ParsedAnalysisResult {
-    analysis?: any;
-    error?: string;
-}
-/** Analysis result with typed session ID */
-export type AnalysisQueryResult = Record<string, unknown> & WithExecutionSessionId;
-/**
- * Parse JSON result from Claude Code response
- */
-export declare function parseAnalysisResult(responseText: string): ParsedAnalysisResult;
-export declare function executeAnalysisQuery(currentPrompt: string, systemPrompt: string, config: EdsgerConfig, verbose?: boolean): Promise<AnalysisQueryResult | null>;
-export {};

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

@@ -1,112 +0,0 @@
-import { query } from '@anthropic-ai/claude-agent-sdk';
-import { DEFAULT_MODEL } from '../../constants.js';
-import { logDebug, logError, logInfo } from '../../utils/logger.js';
-/**
- * Parse JSON result from Claude Code response
- */
-export function parseAnalysisResult(responseText) {
-    try {
-        // eslint-disable-next-line @typescript-eslint/no-explicit-any
-        let jsonResult = null;
-        // First try to extract JSON from markdown code block
-        const jsonBlockMatch = responseText.match(/```json\s*\n([\s\S]*?)\n\s*```/);
-        if (jsonBlockMatch) {
-            jsonResult = JSON.parse(jsonBlockMatch[1]);
-        }
-        else {
-            // Try to parse the entire response as JSON
-            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 executeAnalysisQuery(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}`);
-        }
-        // Stream the analysis process and capture assistant responses
-        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') {
-                    logDebug(`🔧 ${content.name}: ${content.input.description || 'Running...'}`, verbose);
-                }
-            }
-        }
-        if (message.type === 'result') {
-            executionSessionId = message.session_id || executionSessionId;
-            if (message.subtype === 'success') {
-                logInfo('\n📊 Feature 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_user_stories: [],
-                        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');
-                }
-                // Try to parse results from the last assistant response
-                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/feature-analysis/context.d.ts

@@ -1,24 +0,0 @@
-import { type ProductInfo } from '../../api/products.js';
-import { type ChecklistPhaseContext } from '../../services/checklist.js';
-import type { FeatureInfo, TestCase, UserStory } from '../../types/features.js';
-export interface FeatureAnalysisContext {
-    feature: FeatureInfo;
-    product: ProductInfo;
-    existing_user_stories: UserStory[];
-    existing_test_cases: TestCase[];
-}
-/**
- * Fetch all feature analysis context information via MCP endpoints
- */
-export declare function fetchFeatureAnalysisContext(featureId: string, verbose?: boolean): Promise<FeatureAnalysisContext>;
-/**
- * Format the context into a readable string for Claude Code
- */
-export declare function formatContextForPrompt(context: FeatureAnalysisContext): string;
-/**
- * Prepare all context information needed for analysis
- */
-export declare function prepareAnalysisContext(featureId: string, checklistContext: ChecklistPhaseContext | null | undefined, verbose?: boolean): Promise<{
-    featureContext: FeatureAnalysisContext;
-    analysisPrompt: string;
-}>;

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

@@ -1,138 +0,0 @@
-import { getFeature, getTestCases, getUserStories, } from '../../api/features/index.js';
-import { getProduct } from '../../api/products.js';
-import { formatChecklistsForContext, } from '../../services/checklist.js';
-import { formatFeedbacksForContext, getFeedbacksForPhase, } from '../../services/feedbacks.js';
-import { formatFeatureAnalysisContext } from '../../utils/formatters.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { createFeatureAnalysisPromptWithContext } from './prompts.js';
-/**
- * Fetch all feature analysis context information via MCP endpoints
- */
-export async function fetchFeatureAnalysisContext(featureId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Fetching complete feature analysis context for feature: ${featureId}`);
-        }
-        // Fetch all required data in parallel for better performance
-        const [feature, existingUserStories, existingTestCases] = await Promise.all([
-            getFeature(featureId, verbose),
-            getUserStories(featureId, verbose),
-            getTestCases(featureId, verbose),
-        ]);
-        const product = await getProduct(feature.product_id, verbose);
-        if (verbose) {
-            logInfo(`✅ Feature analysis context fetched successfully:`);
-            logInfo(`   Feature: ${feature.name}`);
-            logInfo(`   Product: ${product.name}`);
-            logInfo(`   Existing User Stories: ${existingUserStories.length}`);
-            logInfo(`   Existing Test Cases: ${existingTestCases.length}`);
-        }
-        return {
-            feature,
-            product,
-            existing_user_stories: existingUserStories,
-            existing_test_cases: existingTestCases,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch feature analysis context: ${errorMessage}`);
-        throw new Error(`Context fetch failed: ${errorMessage}`);
-    }
-}
-/**
- * Format the context into a readable string for Claude Code
- */
-export function formatContextForPrompt(context) {
-    const formatUserStories = (stories) => {
-        if (stories.length === 0) {
-            return 'No user stories defined.';
-        }
-        return stories
-            .map((story, index) => `${index + 1}. **${story.title}** (Status: ${story.status})
-   ID: ${story.id}${story.status === 'draft' ? ' [DELETABLE]' : ''}
-   ${story.description}`)
-            .join('\n\n');
-    };
-    const formatTestCases = (cases) => {
-        if (cases.length === 0) {
-            return 'No test cases defined.';
-        }
-        return cases
-            .map((testCase, index) => {
-            return `${index + 1}. **${testCase.name}** ${testCase.is_critical ? '[CRITICAL]' : '[OPTIONAL]'} (Status: ${testCase.status || 'unknown'})
-   ID: ${testCase.id}${testCase.status === 'draft' ? ' [DELETABLE]' : ''}
-   ${testCase.description}`;
-        })
-            .join('\n\n');
-    };
-    return `# Feature Analysis Context
-
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
-- **Description**: ${context.feature.description || 'No description provided'}
-- **Current Status**: ${context.feature.status}
-
-## Product Information
-- **Product**: ${context.product.name}
-- **Product ID**: ${context.product.id}
-- **Description**: ${context.product.description || 'No product description'}
-
-## Existing 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 and existing user stories/test cases, conduct comprehensive business analysis to identify gaps and create additional user stories and test cases that add business value.`;
-}
-/**
- * Prepare all context information needed for analysis
- */
-export async function prepareAnalysisContext(featureId, checklistContext, verbose) {
-    if (verbose) {
-        logInfo('Fetching feature analysis context via MCP endpoints...');
-    }
-    const featureContext = await fetchFeatureAnalysisContext(featureId, verbose);
-    const { content: contextInfo, downloadedImages } = await formatFeatureAnalysisContext(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 to the analysis prompt
-    try {
-        const feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'feature-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) {
-        // Don't fail if feedbacks fetch fails - just log and continue
-        if (verbose) {
-            logInfo(`Note: Could not fetch feedbacks (${error instanceof Error ? error.message : String(error)})`);
-        }
-    }
-    // Add checklist context to the analysis prompt
-    if (checklistContext && checklistContext.checklists.length > 0) {
-        const checklistInfo = formatChecklistsForContext(checklistContext);
-        finalContextInfo = `${finalContextInfo}\n\n${checklistInfo}`;
-        if (verbose) {
-            logInfo(`Added ${checklistContext.checklists.length} checklists to analysis context`);
-        }
-    }
-    const analysisPrompt = createFeatureAnalysisPromptWithContext(featureId, finalContextInfo);
-    return { featureContext, analysisPrompt };
-}

package/dist/phases/feature-analysis/index.d.ts

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

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

@@ -1,199 +0,0 @@
-import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
-import { extractChecklistItems, runPhaseCoaching, } from '../../services/coaching/index.js';
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { performVerificationCycle } from '../feature-analysis-verification/index.js';
-import { executeAnalysisQuery, parseAnalysisResult } from './agent.js';
-import { prepareAnalysisContext } from './context.js';
-import { buildAnalysisResult, deleteArtifacts, deleteSpecificArtifacts, getAllDraftArtifactIds, resetReadyArtifactsToDraft, saveAnalysisArtifactsAsDraft, updateArtifactsToReady, } from './outcome.js';
-import { createFeatureAnalysisSystemPrompt } from './prompts.js';
-// eslint-disable-next-line complexity
-export const analyseFeature = async (options, config, checklistContext) => {
-    const { featureId, verbose } = options;
-    if (verbose) {
-        logInfo(`Starting feature analysis for feature ID: ${featureId}`);
-    }
-    try {
-        // Reset pending_approval artifacts to draft so AI can manage them on re-run
-        const resetResult = await resetReadyArtifactsToDraft(featureId, verbose);
-        if (verbose &&
-            (resetResult.resetUserStories > 0 || resetResult.resetTestCases > 0)) {
-            logInfo(`✅ Reset ${resetResult.resetUserStories} user stories and ${resetResult.resetTestCases} test cases to draft for re-analysis`);
-        }
-        const context = await prepareAnalysisContext(featureId, checklistContext, verbose);
-        const systemPrompt = await createFeatureAnalysisSystemPrompt();
-        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 with pre-fetched information...');
-        }
-        // Iterative improvement loop: analysis → save draft → verification → update ready or delete → re-analysis
-        let currentDraftUserStoryIds = [];
-        let currentDraftTestCaseIds = [];
-        while (currentIteration < maxIterations) {
-            currentIteration++;
-            if (verbose && currentIteration > 1) {
-                logInfo(`\n🔄 Iteration ${currentIteration}/${maxIterations}: Improving analysis based on verification feedback...`);
-            }
-            // Log iteration start (for iterations after the first)
-            if (currentIteration > 1) {
-                await logFeaturePhaseEvent({
-                    featureId,
-                    eventType: 'phase_started',
-                    phase: 'feature_analysis',
-                    result: 'info',
-                    metadata: {
-                        iteration: currentIteration,
-                        max_iterations: maxIterations,
-                        re_analysis: true,
-                        timestamp: new Date().toISOString(),
-                    },
-                }, verbose);
-            }
-            // Execute analysis query
-            structuredAnalysisResult = await executeAnalysisQuery(currentPrompt, systemPrompt, config, verbose);
-            if (!structuredAnalysisResult) {
-                break;
-            }
-            await logFeaturePhaseEvent({
-                featureId,
-                eventType: 'phase_completed',
-                phase: 'feature_analysis',
-                result: 'success',
-                metadata: {
-                    iteration: currentIteration,
-                    max_iterations: maxIterations,
-                    analysis_step: 'completed',
-                    user_stories_count: structuredAnalysisResult.created_user_stories?.length || 0,
-                    test_cases_count: structuredAnalysisResult.created_test_cases?.length || 0,
-                    deleted_user_stories_count: structuredAnalysisResult.deleted_user_story_ids?.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_user_story_ids?.length > 0 ||
-                structuredAnalysisResult.deleted_test_case_ids?.length > 0) {
-                if (verbose) {
-                    logInfo('🗑️  Processing deletions identified by AI during analysis...');
-                }
-                await deleteSpecificArtifacts(featureId, structuredAnalysisResult.deleted_user_story_ids || [], structuredAnalysisResult.deleted_test_case_ids || [], structuredAnalysisResult.deletion_reasons || {}, verbose);
-            }
-            // Save artifacts as draft and get their IDs
-            const { userStoryIds, testCaseIds } = await saveAnalysisArtifactsAsDraft(featureId, structuredAnalysisResult.created_user_stories || [], structuredAnalysisResult.created_test_cases || [], verbose);
-            currentDraftUserStoryIds = userStoryIds;
-            currentDraftTestCaseIds = testCaseIds;
-            // Coaching loop between execute and verify
-            await runPhaseCoaching({
-                featureId,
-                phase: 'feature_analysis',
-                phaseResult: structuredAnalysisResult,
-                checklistItems: extractChecklistItems(checklistContext),
-                onImproved: async (_sessionId, responseText) => {
-                    const parsed = parseAnalysisResult(responseText);
-                    if (parsed.analysis) {
-                        // Delete old drafts and save improved ones
-                        await deleteArtifacts(currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
-                        const { userStoryIds: newUserStoryIds, testCaseIds: newTestCaseIds, } = await saveAnalysisArtifactsAsDraft(featureId, parsed.analysis.created_user_stories || [], parsed.analysis.created_test_cases || [], verbose);
-                        currentDraftUserStoryIds = newUserStoryIds;
-                        currentDraftTestCaseIds = newTestCaseIds;
-                        structuredAnalysisResult = parsed.analysis;
-                    }
-                    else {
-                        logWarning(`Coaching improvement response could not be parsed for feature-analysis. Keeping previous drafts. ${parsed.error || ''}`);
-                    }
-                },
-                verbose,
-            });
-            // Perform verification cycle
-            const verificationCycle = await performVerificationCycle({
-                structuredAnalysisResult,
-                checklistContext: checklistContext || null,
-                context: context.featureContext,
-                config,
-                currentIteration,
-                maxIterations,
-                featureId,
-                verbose,
-            });
-            ({ verificationResult } = verificationCycle);
-            // If verification passed, update ALL remaining draft artifacts to pending_approval and exit
-            if (verificationCycle.passed) {
-                if (verbose) {
-                    logInfo('✅ Verification passed! Updating all draft artifacts to pending_approval status...');
-                }
-                const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
-                await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
-                break;
-            }
-            // Verification failed
-            if (currentIteration < maxIterations && verificationCycle.nextPrompt) {
-                // We have more iterations - delete draft artifacts and retry
-                if (verbose) {
-                    logInfo('🗑️  Deleting draft artifacts for re-analysis...');
-                }
-                await deleteArtifacts(currentDraftUserStoryIds, currentDraftTestCaseIds, verbose);
-                // Continue with improvement prompt
-                currentPrompt = verificationCycle.nextPrompt;
-            }
-            else {
-                // Max iterations reached or no next prompt - exit loop
-                // Draft artifacts remain in database for manual review
-                if (verbose) {
-                    logInfo('⚠️  Max iterations reached. Draft artifacts kept for manual review.');
-                }
-                break;
-            }
-        }
-        // Handle results
-        if (!structuredAnalysisResult) {
-            throw new Error('No analysis results received');
-        }
-        // If no checklist was used, update all draft artifacts to pending_approval now
-        if (!checklistContext ||
-            checklistContext.checklists.length === 0 ||
-            !verificationResult) {
-            const allDrafts = await getAllDraftArtifactIds(featureId, verbose);
-            if (allDrafts.userStoryIds.length > 0 ||
-                allDrafts.testCaseIds.length > 0) {
-                if (verbose) {
-                    logInfo('✅ No checklist verification needed. Updating all draft artifacts to pending_approval status...');
-                }
-                await updateArtifactsToReady(allDrafts.userStoryIds, allDrafts.testCaseIds, verbose);
-            }
-        }
-        // Check if verification failed after all iterations
-        // Note: Artifacts are already saved as draft in the database
-        // If verification failed, they remain as draft for manual review
-        if (verificationResult &&
-            verificationResult.rejected_count > 0 &&
-            checklistContext &&
-            checklistContext.checklists.length > 0) {
-            logError(`❌ Final result: Checklist verification FAILED after ${currentIteration} iterations`);
-            logError(`   Draft artifacts (${currentDraftUserStoryIds.length} user stories, ${currentDraftTestCaseIds.length} test cases) kept for manual review`);
-            throw new Error(`Checklist verification failed after ${currentIteration} iterations`);
-        }
-        // Return success result
-        // Note: Artifacts have already been saved and updated to 'pending_approval' status (if verification passed)
-        // or remain as draft (if verification failed)
-        return buildAnalysisResult(featureId, context.featureContext, structuredAnalysisResult, currentIteration);
-    }
-    catch (error) {
-        logError(`Feature analysis failed: ${error instanceof Error ? error.message : String(error)}`);
-        return {
-            featureId,
-            productInfo: null,
-            featureInfo: null,
-            existingUserStories: [],
-            existingTestCases: [],
-            createdUserStories: [],
-            createdTestCases: [],
-            summary: `Analysis failed: ${error instanceof Error ? error.message : String(error)}`,
-            status: 'error',
-        };
-    }
-};

package/dist/phases/feature-analysis/outcome.d.ts

@@ -1,40 +0,0 @@
-import { type FeatureAnalysisResult } from '../../types/index.js';
-import { type FeatureAnalysisContext } from './context.js';
-/**
- * Reset ready user stories and test cases to draft for re-analysis
- */
-export declare function resetReadyArtifactsToDraft(featureId: string, verbose?: boolean): Promise<{
-    resetUserStories: number;
-    resetTestCases: number;
-}>;
-/**
- * Get all draft artifact IDs for a feature
- */
-export declare function getAllDraftArtifactIds(featureId: string, verbose?: boolean): Promise<{
-    userStoryIds: string[];
-    testCaseIds: string[];
-}>;
-/**
- * Delete artifacts after verification failure
- */
-export declare function deleteArtifacts(userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
-/**
- * Delete specific artifacts identified by AI during analysis
- * Only deletes artifacts with status 'draft'
- */
-export declare function deleteSpecificArtifacts(featureId: string, deletedUserStoryIds: string[], deletedTestCaseIds: string[], deletionReasons: Record<string, string>, verbose?: boolean): Promise<void>;
-/**
- * Update artifacts to pending_approval status after successful verification
- */
-export declare function updateArtifactsToReady(userStoryIds: string[], testCaseIds: string[], verbose?: boolean): Promise<void>;
-/**
- * Save analysis artifacts as draft and return their IDs
- */
-export declare function saveAnalysisArtifactsAsDraft(featureId: string, createdUserStories: Record<string, unknown>[], createdTestCases: Record<string, unknown>[], verbose?: boolean): Promise<{
-    userStoryIds: string[];
-    testCaseIds: string[];
-}>;
-/**
- * Build the final analysis result object
- */
-export declare function buildAnalysisResult(featureId: string, context: FeatureAnalysisContext, structuredAnalysisResult: any, currentIteration: number): FeatureAnalysisResult;