edsger 0.51.0 → 0.53.0

package/dist/api/features/batch-operations.js

@@ -1,100 +0,0 @@
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Batch update user story statuses
- */
-export async function batchUpdateUserStoryStatus(userStoryIds, status, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch updating ${userStoryIds.length} user stories to status: ${status}`);
-        }
-        for (const id of userStoryIds) {
-            await callMcpEndpoint('user_stories/update_status', {
-                user_story_id: id,
-                status,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch user story status update completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch update user story statuses: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Batch update test case statuses
- */
-export async function batchUpdateTestCaseStatus(testCaseIds, status, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch updating ${testCaseIds.length} test cases to status: ${status}`);
-        }
-        for (const id of testCaseIds) {
-            await callMcpEndpoint('test_cases/update_status', {
-                test_case_id: id,
-                status,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch test case status update completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch update test case statuses: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Batch delete user stories
- */
-export async function batchDeleteUserStories(userStoryIds, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch deleting ${userStoryIds.length} user stories`);
-        }
-        for (const id of userStoryIds) {
-            await callMcpEndpoint('user_stories/delete', {
-                user_story_id: id,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch user story deletion completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch delete user stories: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Batch delete test cases
- */
-export async function batchDeleteTestCases(testCaseIds, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Batch deleting ${testCaseIds.length} test cases`);
-        }
-        for (const id of testCaseIds) {
-            await callMcpEndpoint('test_cases/delete', {
-                test_case_id: id,
-            });
-        }
-        if (verbose) {
-            logInfo('✅ Batch test case deletion completed');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to batch delete test cases: ${errorMessage}`);
-        return false;
-    }
-}

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';

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

@@ -1,41 +0,0 @@
-/**
- * Feature status updater for workflow pipeline
- * Updates feature status at each phase of the development workflow
- */
-import type { FeatureStatus } from '../../types/index.js';
-interface StatusUpdateOptions {
-    readonly featureId: string;
-    readonly status: FeatureStatus;
-    readonly verbose?: boolean;
-}
-/**
- * Check if moving from currentStatus to newStatus is forward progression
- *
- * Special cases for archived status:
- * - Any status → archived: Always allowed (archiving from any state)
- * - Archived → backlog: Always allowed (unarchiving restores to backlog)
- */
-export declare function isForwardProgression(currentStatus: FeatureStatus, newStatus: FeatureStatus): boolean;
-/**
- * Update feature status via MCP endpoint
- */
-export declare function updateFeatureStatus({ featureId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
-/**
- * Map pipeline phase to feature status
- */
-export declare const getStatusForPhase: (phase: string) => FeatureStatus | null;
-/**
- * Update feature status based on pipeline phase
- *
- * @param featureId - The feature ID to update
- * @param phase - The pipeline phase name
- * @param verbose - Whether to log verbose output
- * @returns Promise<boolean> - true if update succeeded, false if skipped or failed
- *
- * BREAKING CHANGE: This function was changed from synchronous to asynchronous in PR #87
- * to support regression prevention checks. All callers must now use await/then to handle
- * the Promise return type. The function now validates against status regression and will
- * skip updates that would move a feature backward in the development workflow.
- */
-export declare const updateFeatureStatusForPhase: (featureId: string, phase: string, verbose?: boolean) => Promise<boolean>;
-export {};

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

@@ -1,122 +0,0 @@
-/**
- * Feature status updater for workflow pipeline
- * Updates feature status at each phase of the development workflow
- */
-import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../../config/feature-status.js';
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-import { getFeature } from './get-feature.js';
-/**
- * Check if moving from currentStatus to newStatus is forward progression
- *
- * Special cases for archived status:
- * - Any status → archived: Always allowed (archiving from any state)
- * - Archived → backlog: Always allowed (unarchiving restores to backlog)
- */
-export function isForwardProgression(currentStatus, newStatus) {
-    // Any status can transition to archived
-    if (newStatus === 'archived') {
-        return true;
-    }
-    // Archived can only transition back to backlog (unarchive)
-    if (currentStatus === 'archived') {
-        return newStatus === 'backlog';
-    }
-    const currentIndex = STATUS_PROGRESSION_ORDER.indexOf(currentStatus);
-    const newIndex = STATUS_PROGRESSION_ORDER.indexOf(newStatus);
-    // Allow moving forward or staying at same level (for retries, etc.)
-    return newIndex >= currentIndex;
-}
-/**
- * Update feature status via MCP endpoint
- */
-export async function updateFeatureStatus({ featureId, status, verbose = false, }) {
-    try {
-        if (verbose) {
-            logInfo(`Updating feature ${featureId} status to: ${status}`);
-        }
-        // Get current feature status to check for regression
-        let feature;
-        let currentStatus;
-        try {
-            feature = await getFeature(featureId, verbose);
-            currentStatus = feature.status;
-        }
-        catch (error) {
-            const errorMessage = error instanceof Error ? error.message : String(error);
-            logError(`Failed to get current feature status for ${featureId}: ${errorMessage}`);
-            // If we can't get the current status, we can't safely check for regression
-            // so we'll skip the update to prevent potential regression
-            if (verbose) {
-                logInfo('⚠️ Skipping status update due to inability to verify current status');
-            }
-            return false;
-        }
-        // Check if this would be a regression
-        if (!isForwardProgression(currentStatus, status)) {
-            const message = `⚠️ Skipping status regression: ${currentStatus} → ${status}. Only forward progression allowed.`;
-            if (verbose) {
-                logInfo(message);
-            }
-            return false;
-        }
-        // Only proceed if status actually changed
-        if (currentStatus === status) {
-            if (verbose) {
-                logInfo(`Status already at ${status}, no update needed`);
-            }
-            return true;
-        }
-        // Update status
-        await callMcpEndpoint('features/update', {
-            feature_id: featureId,
-            status,
-        });
-        if (verbose) {
-            logInfo(`✅ Feature status updated successfully from ${currentStatus} to: ${status}`);
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        if (verbose) {
-            logError(`Failed to update feature status: ${errorMessage}`);
-        }
-        return false;
-    }
-}
-/**
- * Map pipeline phase to feature status
- */
-export const getStatusForPhase = (phase) => {
-    // Use the externalized phase-to-status mapping
-    return PHASE_STATUS_MAP[phase] ?? null;
-};
-/**
- * Update feature status based on pipeline phase
- *
- * @param featureId - The feature ID to update
- * @param phase - The pipeline phase name
- * @param verbose - Whether to log verbose output
- * @returns Promise<boolean> - true if update succeeded, false if skipped or failed
- *
- * BREAKING CHANGE: This function was changed from synchronous to asynchronous in PR #87
- * to support regression prevention checks. All callers must now use await/then to handle
- * the Promise return type. The function now validates against status regression and will
- * skip updates that would move a feature backward in the development workflow.
- */
-export const updateFeatureStatusForPhase = async (featureId, phase, verbose) => {
-    const status = getStatusForPhase(phase);
-    if (!status) {
-        const message = `⚠️ Unknown phase '${phase}' - skipping status update to prevent regression`;
-        if (verbose) {
-            logInfo(message);
-        }
-        return false;
-    }
-    return updateFeatureStatus({
-        featureId,
-        status,
-        verbose,
-    });
-};

package/dist/api/features/test-cases.d.ts

@@ -1,29 +0,0 @@
-import { type TestCase, type TestCaseStatus } from '../../types/features.js';
-/**
- * Get test cases for a feature
- */
-export declare function getTestCases(featureId: string, verbose?: boolean): Promise<TestCase[]>;
-/**
- * Create a new test case for a feature
- */
-export declare function createTestCase(featureId: string, testCase: {
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Create multiple test cases for a feature
- */
-export declare function createTestCases(mcpServerUrl: string, mcpToken: string, featureId: string, testCases: {
-    name: string;
-    description: string;
-    is_critical?: boolean;
-}[], verbose?: boolean): Promise<boolean>;
-/**
- * Delete a test case
- */
-export declare function deleteTestCase(testCaseId: string, verbose?: boolean): Promise<boolean>;
-/**
- * Update test case status
- */
-export declare function updateTestCaseStatus(testCaseId: string, status: TestCaseStatus, verbose?: boolean): Promise<boolean>;

package/dist/api/features/test-cases.js

@@ -1,110 +0,0 @@
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Get test cases for a feature
- */
-export async function getTestCases(featureId, verbose) {
-    if (verbose) {
-        logInfo(`Fetching test cases for feature: ${featureId}`);
-    }
-    const result = (await callMcpEndpoint('test_cases/list', {
-        feature_id: featureId,
-    }));
-    return (result.test_cases || []);
-}
-/**
- * Create a new test case for a feature
- */
-export async function createTestCase(featureId, testCase, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Creating test case for feature: ${featureId}`);
-        }
-        await callMcpEndpoint('test_cases/create', {
-            feature_id: featureId,
-            test_cases: [
-                {
-                    name: testCase.name,
-                    description: testCase.description,
-                    is_critical: testCase.is_critical || false,
-                },
-            ],
-        });
-        if (verbose) {
-            logInfo('✅ Test case created successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create test case: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Create multiple test cases for a feature
- */
-export async function createTestCases(mcpServerUrl, mcpToken, featureId, testCases, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Creating ${testCases.length} test cases for feature: ${featureId}`);
-        }
-        for (const testCase of testCases) {
-            await createTestCase(featureId, testCase, false);
-        }
-        if (verbose) {
-            logInfo('✅ All test cases created successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to create test cases: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Delete a test case
- */
-export async function deleteTestCase(testCaseId, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Deleting test case: ${testCaseId}`);
-        }
-        await callMcpEndpoint('test_cases/delete', {
-            test_case_id: testCaseId,
-        });
-        if (verbose) {
-            logInfo('✅ Test case deleted successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to delete test case: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Update test case status
- */
-export async function updateTestCaseStatus(testCaseId, status, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Updating test case ${testCaseId} status to: ${status}`);
-        }
-        await callMcpEndpoint('test_cases/update_status', {
-            test_case_id: testCaseId,
-            status,
-        });
-        if (verbose) {
-            logInfo('✅ Test case status updated successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to update test case status: ${errorMessage}`);
-        return false;
-    }
-}

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

@@ -1,20 +0,0 @@
-import { type FeatureWorkflow } from '../../types/pipeline.js';
-/**
- * Update feature with new data
- */
-export declare function updateFeature(featureId: string, updates: {
-    technical_design?: string;
-    status?: string;
-    execution_mode?: string;
-    workflow?: FeatureWorkflow;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Update technical design for a feature
- */
-export declare function updateTechnicalDesign(featureId: string, technicalDesign: string, verbose?: boolean): Promise<boolean>;
-/**
- * Mark a workflow phase as completed
- * Fetches current workflow, updates the phase status, and saves back
- * Accepts phase names in either format (hyphens or underscores)
- */
-export declare function markWorkflowPhaseCompleted(featureId: string, phaseName: string, verbose?: boolean): Promise<boolean>;

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

@@ -1,83 +0,0 @@
-import { logError, logInfo } from '../../utils/logger.js';
-import { callMcpEndpoint } from '../mcp-client.js';
-/**
- * Update feature with new data
- */
-export async function updateFeature(featureId, updates, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`Updating feature: ${featureId}`);
-        }
-        await callMcpEndpoint('features/update', {
-            feature_id: featureId,
-            ...updates,
-        });
-        if (verbose) {
-            logInfo('✅ Feature updated successfully');
-        }
-        return true;
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to update feature: ${errorMessage}`);
-        return false;
-    }
-}
-/**
- * Update technical design for a feature
- */
-export async function updateTechnicalDesign(featureId, technicalDesign, verbose) {
-    return updateFeature(featureId, { technical_design: technicalDesign }, verbose);
-}
-/**
- * Normalize phase name from pipeline format (hyphens) to workflow format (underscores)
- * e.g., 'feature-analysis' -> 'feature_analysis'
- */
-function normalizePhaseNameForWorkflow(phaseName) {
-    return phaseName.replace(/-/g, '_');
-}
-/**
- * Mark a workflow phase as completed
- * Fetches current workflow, updates the phase status, and saves back
- * Accepts phase names in either format (hyphens or underscores)
- */
-export async function markWorkflowPhaseCompleted(featureId, phaseName, verbose) {
-    try {
-        // Normalize phase name to workflow format (underscores)
-        const normalizedPhaseName = normalizePhaseNameForWorkflow(phaseName);
-        if (verbose) {
-            logInfo(`Marking workflow phase '${normalizedPhaseName}' as completed for feature: ${featureId}`);
-        }
-        // Fetch current feature to get workflow
-        const response = (await callMcpEndpoint('features/get', {
-            feature_id: featureId,
-        }));
-        const feature = response?.features?.[0];
-        if (!feature) {
-            logError(`Feature not found: ${featureId}`);
-            return false;
-        }
-        const workflow = feature.workflow || [];
-        if (workflow.length === 0) {
-            if (verbose) {
-                logInfo(`No workflow defined for feature, skipping phase completion`);
-            }
-            return true;
-        }
-        // Update the phase status
-        const updatedWorkflow = workflow.map((p) => p.phase === normalizedPhaseName
-            ? {
-                ...p,
-                status: 'completed',
-                executed_at: new Date().toISOString(),
-            }
-            : p);
-        // Save updated workflow
-        return await updateFeature(featureId, { workflow: updatedWorkflow }, verbose);
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        logError(`Failed to mark workflow phase completed: ${errorMessage}`);
-        return false;
-    }
-}

package/dist/api/features/user-stories.d.ts

@@ -1,21 +0,0 @@
-import { type UserStory, type UserStoryStatus } from '../../types/features.js';
-/**
- * Get user stories for a feature
- */
-export declare function getUserStories(featureId: string, verbose?: boolean): Promise<UserStory[]>;
-/**
- * Create a new user story for a feature
- */
-export declare function createUserStory(featureId: string, userStory: {
-    title: string;
-    description: string;
-    status?: string;
-}, verbose?: boolean): Promise<boolean>;
-/**
- * Delete a user story
- */
-export declare function deleteUserStory(userStoryId: string, verbose?: boolean): Promise<boolean>;
-/**
- * Update user story status
- */
-export declare function updateUserStoryStatus(userStoryId: string, status: UserStoryStatus, verbose?: boolean): Promise<boolean>;