edsger 0.13.3 → 0.14.0

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

@@ -1,3 +1,4 @@
+import { FeatureWorkflow } from '../../types/pipeline.js';
 /**
  * Update feature with new data
  */
@@ -6,8 +7,15 @@ export declare function updateFeature(featureId: string, updates: {
     status?: string;
     pull_request_url?: 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

@@ -29,3 +29,55 @@ export async function updateFeature(featureId, updates, verbose) {
 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/commands/workflow/feature-coordinator.js

@@ -125,6 +125,7 @@ export function getExecutionModeDescription(mode) {
         from_functional_testing: 'Execute from functional testing to end: testing',
         from_pull_request: 'Execute from pull request creation to end: pull-request → code-review → code-refine → code-refine-verification',
         from_code_review: 'Execute from code review to end: code-review → code-refine → code-refine-verification',
+        custom: 'Execute user-selected phases in order',
     };
     return descriptions[mode] || 'Unknown execution mode';
 }

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

@@ -13,13 +13,24 @@
  *
  * Uses functional programming principles for composability
  */
-import { updateFeatureStatusForPhase } from '../../api/features/index.js';
+import { updateFeatureStatusForPhase, markWorkflowPhaseCompleted, } from '../../api/features/index.js';
 import { runFeatureAnalysisPhase, runTechnicalDesignPhase, runCodeImplementationPhase, runFunctionalTestingPhase, runCodeTestingPhase, runCodeReviewPhase, } from './executors/phase-executor.js';
 import { logPipelineStart, logPhaseResult, logPipelineComplete, shouldContinuePipeline, } from '../../utils/pipeline-logger.js';
 import { handleTestFailuresWithRetry } from '../../phases/functional-testing/test-retry-handler.js';
 import { handleCodeRefineWithRetry } from '../../phases/code-refine/retry-handler.js';
 import { handlePullRequestCreation } from '../../phases/pull-request/handler.js';
 import { logInfo } from '../../utils/logger.js';
+/**
+ * Helper to log phase result and mark workflow phase as completed if successful
+ */
+const logAndMarkPhaseCompleted = async (result, verbose) => {
+    const logged = logPhaseResult(result, verbose);
+    // Mark workflow phase as completed if phase succeeded
+    if (result.status === 'success') {
+        await markWorkflowPhaseCompleted(result.featureId, result.phase, verbose);
+    }
+    return logged;
+};
 /**
  * Orchestrate phase execution based on execution mode
  * Routes to appropriate phase sequence based on mode (only_*, from_*, full_pipeline)
@@ -111,7 +122,7 @@ const runOnlyFeatureAnalysis = async (options, config) => {
     logPipelineStart(featureId, verbose);
     const results = [];
     const analysisResult = await runFeatureAnalysisPhase(options, config);
-    results.push(logPhaseResult(analysisResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
 /**
@@ -122,7 +133,7 @@ const runOnlyTechnicalDesign = async (options, config) => {
     logPipelineStart(featureId, verbose);
     const results = [];
     const designResult = await runTechnicalDesignPhase(options, config);
-    results.push(logPhaseResult(designResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(designResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
 /**
@@ -134,7 +145,7 @@ const runOnlyCodeImplementation = async (options, config) => {
     logPipelineStart(featureId, verbose);
     const results = [];
     const implementationResult = await runCodeImplementationPhase(options, config);
-    results.push(logPhaseResult(implementationResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
     // If implementation succeeded, create a pull request so the code can be reviewed
     if (implementationResult.status === 'success') {
         if (verbose) {
@@ -156,7 +167,7 @@ const runOnlyCodeImplementation = async (options, config) => {
                 : 'Pull request creation failed',
             data: {},
         };
-        results.push(logPhaseResult(prResult, verbose));
+        results.push(await logAndMarkPhaseCompleted(prResult, verbose));
     }
     return finalizePipelineExecution(options, results, verbose);
 };
@@ -168,7 +179,7 @@ const runOnlyFunctionalTesting = async (options, config) => {
     logPipelineStart(featureId, verbose);
     const results = [];
     const testingResult = await runFunctionalTestingPhase(options, config);
-    results.push(logPhaseResult(testingResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(testingResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
 /**
@@ -180,19 +191,19 @@ const runFromFeatureAnalysis = async (options, config) => {
     const results = [];
     // 1. Feature Analysis
     const analysisResult = await runFeatureAnalysisPhase(options, config);
-    results.push(logPhaseResult(analysisResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(analysisResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Technical Design
     const designResult = await runTechnicalDesignPhase(options, config);
-    results.push(logPhaseResult(designResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(designResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
     // 3. Code Implementation
     const implementationResult = await runCodeImplementationPhase(options, config);
-    results.push(logPhaseResult(implementationResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
@@ -235,13 +246,13 @@ const runFromTechnicalDesign = async (options, config) => {
     const results = [];
     // 1. Technical Design
     const designResult = await runTechnicalDesignPhase(options, config);
-    results.push(logPhaseResult(designResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(designResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
     // 2. Code Implementation
     const implementationResult = await runCodeImplementationPhase(options, config);
-    results.push(logPhaseResult(implementationResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
@@ -284,7 +295,7 @@ const runFromCodeImplementation = async (options, config) => {
     const results = [];
     // 1. Code Implementation
     const implementationResult = await runCodeImplementationPhase(options, config);
-    results.push(logPhaseResult(implementationResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(implementationResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
@@ -387,7 +398,7 @@ const runOnlyPullRequest = async (options, config) => {
             : 'Pull request creation failed',
         data: {},
     };
-    results.push(logPhaseResult(prResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(prResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
 /**
@@ -416,7 +427,7 @@ const runOnlyCodeReview = async (options, config) => {
     const results = [];
     // Code Review - analyze PR and create review comments
     const reviewResult = await runCodeReviewPhase(options, config);
-    results.push(logPhaseResult(reviewResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(reviewResult, verbose));
     return finalizePipelineExecution(options, results, verbose);
 };
 /**
@@ -428,7 +439,7 @@ const runFromCodeReview = async (options, config) => {
     const results = [];
     // 1. Code Review - analyze PR and create review comments
     const reviewResult = await runCodeReviewPhase(options, config);
-    results.push(logPhaseResult(reviewResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(reviewResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return finalizePipelineExecution(options, results, verbose);
     }
@@ -484,7 +495,7 @@ const continueWithCodeReviewAndRefine = async (options, config, results, verbose
     }
     // 1. Code Review - analyze PR and create review comments
     const reviewResult = await runCodeReviewPhase(options, config);
-    results.push(logPhaseResult(reviewResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(reviewResult, verbose));
     if (!shouldContinuePipeline(results)) {
         return;
     }
@@ -503,5 +514,5 @@ const continueWithCodeReviewAndRefine = async (options, config, results, verbose
         logInfo('\n📝 Starting code testing phase...');
     }
     const testingResult = await runCodeTestingPhase(options, config);
-    results.push(logPhaseResult(testingResult, verbose));
+    results.push(await logAndMarkPhaseCompleted(testingResult, verbose));
 };

package/dist/config/feature-status.d.ts

@@ -36,3 +36,21 @@ export declare const STATUS_PROGRESSION_ORDER: readonly FeatureStatus[];
  * and skip the status update to prevent unintended regression to 'backlog'.
  */
 export declare const PHASE_STATUS_MAP: Record<string, FeatureStatus>;
+/**
+ * Human-selectable statuses
+ * These are the statuses that a human user can manually set.
+ *
+ * Excluded statuses (system-managed):
+ * - *_verification statuses: Automatically entered after completing the corresponding phase
+ * - testing_in_progress: Automatically set when functional testing begins
+ * - testing_passed: Automatically set when all tests pass
+ * - testing_failed: Automatically set when tests fail
+ *
+ * These excluded statuses should not be shown in UI dropdowns for manual status changes
+ * because they represent intermediate states that are managed by the workflow system.
+ */
+export declare const HUMAN_SELECTABLE_STATUSES: readonly FeatureStatus[];
+/**
+ * Check if a status can be manually selected by a human user
+ */
+export declare function isHumanSelectableStatus(status: FeatureStatus): boolean;

package/dist/config/feature-status.js

@@ -72,3 +72,36 @@ export const PHASE_STATUS_MAP = {
     'testing-failed': 'testing_failed',
     'ready-for-review': 'ready_for_review',
 };
+/**
+ * Human-selectable statuses
+ * These are the statuses that a human user can manually set.
+ *
+ * Excluded statuses (system-managed):
+ * - *_verification statuses: Automatically entered after completing the corresponding phase
+ * - testing_in_progress: Automatically set when functional testing begins
+ * - testing_passed: Automatically set when all tests pass
+ * - testing_failed: Automatically set when tests fail
+ *
+ * These excluded statuses should not be shown in UI dropdowns for manual status changes
+ * because they represent intermediate states that are managed by the workflow system.
+ */
+export const HUMAN_SELECTABLE_STATUSES = [
+    'backlog',
+    'ready_for_ai',
+    'feature_analysis',
+    'technical_design',
+    'code_implementation',
+    'code_refine',
+    'bug_fixing',
+    'code_review',
+    'pull_request',
+    'functional_testing',
+    'ready_for_review',
+    'shipped',
+];
+/**
+ * Check if a status can be manually selected by a human user
+ */
+export function isHumanSelectableStatus(status) {
+    return HUMAN_SELECTABLE_STATUSES.includes(status);
+}

package/dist/types/features.d.ts

@@ -1,3 +1,4 @@
+import { FeatureWorkflow } from './pipeline.js';
 export interface FeatureInfo {
     id: string;
     name: string;
@@ -6,6 +7,7 @@ export interface FeatureInfo {
     status: string;
     product_id: string;
     execution_mode?: string;
+    workflow?: FeatureWorkflow | null;
     pull_request_url?: string;
     created_at?: string;
     updated_at?: string;

package/dist/types/pipeline.d.ts

@@ -3,7 +3,14 @@
  */
 import { EdsgerConfig } from './index.js';
 import { ChecklistPhaseContext } from '../services/checklist.js';
-export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_code_implementation' | 'only_functional_testing' | 'only_pull_request' | 'only_code_refine' | 'only_code_review' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing' | 'from_code_review' | 'from_pull_request';
+export type ExecutionMode = 'full_pipeline' | 'only_feature_analysis' | 'only_technical_design' | 'only_code_implementation' | 'only_functional_testing' | 'only_pull_request' | 'only_code_refine' | 'only_code_review' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing' | 'from_code_review' | 'from_pull_request' | 'custom';
+export type WorkflowPhaseStatus = 'pending' | 'completed';
+export interface WorkflowPhase {
+    phase: string;
+    status: WorkflowPhaseStatus;
+    executed_at?: string;
+}
+export type FeatureWorkflow = WorkflowPhase[];
 export interface PipelinePhaseOptions {
     readonly featureId: string;
     readonly verbose?: boolean;

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

@@ -409,42 +409,42 @@ export async function syncFeatBranchWithMain(featureId, githubToken, owner, repo
             branch: featBranch,
         });
         const featSha = featBranchData.commit.sha;
-        // Check if feat branch is already up to date (same as main or ahead)
-        // We need to merge main into feat to keep it updated
+        // Check if feat branch is already up to date
         if (verbose) {
             logInfo(`📥 Syncing ${featBranch} with ${baseBranch}...`);
             logInfo(`   ${baseBranch} SHA: ${mainSha.substring(0, 7)}`);
             logInfo(`   ${featBranch} SHA: ${featSha.substring(0, 7)}`);
         }
-        // Use GitHub merge API to merge main into feat branch
+        // If already at the same SHA, no need to update
+        if (mainSha === featSha) {
+            if (verbose) {
+                logInfo(`ℹ️  ${featBranch} is already up to date with ${baseBranch}`);
+            }
+            return true;
+        }
+        // Use git.updateRef to fast-forward feat branch to main's SHA
+        // This avoids creating a merge commit
         try {
-            await octokit.repos.merge({
+            await octokit.git.updateRef({
                 owner,
                 repo,
-                base: featBranch,
-                head: baseBranch,
-                commit_message: `chore: sync ${featBranch} with ${baseBranch}`,
+                ref: `heads/${featBranch}`,
+                sha: mainSha,
+                force: true, // Force update since feat branch may have diverged
             });
             if (verbose) {
-                logInfo(`✅ Successfully synced ${featBranch} with ${baseBranch}`);
+                logInfo(`✅ Successfully synced ${featBranch} to ${baseBranch} (${mainSha.substring(0, 7)})`);
             }
         }
-        catch (mergeError) {
-            // 409 means nothing to merge (already up to date)
-            if (mergeError.status === 409) {
-                if (verbose) {
-                    logInfo(`ℹ️  ${featBranch} is already up to date with ${baseBranch}`);
-                }
-                return true;
-            }
-            // 404 means branch doesn't exist (shouldn't happen since we checked above)
-            if (mergeError.status === 404) {
+        catch (updateError) {
+            // 422 means the ref doesn't exist or other validation error
+            if (updateError.status === 422 || updateError.status === 404) {
                 if (verbose) {
-                    logInfo(`ℹ️  ${featBranch} branch not found, skipping sync`);
+                    logInfo(`ℹ️  Could not update ${featBranch} ref, skipping sync`);
                 }
                 return true;
             }
-            throw mergeError;
+            throw updateError;
         }
         return true;
     }

package/package.json

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