edsger 0.51.0 → 0.53.0

package/dist/api/features/__tests__/feature-utils.test.js

@@ -1,370 +0,0 @@
-/**
- * Unit tests for feature utility functions
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { filterFeaturesByStatus, sortFeaturesByUpdatedAt, } from '../feature-utils.js';
-void describe('Feature Utils', () => {
-    void describe('sortFeaturesByUpdatedAt', () => {
-        void it('should sort features by updated_at in ascending order (oldest first)', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T10:00:00Z',
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            // Should be sorted oldest first: Feature 2, Feature 1, Feature 3
-            assert.strictEqual(sorted[0].id, '2', 'First should be Feature 2 (oldest)');
-            assert.strictEqual(sorted[1].id, '1', 'Second should be Feature 1');
-            assert.strictEqual(sorted[2].id, '3', 'Third should be Feature 3 (newest)');
-        });
-        void it('should handle features with missing updated_at dates', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    // Missing updated_at
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            // Feature without updated_at should be treated as epoch (1970-01-01)
-            // and sorted first
-            assert.strictEqual(sorted[0].id, '2', 'Feature without date should come first');
-            assert.strictEqual(sorted[1].id, '3', 'Feature 3 should be second (older date)');
-            assert.strictEqual(sorted[2].id, '1', 'Feature 1 should be third (newer date)');
-        });
-        void it('should handle empty array', () => {
-            const features = [];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            assert.strictEqual(sorted.length, 0, 'Empty array should remain empty');
-        });
-        void it('should handle single feature', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            assert.strictEqual(sorted.length, 1, 'Should return single feature');
-            assert.strictEqual(sorted[0].id, '1', 'Should be the same feature');
-        });
-        void it('should create a new array and not mutate the original', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-            ];
-            const originalOrder = features.map((f) => f.id);
-            const sorted = sortFeaturesByUpdatedAt(features);
-            const originalAfterSort = features.map((f) => f.id);
-            // Original array should be unchanged
-            assert.deepStrictEqual(originalAfterSort, originalOrder, 'Original array should not be mutated');
-            // Sorted array should be different
-            assert.notDeepStrictEqual(sorted.map((f) => f.id), originalOrder, 'Sorted array should have different order');
-        });
-        void it('should handle features with same updated_at timestamps consistently', () => {
-            const sameTimestamp = '2024-01-15T10:00:00Z';
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: sameTimestamp,
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: sameTimestamp,
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: sameTimestamp,
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            assert.strictEqual(sorted.length, 3, 'Should return all features');
-            // Order should be stable (same as original for equal timestamps)
-            // Note: JavaScript sort is stable in modern engines
-        });
-        void it('should handle various date formats correctly', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15', // Date only
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00.000Z', // Full ISO format
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T15:30:00Z', // ISO with time
-                },
-            ];
-            const sorted = sortFeaturesByUpdatedAt(features);
-            // Should handle different date formats and sort correctly
-            assert.strictEqual(sorted[0].id, '2', 'Feature 2 should be first (oldest)');
-            assert.strictEqual(sorted[1].id, '1', 'Feature 1 should be second');
-            assert.strictEqual(sorted[2].id, '3', 'Feature 3 should be third (newest)');
-        });
-    });
-    void describe('filterFeaturesByStatus', () => {
-        void it('should filter features by exact status match', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'feature_analysis',
-                    product_id: 'test-product',
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                },
-            ];
-            const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
-            assert.strictEqual(filtered.length, 2, 'Should return 2 ready_for_ai features');
-            assert.strictEqual(filtered[0].id, '1', 'Should include Feature 1');
-            assert.strictEqual(filtered[1].id, '3', 'Should include Feature 3');
-        });
-        void it('should return empty array when no features match status', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'feature_analysis',
-                    product_id: 'test-product',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'code_implementation',
-                    product_id: 'test-product',
-                },
-            ];
-            const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
-            assert.strictEqual(filtered.length, 0, 'Should return empty array');
-        });
-        void it('should handle empty input array', () => {
-            const features = [];
-            const filtered = filterFeaturesByStatus(features, 'ready_for_ai');
-            assert.strictEqual(filtered.length, 0, 'Should return empty array');
-        });
-    });
-    void describe('Integration Tests - Workflow Processing Order', () => {
-        void it('should process features in oldest-first order for workflow execution', () => {
-            // This test simulates the expected behavior for workflow processing
-            const simulatedWorkflowFeatures = [
-                {
-                    id: 'urgent-feature',
-                    name: 'Urgent Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-01T08:00:00Z', // Very old - should be processed first
-                },
-                {
-                    id: 'recent-feature',
-                    name: 'Recent Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T10:00:00Z', // Recent - should be processed last
-                },
-                {
-                    id: 'medium-feature',
-                    name: 'Medium Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T12:00:00Z', // Medium age - should be processed second
-                },
-            ];
-            const processingOrder = sortFeaturesByUpdatedAt(simulatedWorkflowFeatures);
-            // Verify processing order matches expected workflow behavior
-            assert.strictEqual(processingOrder[0].id, 'urgent-feature', 'Oldest feature should be processed first in workflow');
-            assert.strictEqual(processingOrder[1].id, 'medium-feature', 'Medium-age feature should be processed second in workflow');
-            assert.strictEqual(processingOrder[2].id, 'recent-feature', 'Newest feature should be processed last in workflow');
-            // Verify timestamps are in correct ascending order
-            const timestamps = processingOrder.map((f) => new Date(f.updated_at || 0).getTime());
-            for (let i = 1; i < timestamps.length; i++) {
-                assert.ok(timestamps[i] >= timestamps[i - 1], `Feature ${i} should have timestamp >= feature ${i - 1}`);
-            }
-        });
-        void it('should maintain consistent ordering across multiple calls', () => {
-            const features = [
-                {
-                    id: '1',
-                    name: 'Feature 1',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T10:00:00Z',
-                },
-                {
-                    id: '2',
-                    name: 'Feature 2',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-10T10:00:00Z',
-                },
-                {
-                    id: '3',
-                    name: 'Feature 3',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-20T10:00:00Z',
-                },
-            ];
-            // Sort multiple times to ensure consistency
-            const sorted1 = sortFeaturesByUpdatedAt(features);
-            const sorted2 = sortFeaturesByUpdatedAt(features);
-            const sorted3 = sortFeaturesByUpdatedAt(features);
-            // All should produce the same order
-            assert.deepStrictEqual(sorted1.map((f) => f.id), sorted2.map((f) => f.id), 'First and second sort should produce same order');
-            assert.deepStrictEqual(sorted2.map((f) => f.id), sorted3.map((f) => f.id), 'Second and third sort should produce same order');
-        });
-        void it('should verify oldest-first ordering is critical for fair workflow processing', () => {
-            // Test that demonstrates why oldest-first ordering is important
-            const featuresWithVariousAges = [
-                {
-                    id: 'very-old-bug',
-                    name: 'Critical Bug Fix',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-01T00:00:00Z', // Very old, should be highest priority
-                },
-                {
-                    id: 'new-enhancement',
-                    name: 'Nice to Have Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-25T00:00:00Z', // Recent, should be lowest priority
-                },
-                {
-                    id: 'medium-priority',
-                    name: 'Important Feature',
-                    status: 'ready_for_ai',
-                    product_id: 'test-product',
-                    updated_at: '2024-01-15T00:00:00Z', // Medium age, should be middle priority
-                },
-            ];
-            const orderedFeatures = sortFeaturesByUpdatedAt(featuresWithVariousAges);
-            // The oldest feature (potentially a bug that's been waiting) should be processed first
-            assert.strictEqual(orderedFeatures[0].id, 'very-old-bug');
-            assert.strictEqual(orderedFeatures[1].id, 'medium-priority');
-            assert.strictEqual(orderedFeatures[2].id, 'new-enhancement');
-            // Verify the business logic: older items get processed before newer ones
-            // This ensures fairness and prevents newer features from always jumping ahead
-            const ages = orderedFeatures.map((f) => new Date(f.updated_at ?? '').getTime());
-            assert.ok(ages[0] <= ages[1] && ages[1] <= ages[2], 'Features should be processed in age order (oldest first)');
-        });
-    });
-    void describe('getReadyForAIFeatures integration behavior', () => {
-        void it('should use sortFeaturesByUpdatedAt to ensure oldest-first processing', () => {
-            // This test verifies the integration between getReadyForAIFeatures and sortFeaturesByUpdatedAt
-            // We can test this indirectly by testing the sorting function that getReadyForAIFeatures uses
-            const mockApiResponse = [
-                {
-                    id: 'feat-1',
-                    name: 'Feature Added Last Week',
-                    status: 'ready_for_ai',
-                    product_id: 'product-123',
-                    updated_at: '2024-01-18T10:00:00Z',
-                },
-                {
-                    id: 'feat-2',
-                    name: 'Feature Added Yesterday',
-                    status: 'ready_for_ai',
-                    product_id: 'product-123',
-                    updated_at: '2024-01-24T15:30:00Z',
-                },
-                {
-                    id: 'feat-3',
-                    name: 'Feature Added Last Month',
-                    status: 'ready_for_ai',
-                    product_id: 'product-123',
-                    updated_at: '2024-01-05T08:00:00Z',
-                },
-            ];
-            // This simulates what getReadyForAIFeatures does internally
-            const sortedForWorkflow = sortFeaturesByUpdatedAt(mockApiResponse);
-            // Verify oldest-first ordering that getReadyForAIFeatures should provide
-            assert.strictEqual(sortedForWorkflow[0].id, 'feat-3', 'Oldest feature should be first');
-            assert.strictEqual(sortedForWorkflow[1].id, 'feat-1', 'Second oldest should be second');
-            assert.strictEqual(sortedForWorkflow[2].id, 'feat-2', 'Newest feature should be last');
-            // Verify the function returns the features in the correct order for workflow processing
-            const expectedOrder = ['feat-3', 'feat-1', 'feat-2'];
-            const actualOrder = sortedForWorkflow.map((f) => f.id);
-            assert.deepStrictEqual(actualOrder, expectedOrder, 'Features should be ordered for fair workflow processing');
-        });
-    });
-});

package/dist/api/features/__tests__/status-updater.test.d.ts

@@ -1,4 +0,0 @@
-/**
- * Unit tests for status progression logic
- */
-export {};

package/dist/api/features/__tests__/status-updater.test.js

@@ -1,88 +0,0 @@
-/**
- * Unit tests for status progression logic
- */
-import assert from 'node:assert';
-import { describe, it } from 'node:test';
-import { STATUS_PROGRESSION_ORDER } from '../../../config/feature-status.js';
-import { isForwardProgression } from '../status-updater.js';
-void describe('Status Progression Logic', () => {
-    void describe('isForwardProgression', () => {
-        void it('should allow forward progression', () => {
-            assert.strictEqual(isForwardProgression('backlog', 'ready_for_ai'), true, 'Should allow progression from backlog to ready_for_ai');
-            assert.strictEqual(isForwardProgression('feature_analysis', 'technical_design'), true, 'Should allow progression from feature_analysis to technical_design');
-            assert.strictEqual(isForwardProgression('code_implementation', 'shipped'), true, 'Should allow progression from code_implementation to shipped');
-        });
-        void it('should allow staying at same status', () => {
-            assert.strictEqual(isForwardProgression('backlog', 'backlog'), true, 'Should allow staying at backlog status');
-            assert.strictEqual(isForwardProgression('feature_analysis', 'feature_analysis'), true, 'Should allow staying at feature_analysis status');
-            assert.strictEqual(isForwardProgression('shipped', 'shipped'), true, 'Should allow staying at shipped status');
-        });
-        void it('should prevent backward progression', () => {
-            assert.strictEqual(isForwardProgression('ready_for_ai', 'backlog'), false, 'Should prevent regression from ready_for_ai to backlog');
-            assert.strictEqual(isForwardProgression('technical_design', 'feature_analysis'), false, 'Should prevent regression from technical_design to feature_analysis');
-            assert.strictEqual(isForwardProgression('shipped', 'code_implementation'), false, 'Should prevent regression from shipped to code_implementation');
-        });
-        void it('should handle edge cases correctly', () => {
-            // First status to last status
-            assert.strictEqual(isForwardProgression('backlog', 'shipped'), true, 'Should allow progression from first to last status');
-            // Last status to first status
-            assert.strictEqual(isForwardProgression('shipped', 'backlog'), false, 'Should prevent regression from last to first status');
-        });
-        void it('should handle testing workflow correctly', () => {
-            // Allow progression through testing states
-            assert.strictEqual(isForwardProgression('functional_testing', 'testing_in_progress'), true, 'Should allow progression to testing_in_progress');
-            assert.strictEqual(isForwardProgression('testing_in_progress', 'testing_passed'), true, 'Should allow progression to testing_passed');
-            // Allow retry after failed testing
-            assert.strictEqual(isForwardProgression('testing_in_progress', 'testing_failed'), true, 'Should allow marking tests as failed');
-            // Prevent going back to testing_in_progress from passed
-            assert.strictEqual(isForwardProgression('testing_passed', 'testing_in_progress'), false, 'Should prevent going back from testing_passed to testing_in_progress');
-        });
-    });
-    void describe('STATUS_PROGRESSION_ORDER', () => {
-        void it('should contain all expected statuses', () => {
-            const expectedStatuses = [
-                'backlog',
-                'ready_for_ai',
-                'feature_analysis',
-                'feature_analysis_verification',
-                'technical_design',
-                'technical_design_verification',
-                'branch_planning',
-                'branch_planning_verification',
-                'code_implementation',
-                'code_implementation_verification',
-                'code_refine',
-                'code_refine_verification',
-                'bug_fixing',
-                'code_review',
-                'functional_testing',
-                'testing_in_progress',
-                'testing_passed',
-                'testing_failed',
-                'ready_for_review',
-                'shipped',
-            ];
-            assert.strictEqual(STATUS_PROGRESSION_ORDER.length, expectedStatuses.length, 'Should contain the correct number of statuses');
-            for (const status of expectedStatuses) {
-                assert.ok(STATUS_PROGRESSION_ORDER.includes(status), `Should include status: ${status}`);
-            }
-        });
-        void it('should have correct ordering for key workflow phases', () => {
-            const backlogIndex = STATUS_PROGRESSION_ORDER.indexOf('backlog');
-            const readyForDevIndex = STATUS_PROGRESSION_ORDER.indexOf('ready_for_ai');
-            const featureAnalysisIndex = STATUS_PROGRESSION_ORDER.indexOf('feature_analysis');
-            const technicalDesignIndex = STATUS_PROGRESSION_ORDER.indexOf('technical_design');
-            const codeImplementationIndex = STATUS_PROGRESSION_ORDER.indexOf('code_implementation');
-            const shippedIndex = STATUS_PROGRESSION_ORDER.indexOf('shipped');
-            assert.ok(backlogIndex < readyForDevIndex, 'backlog should come before ready_for_ai');
-            assert.ok(readyForDevIndex < featureAnalysisIndex, 'ready_for_ai should come before feature_analysis');
-            assert.ok(featureAnalysisIndex < technicalDesignIndex, 'feature_analysis should come before technical_design');
-            assert.ok(technicalDesignIndex < codeImplementationIndex, 'technical_design should come before code_implementation');
-            assert.ok(codeImplementationIndex < shippedIndex, 'code_implementation should come before shipped');
-        });
-        void it('should not have duplicate statuses', () => {
-            const uniqueStatuses = new Set(STATUS_PROGRESSION_ORDER);
-            assert.strictEqual(uniqueStatuses.size, STATUS_PROGRESSION_ORDER.length, 'Should not contain duplicate statuses');
-        });
-    });
-});

package/dist/api/features/approval-checker.d.ts

@@ -1,20 +0,0 @@
-/**
- * Approval workflow integration for feature phases
- * Checks if current feature status has been approved before executing next phase
- */
-interface ApprovalCheckResult {
-    canProceed: boolean;
-    requiresApproval: boolean;
-    approvalId?: string;
-    message?: string;
-}
-/**
- * Check if current feature status has been approved before executing next phase
- * This should be called BEFORE executing a phase, not after
- *
- * @param featureId - Feature ID
- * @param verbose - Verbose logging
- * @returns Promise<ApprovalCheckResult> - Whether the phase can proceed
- */
-export declare function checkApprovalBeforePhaseExecution(featureId: string, verbose?: boolean): Promise<ApprovalCheckResult>;
-export {};

package/dist/api/features/approval-checker.js

@@ -1,152 +0,0 @@
-/**
- * Approval workflow integration for feature phases
- * Checks if current feature status has been approved before executing next phase
- */
-import { logError, logInfo, logWarning } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-import { getFeature } from './get-feature.js';
-/**
- * Check if current feature status has been approved before executing next phase
- * This should be called BEFORE executing a phase, not after
- *
- * @param featureId - Feature ID
- * @param verbose - Verbose logging
- * @returns Promise<ApprovalCheckResult> - Whether the phase can proceed
- */
-export async function checkApprovalBeforePhaseExecution(featureId, verbose = false) {
-    try {
-        // 1. Get current feature to check its status and product_id
-        const feature = await getFeature(featureId, verbose);
-        const currentStatus = feature.status;
-        const productId = feature.product_id;
-        if (verbose) {
-            logInfo(`🔍 Checking approval for current status: ${currentStatus}`);
-            logInfo(`📦 Product ID: ${productId}`);
-        }
-        // 2. Check if current status requires approval
-        const requiresApprovalResult = (await callMcpEndpoint('approvals/requires_approval', {
-            product_id: productId,
-            feature_status: currentStatus,
-        }));
-        if (verbose) {
-            logInfo(`📋 MCP requires_approval response: ${JSON.stringify(requiresApprovalResult)}`);
-        }
-        const requiresApproval = requiresApprovalResult?.requires_approval === true;
-        if (!requiresApproval) {
-            if (verbose) {
-                logInfo(`✅ Current status ${currentStatus} does not require approval. Proceeding.`);
-            }
-            return {
-                canProceed: true,
-                requiresApproval: false,
-            };
-        }
-        // 3. Status requires approval - check if already approved
-        if (verbose) {
-            logInfo(`🔒 Current status ${currentStatus} requires approval`);
-        }
-        const existingApprovals = (await callMcpEndpoint('approvals/feature_approvals', {
-            feature_id: featureId,
-        }));
-        // Check if there's an approved approval for the current status
-        const approvedApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === currentStatus &&
-            approval.approval_status === 'approved');
-        if (approvedApproval) {
-            if (verbose) {
-                logInfo(`✅ Found approved approval for ${currentStatus}. Proceeding.`);
-            }
-            return {
-                canProceed: true,
-                requiresApproval: true,
-                approvalId: approvedApproval.id,
-            };
-        }
-        // Check if there's already a pending approval for current status
-        const pendingApproval = existingApprovals?.approvals?.find((approval) => approval.requested_status === currentStatus &&
-            approval.approval_status === 'pending');
-        if (pendingApproval) {
-            if (verbose) {
-                logWarning(`⏳ Approval already pending for ${currentStatus}. Waiting for review.`);
-            }
-            return {
-                canProceed: false,
-                requiresApproval: true,
-                approvalId: pendingApproval.id,
-                message: `Waiting for approval of current status: ${currentStatus}`,
-            };
-        }
-        // No pending or approved approval - need to create one
-        if (verbose) {
-            logInfo(`🔔 No approval exists for ${currentStatus}. Creating approval request...`);
-        }
-        // Create approval request
-        const approvalId = await createApprovalRequestWithEmail(featureId, productId, currentStatus, verbose);
-        if (approvalId) {
-            return {
-                canProceed: false,
-                requiresApproval: true,
-                approvalId,
-                message: `Approval request created for status: ${currentStatus}`,
-            };
-        }
-        logError('Failed to create approval request');
-        return {
-            canProceed: false,
-            requiresApproval: true,
-            message: `Failed to create approval request for status: ${currentStatus}`,
-        };
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Error checking approval before phase execution: ${errorMessage}`);
-        // On error, block execution to be safe
-        return {
-            canProceed: false,
-            requiresApproval: true,
-            message: `Error checking approval: ${errorMessage}`,
-        };
-    }
-}
-/**
- * Create an approval request (emails are sent automatically by the MCP handler)
- * This is for the CURRENT status, not the next status
- */
-async function createApprovalRequestWithEmail(featureId, productId, currentStatus, verbose = false) {
-    try {
-        if (verbose) {
-            logInfo(`Creating approval request for current status: ${currentStatus}`);
-        }
-        // Create approval request via MCP endpoint
-        // Note: We're requesting approval for the current status
-        // The approval is asking: "Can we proceed from this status?"
-        // Email notifications are sent automatically by the MCP handler
-        const result = (await callMcpEndpoint('approvals/create', {
-            feature_id: featureId,
-            requested_status: currentStatus,
-            previous_status: null, // We're approving current status, not transitioning
-        }));
-        const approvalId = result?.approval_id;
-        if (!approvalId) {
-            logError('Failed to create approval request: No approval_id returned');
-            return null;
-        }
-        if (verbose) {
-            logInfo(`✅ Approval request created: ${approvalId}`);
-            // Log email results if available
-            if (result?.emails_sent) {
-                const sentCount = result.emails_sent.filter((e) => e.status === 'sent').length;
-                const failedCount = result.emails_sent.filter((e) => e.status !== 'sent').length;
-                logInfo(`📧 Sent approval emails to ${sentCount} assignee(s)`);
-                if (failedCount > 0) {
-                    logWarning(`⚠️ Failed to send ${failedCount} email(s)`);
-                }
-            }
-        }
-        return approvalId;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create approval request: ${errorMessage}`);
-        return null;
-    }
-}

package/dist/api/features/batch-operations.d.ts

@@ -1,17 +0,0 @@
-import { type TestCaseStatus, type UserStoryStatus } from '../../types/index.js';
-/**
- * Batch update user story statuses
- */
-export declare function batchUpdateUserStoryStatus(userStoryIds: string[], status: UserStoryStatus, verbose?: boolean): Promise<boolean>;
-/**
- * Batch update test case statuses
- */
-export declare function batchUpdateTestCaseStatus(testCaseIds: string[], status: TestCaseStatus, verbose?: boolean): Promise<boolean>;
-/**
- * Batch delete user stories
- */
-export declare function batchDeleteUserStories(userStoryIds: string[], verbose?: boolean): Promise<boolean>;
-/**
- * Batch delete test cases
- */
-export declare function batchDeleteTestCases(testCaseIds: string[], verbose?: boolean): Promise<boolean>;