edsger 0.9.0 → 0.9.2

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

@@ -0,0 +1,20 @@
+/**
+ * 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

@@ -0,0 +1,163 @@
+/**
+ * Approval workflow integration for feature phases
+ * Checks if current feature status has been approved before executing next phase
+ */
+import { logInfo, logError, 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}`);
+        }
+        // 2. Check if current status requires approval
+        const requiresApprovalResult = (await callMcpEndpoint('approvals/requires_approval', {
+            product_id: productId,
+            feature_status: currentStatus,
+        }));
+        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}`,
+            };
+        }
+        else {
+            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 and send notification emails
+ * 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?"
+        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}`);
+        }
+        // Send approval emails via edge function
+        try {
+            if (verbose) {
+                logInfo('Sending approval notification emails...');
+            }
+            const emailResult = (await callMcpEndpoint('approvals/send_email', {
+                approval_id: approvalId,
+            }));
+            if (emailResult?.emails_sent) {
+                const sentCount = emailResult.emails_sent.filter((e) => e.status === 'sent').length;
+                if (verbose) {
+                    logInfo(`✅ Sent approval emails to ${sentCount} assignee(s)`);
+                }
+            }
+        }
+        catch (emailError) {
+            // Don't fail the whole process if email fails
+            const errorMessage = emailError instanceof Error ? emailError.message : String(emailError);
+            logWarning(`Failed to send approval emails: ${errorMessage}`);
+            if (verbose) {
+                logInfo('⚠️ Approval created but email notification failed');
+            }
+        }
+        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/status-updater.js

@@ -55,6 +55,7 @@ export async function updateFeatureStatus({ featureId, status, verbose = false,
             }
             return true;
         }
+        // Update status
         await callMcpEndpoint('features/update', {
             feature_id: featureId,
             status,

package/dist/commands/workflow/executors/phase-executor.js

@@ -5,6 +5,7 @@ import { updateFeatureStatusForPhase } from '../../../api/features/index.js';
 import { phaseConfigs } from '../config/phase-configs.js';
 import { getChecklistsForPhase, validateChecklistsForPhase, validateRequiredChecklistResults, processChecklistResultsFromResponse, processChecklistItemResultsFromResponse, } from '../../../services/checklist.js';
 import { logFeaturePhaseEvent } from '../../../services/audit-logs.js';
+import { checkApprovalBeforePhaseExecution } from '../../../api/features/approval-checker.js';
 // Higher-order function for phase execution
 export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     const { featureId, verbose } = options;
@@ -12,6 +13,34 @@ export const createPhaseRunner = (phaseConfig) => async (options, config) => {
     // Track phase duration for logging
     const phaseStartTime = Date.now();
     try {
+        // CHECK APPROVAL BEFORE EXECUTING PHASE
+        // This checks if the current feature status has been approved
+        if (verbose) {
+            console.log(`🔍 Checking approval before executing ${name} phase...`);
+        }
+        const approvalCheck = await checkApprovalBeforePhaseExecution(featureId, verbose);
+        if (!approvalCheck.canProceed) {
+            // Current status requires approval but hasn't been approved yet
+            // Block phase execution and return blocked result
+            if (verbose) {
+                console.log(`⛔ Phase ${name} blocked: ${approvalCheck.message || 'Waiting for approval'}`);
+            }
+            return {
+                featureId,
+                phase: name,
+                status: 'blocked',
+                message: approvalCheck.message ||
+                    'Phase execution blocked - waiting for approval of current feature status',
+                data: {
+                    approval_required: true,
+                    approval_id: approvalCheck.approvalId,
+                },
+            };
+        }
+        // Approval check passed, proceed with phase execution
+        if (verbose && approvalCheck.requiresApproval) {
+            console.log(`✅ Approval verified for current status. Proceeding with ${name} phase.`);
+        }
         // Update feature status to reflect current phase
         await updateFeatureStatusForPhase(featureId, name, verbose);
         if (verbose) {

package/dist/commands/workflow/phase-orchestrator.js

@@ -88,6 +88,21 @@ export const runCompletePipeline = (options, config) => {
     };
 };
 // Helper functions for different execution patterns
+/**
+ * Finalize pipeline execution by updating feature status to ready_for_review if all phases succeeded
+ */
+const finalizePipelineExecution = async (options, results, verbose) => {
+    // Check if all phases succeeded
+    const allSucceeded = results.every((result) => result.status === 'success');
+    if (allSucceeded && results.length > 0) {
+        // Update status to ready_for_review
+        await updateFeatureStatusForPhase(options.featureId, 'ready-for-review', verbose);
+        if (verbose) {
+            logInfo('✅ Pipeline execution completed - feature is ready for review');
+        }
+    }
+    return logPipelineComplete(results, verbose);
+};
 /**
  * Run only feature analysis phase
  */
@@ -97,7 +112,7 @@ const runOnlyFeatureAnalysis = async (options, config) => {
     const results = [];
     const analysisResult = await runFeatureAnalysisPhase(options, config);
     results.push(logPhaseResult(analysisResult, verbose));
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run only technical design phase
@@ -108,7 +123,7 @@ const runOnlyTechnicalDesign = async (options, config) => {
     const results = [];
     const designResult = await runTechnicalDesignPhase(options, config);
     results.push(logPhaseResult(designResult, verbose));
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run only code implementation phase
@@ -119,7 +134,7 @@ const runOnlyCodeImplementation = async (options, config) => {
     const results = [];
     const implementationResult = await runCodeImplementationPhase(options, config);
     results.push(logPhaseResult(implementationResult, verbose));
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run only functional testing phase
@@ -130,7 +145,7 @@ const runOnlyFunctionalTesting = async (options, config) => {
     const results = [];
     const testingResult = await runFunctionalTestingPhase(options, config);
     results.push(logPhaseResult(testingResult, verbose));
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run from feature analysis to end
@@ -143,19 +158,19 @@ const runFromFeatureAnalysis = async (options, config) => {
     const analysisResult = await runFeatureAnalysisPhase(options, config);
     results.push(logPhaseResult(analysisResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Technical Design
     const designResult = await runTechnicalDesignPhase(options, config);
     results.push(logPhaseResult(designResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 3. Code Implementation
     const implementationResult = await runCodeImplementationPhase(options, config);
     results.push(logPhaseResult(implementationResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 4. Functional Testing with retry loop for bug fixes
     const testingResult = await handleTestFailuresWithRetry({
@@ -185,7 +200,7 @@ const runFromFeatureAnalysis = async (options, config) => {
             }
         }
     }
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run from technical design to end
@@ -198,13 +213,13 @@ const runFromTechnicalDesign = async (options, config) => {
     const designResult = await runTechnicalDesignPhase(options, config);
     results.push(logPhaseResult(designResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Code Implementation
     const implementationResult = await runCodeImplementationPhase(options, config);
     results.push(logPhaseResult(implementationResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 3. Functional Testing with retry loop for bug fixes
     const testingResult = await handleTestFailuresWithRetry({
@@ -234,7 +249,7 @@ const runFromTechnicalDesign = async (options, config) => {
             }
         }
     }
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run from code implementation to end
@@ -247,7 +262,7 @@ const runFromCodeImplementation = async (options, config) => {
     const implementationResult = await runCodeImplementationPhase(options, config);
     results.push(logPhaseResult(implementationResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Functional Testing with retry loop for bug fixes
     const testingResult = await handleTestFailuresWithRetry({
@@ -277,7 +292,7 @@ const runFromCodeImplementation = async (options, config) => {
             }
         }
     }
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run from functional testing to end
@@ -314,7 +329,7 @@ const runFromFunctionalTesting = async (options, config) => {
             }
         }
     }
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run only pull request creation phase
@@ -349,7 +364,7 @@ const runOnlyPullRequest = async (options, config) => {
         data: {},
     };
     results.push(logPhaseResult(prResult, verbose));
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run only code refine phase (refine code based on PR feedback)
@@ -366,7 +381,7 @@ const runOnlyCodeRefine = async (options, config) => {
         results,
         verbose,
     });
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run only code review phase (review PR and create review comments)
@@ -378,7 +393,7 @@ const runOnlyCodeReview = async (options, config) => {
     // Code Review - analyze PR and create review comments
     const reviewResult = await runCodeReviewPhase(options, config);
     results.push(logPhaseResult(reviewResult, verbose));
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run from code review to end (code-review → code-refine → code-refine-verification)
@@ -391,7 +406,7 @@ const runFromCodeReview = async (options, config) => {
     const reviewResult = await runCodeReviewPhase(options, config);
     results.push(logPhaseResult(reviewResult, verbose));
     if (!shouldContinuePipeline(results)) {
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Code Refine with automatic retry for verification failures
     await handleCodeRefineWithRetry({
@@ -400,7 +415,7 @@ const runFromCodeReview = async (options, config) => {
         results,
         verbose,
     });
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Run from pull request creation to end (pull-request → code-review → code-refine → code-refine-verification)
@@ -429,11 +444,11 @@ const runFromPullRequest = async (options, config) => {
         if (verbose) {
             logInfo('⚠️ Pull request creation failed, stopping workflow');
         }
-        return logPipelineComplete(results, verbose);
+        return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Continue with code review and refine workflow
     await continueWithCodeReviewAndRefine(options, config, results, verbose);
-    return logPipelineComplete(results, verbose);
+    return finalizePipelineExecution(options, results, verbose);
 };
 /**
  * Continue with code review and refine after PR creation

package/dist/config/feature-status.js

@@ -70,4 +70,5 @@ export const PHASE_STATUS_MAP = {
     'testing-in-progress': 'testing_in_progress',
     'testing-passed': 'testing_passed',
     'testing-failed': 'testing_failed',
+    'ready-for-review': 'ready_for_review',
 };

package/dist/phases/code-refine/index.js

@@ -36,7 +36,22 @@ const pushChanges = (verbose) => {
         }
     }
     catch (error) {
-        throw new Error(`Failed to push changes: ${error instanceof Error ? error.message : String(error)}`);
+        // If push fails due to non-fast-forward, use force-with-lease for safer force push
+        // force-with-lease ensures we don't overwrite others' work by checking remote state
+        if (verbose) {
+            logInfo(`⚠️  Push rejected, attempting force push with lease...`);
+        }
+        try {
+            execSync('git push --force-with-lease origin $(git branch --show-current)', {
+                encoding: 'utf-8',
+            });
+            if (verbose) {
+                logInfo(`✅ Successfully force pushed changes`);
+            }
+        }
+        catch (forceError) {
+            throw new Error(`Failed to push changes: ${forceError instanceof Error ? forceError.message : String(forceError)}`);
+        }
     }
 };
 /**

package/dist/services/feedbacks.d.ts

@@ -11,6 +11,8 @@ export interface Feedback {
     id: string;
     feature_id: string | null;
     product_id: string | null;
+    user_story_id?: string | null;
+    test_case_id?: string | null;
     phase: string;
     feedback_type: FeedbackType;
     title: string;

package/dist/services/feedbacks.js

@@ -141,6 +141,15 @@ function formatFeedbacksList(feedbacks) {
         const priorityBadge = getPriorityBadge(feedback.priority);
         // Build context metadata section
         let contextInfo = '';
+        // Item references (User Story or Test Case)
+        if (feedback.user_story_id) {
+            contextInfo += `\n**User Story ID**: ${feedback.user_story_id}`;
+            contextInfo += `\n*Note: This feedback applies to the user story referenced above in the context. Look for the ID in the "Existing User Stories" section.*`;
+        }
+        if (feedback.test_case_id) {
+            contextInfo += `\n**Test Case ID**: ${feedback.test_case_id}`;
+            contextInfo += `\n*Note: This feedback applies to the test case referenced above in the context. Look for the ID in the "Existing Test Cases" section.*`;
+        }
         // Document type
         if (feedback.document_type) {
             const docTypeDisplay = feedback.document_type

package/dist/types/pipeline.d.ts

@@ -11,7 +11,7 @@ export interface PipelinePhaseOptions {
 export interface PipelineResult {
     readonly featureId: string;
     readonly phase: string;
-    readonly status: 'success' | 'error';
+    readonly status: 'success' | 'error' | 'blocked';
     readonly message: string;
     readonly data?: unknown;
 }

package/dist/utils/git-branch-manager.js

@@ -238,8 +238,12 @@ export function returnToMainBranch(baseBranch = 'main', verbose) {
         if (verbose) {
             logError(`⚠️  Warning: Uncommitted changes detected before returning to ${baseBranch}:`);
             uncommittedFiles.forEach((file) => logError(`     ${file}`));
-            logError(`   These changes will remain on the ${currentBranch} branch.`);
+            logError(`   Resetting uncommitted changes to allow branch switch.`);
         }
+        // Reset uncommitted changes to allow clean branch switch
+        // The code should already be committed on the feature branch,
+        // so these changes are likely from post-commit operations
+        resetUncommittedChanges(verbose);
     }
     switchToBranch(baseBranch, verbose);
     if (verbose) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "edsger",
-  "version": "0.9.0",
+  "version": "0.9.2",
   "type": "module",
   "bin": {
     "edsger": "dist/index.js"