edsger 0.49.0 → 0.51.0

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

@@ -0,0 +1,152 @@
+/**
+ * Approval workflow integration for issue phases
+ * Checks if current issue status has been approved before executing next phase
+ */
+import { logError, logInfo, logWarning } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+import { getIssue } from './get-issue.js';
+/**
+ * Check if current issue status has been approved before executing next phase
+ * This should be called BEFORE executing a phase, not after
+ *
+ * @param issueId - Issue ID
+ * @param verbose - Verbose logging
+ * @returns Promise<ApprovalCheckResult> - Whether the phase can proceed
+ */
+export async function checkApprovalBeforePhaseExecution(issueId, verbose = false) {
+    try {
+        // 1. Get current issue to check its status and product_id
+        const issue = await getIssue(issueId, verbose);
+        const currentStatus = issue.status;
+        const productId = issue.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,
+            issue_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/issue_approvals', {
+            issue_id: issueId,
+        }));
+        // 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(issueId, 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(issueId, 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', {
+            issue_id: issueId,
+            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/issues/batch-operations.d.ts

@@ -0,0 +1,17 @@
+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>;

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

@@ -0,0 +1,100 @@
+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/issues/get-issue.d.ts

@@ -0,0 +1,5 @@
+import { type IssueInfo } from '../../types/issues.js';
+/**
+ * Get issue details by ID
+ */
+export declare function getIssue(issueId: string, verbose?: boolean): Promise<IssueInfo>;

package/dist/api/issues/get-issue.js

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

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

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

package/dist/api/issues/index.js

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

package/dist/api/issues/issue-utils.d.ts

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

package/dist/api/issues/issue-utils.js

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

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

@@ -0,0 +1,41 @@
+/**
+ * Issue status updater for workflow pipeline
+ * Updates issue status at each phase of the development workflow
+ */
+import type { IssueStatus } from '../../types/index.js';
+interface StatusUpdateOptions {
+    readonly issueId: string;
+    readonly status: IssueStatus;
+    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: IssueStatus, newStatus: IssueStatus): boolean;
+/**
+ * Update issue status via MCP endpoint
+ */
+export declare function updateIssueStatus({ issueId, status, verbose, }: StatusUpdateOptions): Promise<boolean>;
+/**
+ * Map pipeline phase to issue status
+ */
+export declare const getStatusForPhase: (phase: string) => IssueStatus | null;
+/**
+ * Update issue status based on pipeline phase
+ *
+ * @param issueId - The issue 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 an issue backward in the development workflow.
+ */
+export declare const updateIssueStatusForPhase: (issueId: string, phase: string, verbose?: boolean) => Promise<boolean>;
+export {};

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

@@ -0,0 +1,122 @@
+/**
+ * Issue status updater for workflow pipeline
+ * Updates issue status at each phase of the development workflow
+ */
+import { PHASE_STATUS_MAP, STATUS_PROGRESSION_ORDER, } from '../../config/issue-status.js';
+import { logError, logInfo } from '../../utils/logger.js';
+import { callMcpEndpoint } from '../mcp-client.js';
+import { getIssue } from './get-issue.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 issue status via MCP endpoint
+ */
+export async function updateIssueStatus({ issueId, status, verbose = false, }) {
+    try {
+        if (verbose) {
+            logInfo(`Updating issue ${issueId} status to: ${status}`);
+        }
+        // Get current issue status to check for regression
+        let issue;
+        let currentStatus;
+        try {
+            issue = await getIssue(issueId, verbose);
+            currentStatus = issue.status;
+        }
+        catch (error) {
+            const errorMessage = error instanceof Error ? error.message : String(error);
+            logError(`Failed to get current issue status for ${issueId}: ${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('issues/update', {
+            issue_id: issueId,
+            status,
+        });
+        if (verbose) {
+            logInfo(`✅ Issue 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 issue status: ${errorMessage}`);
+        }
+        return false;
+    }
+}
+/**
+ * Map pipeline phase to issue status
+ */
+export const getStatusForPhase = (phase) => {
+    // Use the externalized phase-to-status mapping
+    return PHASE_STATUS_MAP[phase] ?? null;
+};
+/**
+ * Update issue status based on pipeline phase
+ *
+ * @param issueId - The issue 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 an issue backward in the development workflow.
+ */
+export const updateIssueStatusForPhase = async (issueId, 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 updateIssueStatus({
+        issueId,
+        status,
+        verbose,
+    });
+};

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

@@ -0,0 +1,29 @@
+import { type TestCase, type TestCaseStatus } from '../../types/issues.js';
+/**
+ * Get test cases for an issue
+ */
+export declare function getTestCases(issueId: string, verbose?: boolean): Promise<TestCase[]>;
+/**
+ * Create a new test case for an issue
+ */
+export declare function createTestCase(issueId: string, testCase: {
+    name: string;
+    description: string;
+    is_critical?: boolean;
+}, verbose?: boolean): Promise<boolean>;
+/**
+ * Create multiple test cases for an issue
+ */
+export declare function createTestCases(mcpServerUrl: string, mcpToken: string, issueId: 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>;