edsger 0.50.0 → 0.52.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/feature-utils.d.ts

@@ -1,23 +0,0 @@
-import { type FeatureInfo } from '../../types/features.js';
-/**
- * Claim the next available ready_for_ai feature for processing.
- * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent
- * race conditions between multiple workers.
- *
- * @param productId - The product ID to claim a feature from
- * @param verbose - Whether to log verbose output
- * @returns The claimed feature or null if no features available
- */
-export declare function claimNextFeature(productId: string, verbose?: boolean): Promise<FeatureInfo | null>;
-/**
- * Filter features by status
- */
-export declare function filterFeaturesByStatus(features: FeatureInfo[], status: string): FeatureInfo[];
-/**
- * Sort features by updated_at (oldest first for processing)
- */
-export declare function sortFeaturesByUpdatedAt(features: FeatureInfo[]): FeatureInfo[];
-/**
- * Get features with ready_for_ai status for a product
- */
-export declare function getReadyForAIFeatures(productId: string, verbose?: boolean): Promise<FeatureInfo[]>;

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

@@ -1,80 +0,0 @@
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Claim the next available ready_for_ai feature for processing.
- * Uses database-level locking (FOR UPDATE SKIP LOCKED) to prevent
- * race conditions between multiple workers.
- *
- * @param productId - The product ID to claim a feature from
- * @param verbose - Whether to log verbose output
- * @returns The claimed feature or null if no features available
- */
-export async function claimNextFeature(productId, verbose) {
-    if (verbose) {
-        logInfo(`Attempting to claim next ready_for_ai feature for product: ${productId}`);
-    }
-    try {
-        const result = (await callMcpEndpoint('features/claim', {
-            product_id: productId,
-        }));
-        if (result.feature) {
-            if (verbose) {
-                logInfo(`✅ Claimed feature: ${result.feature.name} (${result.feature.id})`);
-            }
-            return result.feature;
-        }
-        if (verbose) {
-            logInfo('No features available for processing');
-        }
-        return null;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to claim feature: ${errorMessage}`);
-        throw error;
-    }
-}
-/**
- * Filter features by status
- */
-export function filterFeaturesByStatus(features, status) {
-    return features.filter((feature) => feature.status === status);
-}
-/**
- * Sort features by updated_at (oldest first for processing)
- */
-export function sortFeaturesByUpdatedAt(features) {
-    return [...features].sort((a, b) => {
-        const dateA = new Date(a.updated_at || 0).getTime();
-        const dateB = new Date(b.updated_at || 0).getTime();
-        return dateA - dateB;
-    });
-}
-/**
- * Get features with ready_for_ai status for a product
- */
-export async function getReadyForAIFeatures(productId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching ready_for_ai features for product: ${productId}`);
-    }
-    try {
-        const result = (await callMcpEndpoint('features/list', {
-            product_id: productId,
-            status: 'ready_for_ai',
-        }));
-        const features = result.features || [];
-        const sortedFeatures = sortFeaturesByUpdatedAt(features);
-        if (verbose) {
-            logInfo(`✅ Found ${sortedFeatures.length} ready_for_ai features (oldest first)`);
-            sortedFeatures.forEach((feature, index) => {
-                logInfo(`   ${index + 1}. ${feature.name} (updated: ${feature.updated_at})`);
-            });
-        }
-        return sortedFeatures;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to fetch ready_for_ai features: ${errorMessage}`);
-        throw error;
-    }
-}

package/dist/api/features/get-feature.d.ts

@@ -1,5 +0,0 @@
-import { type FeatureInfo } from '../../types/features.js';
-/**
- * Get feature details by ID
- */
-export declare function getFeature(featureId: string, verbose?: boolean): Promise<FeatureInfo>;

package/dist/api/features/get-feature.js

@@ -1,21 +0,0 @@
-import { logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Get feature details by ID
- */
-export async function getFeature(featureId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching feature details for: ${featureId}`);
-    }
-    const result = (await callMcpEndpoint('features/get', {
-        feature_id: featureId,
-    }));
-    if (!result.features || result.features.length === 0) {
-        throw new Error(`Feature not found: ${featureId}`);
-    }
-    const feature = result.features[0];
-    if (!feature || typeof feature !== 'object') {
-        throw new Error(`Invalid feature data returned for: ${featureId}`);
-    }
-    return feature;
-}

package/dist/api/features/index.d.ts

@@ -1,8 +0,0 @@
-export * from './batch-operations.js';
-export * from './feature-utils.js';
-export * from './get-feature.js';
-export * from './status-updater.js';
-export * from './test-cases.js';
-export * from './update-feature.js';
-export * from './user-stories.js';
-export * from '../../types/features.js';

package/dist/api/features/index.js

@@ -1,10 +0,0 @@
-// Re-export all feature-related functions
-export * from './batch-operations.js';
-export * from './feature-utils.js';
-export * from './get-feature.js';
-export * from './status-updater.js';
-export * from './test-cases.js';
-export * from './update-feature.js';
-export * from './user-stories.js';
-// Re-export types
-export * from '../../types/features.js';