edsger 0.6.2 → 0.6.4

package/dist/commands/workflow/feature-coordinator.js

@@ -114,12 +114,14 @@ export function getExecutionModeDescription(mode) {
         only_technical_design: 'Execute only: technical design',
         only_code_implementation: 'Execute only: code implementation',
         only_functional_testing: 'Execute only: functional testing',
+        only_pull_request: 'Execute only: create pull request',
         only_code_refine: 'Execute only: code refine (address PR review feedback and verify resolution)',
         only_code_review: 'Execute only: code review (review PR code and create review comments)',
         from_feature_analysis: 'Execute from feature analysis to end: analysis → design → implementation → testing',
         from_technical_design: 'Execute from technical design to end: design → implementation → testing',
         from_code_implementation: 'Execute from code implementation to end: implementation → testing',
         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',
     };
     return descriptions[mode] || 'Unknown execution mode';

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

@@ -62,6 +62,11 @@ export const runPipelineByMode = async (options, config, executionMode) => {
             return await runOnlyFunctionalTesting(options, config);
         case 'from_functional_testing':
             return await runFromFunctionalTesting(options, config);
+        // Pull Request
+        case 'only_pull_request':
+            return await runOnlyPullRequest(options, config);
+        case 'from_pull_request':
+            return await runFromPullRequest(options, config);
         // Code Refine
         case 'only_code_refine':
             return await runOnlyCodeRefine(options, config);
@@ -311,6 +316,30 @@ const runFromFunctionalTesting = async (options, config) => {
     }
     return logPipelineComplete(results, verbose);
 };
+/**
+ * Run only pull request creation phase
+ */
+const runOnlyPullRequest = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // Note: We create a mock testing result since this mode assumes testing already passed
+    const mockTestingResult = {
+        featureId,
+        phase: 'functional-testing',
+        status: 'success',
+        message: 'Functional testing assumed to have passed',
+        data: {},
+    };
+    // Create pull request only
+    await handlePullRequestCreation({
+        featureId,
+        results,
+        testingResult: mockTestingResult,
+        verbose,
+    });
+    return logPipelineComplete(results, verbose);
+};
 /**
  * Run only code refine phase (refine code based on PR feedback)
  * Includes automatic retry loop for verification failures
@@ -362,6 +391,39 @@ const runFromCodeReview = async (options, config) => {
     });
     return logPipelineComplete(results, verbose);
 };
+/**
+ * Run from pull request creation to end (pull-request → code-review → code-refine → code-refine-verification)
+ */
+const runFromPullRequest = async (options, config) => {
+    const { featureId, verbose } = options;
+    logPipelineStart(featureId, verbose);
+    const results = [];
+    // Note: We create a mock testing result since this mode assumes testing already passed
+    // The PR creation handler needs this for context
+    const mockTestingResult = {
+        featureId,
+        phase: 'functional-testing',
+        status: 'success',
+        message: 'Functional testing assumed to have passed',
+        data: {},
+    };
+    // 1. Create pull request
+    const prCreated = await handlePullRequestCreation({
+        featureId,
+        results,
+        testingResult: mockTestingResult,
+        verbose,
+    });
+    if (!prCreated) {
+        if (verbose) {
+            logInfo('⚠️ Pull request creation failed, stopping workflow');
+        }
+        return logPipelineComplete(results, verbose);
+    }
+    // 2. Continue with code review and refine workflow
+    await continueWithCodeReviewAndRefine(options, config, results, verbose);
+    return logPipelineComplete(results, verbose);
+};
 /**
  * Continue with code review and refine after PR creation
  * This is the post-PR workflow: code-review → code-refine → code-refine-verification → code-testing

package/dist/phases/pull-request/creator.js

@@ -15,6 +15,39 @@ const getCurrentBranch = () => {
         throw new Error(`Failed to get current branch: ${error}`);
     }
 };
+/**
+ * Check if a branch exists
+ */
+const branchExists = (branch) => {
+    try {
+        execSync(`git rev-parse --verify ${branch}`, { encoding: 'utf-8' });
+        return true;
+    }
+    catch {
+        return false;
+    }
+};
+/**
+ * Switch to an existing branch
+ */
+const switchToBranch = (branch, verbose) => {
+    try {
+        // First check if branch exists
+        if (!branchExists(branch)) {
+            throw new Error(`Branch '${branch}' does not exist. The branch should have been created during code implementation phase.`);
+        }
+        if (verbose) {
+            console.log(`🔀 Switching to branch: ${branch}`);
+        }
+        execSync(`git checkout ${branch}`, { encoding: 'utf-8' });
+        if (verbose) {
+            console.log(`✅ Switched to branch: ${branch}`);
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to switch to branch ${branch}: ${error}`);
+    }
+};
 /**
  * Push current branch to remote
  */
@@ -93,16 +126,18 @@ export async function createPullRequest(config, feature) {
             auth: githubToken,
         });
         // Get current branch (should be dev/feature-id)
-        const currentBranch = getCurrentBranch();
+        let currentBranch = getCurrentBranch();
         if (verbose) {
             console.log(`🔍 Current branch: ${currentBranch}`);
         }
-        // Don't create PR if we're on the base branch
+        // If we're on the base branch, switch to dev branch (should already exist)
         if (currentBranch === baseBranch) {
-            return {
-                success: false,
-                error: `Cannot create PR: already on ${baseBranch} branch`,
-            };
+            const devBranch = `dev/${feature.id}`;
+            if (verbose) {
+                console.log(`⚠️ Currently on ${baseBranch} branch, switching to ${devBranch}`);
+            }
+            switchToBranch(devBranch, verbose);
+            currentBranch = devBranch;
         }
         // Extract feature ID from current branch (dev/feature-id)
         let targetBranch = baseBranch;

package/dist/phases/pull-request/handler.js

@@ -3,6 +3,7 @@
  */
 import { getFeature } from '../../api/features/index.js';
 import { createPullRequest, updateFeatureWithPullRequest } from './creator.js';
+import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 /**
  * Create pull request for successful feature implementation
  * Returns true if PR was successfully created, false otherwise
@@ -11,12 +12,33 @@ export async function handlePullRequestCreation({ featureId, results, testingRes
     if (verbose) {
         console.log('🔄 Creating pull request for successful feature...');
     }
+    // Log phase start
+    await logFeaturePhaseEvent({
+        featureId,
+        eventType: 'phase_started',
+        phase: 'pull_request',
+        result: 'info',
+        metadata: {
+            timestamp: new Date().toISOString(),
+        },
+    }, verbose);
     // Get feature details for PR creation
     const feature = await getFeature(featureId, verbose);
     if (!feature) {
         if (verbose) {
             console.log('⚠️ Could not fetch feature details for pull request creation');
         }
+        // Log phase failure
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_failed',
+            phase: 'pull_request',
+            result: 'error',
+            errorMessage: 'Could not fetch feature details',
+            metadata: {
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
         return false;
     }
     // Get GitHub configuration from environment
@@ -28,6 +50,22 @@ export async function handlePullRequestCreation({ featureId, results, testingRes
             console.log('⚠️ GitHub configuration not found. Skipping pull request creation.');
             console.log('   Set GITHUB_TOKEN, GITHUB_OWNER, and GITHUB_REPO environment variables.');
         }
+        // Log phase failure
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_failed',
+            phase: 'pull_request',
+            result: 'error',
+            errorMessage: 'GitHub configuration not found',
+            metadata: {
+                missing_vars: [
+                    !githubToken && 'GITHUB_TOKEN',
+                    !githubOwner && 'GITHUB_OWNER',
+                    !githubRepo && 'GITHUB_REPO',
+                ].filter(Boolean),
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
         return false;
     }
     const prResult = await createPullRequest({
@@ -49,6 +87,18 @@ export async function handlePullRequestCreation({ featureId, results, testingRes
     if (prResult.success && prResult.pullRequestUrl) {
         // Update feature with PR URL and status
         await updateFeatureWithPullRequest(featureId, prResult.pullRequestUrl, verbose);
+        // Log phase completion
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_completed',
+            phase: 'pull_request',
+            result: 'success',
+            metadata: {
+                pull_request_url: prResult.pullRequestUrl,
+                pull_request_number: prResult.pullRequestNumber,
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
         if (verbose) {
             console.log(`✅ Pull request created and feature updated to ready_for_review`);
         }
@@ -58,6 +108,17 @@ export async function handlePullRequestCreation({ featureId, results, testingRes
         if (verbose) {
             console.log(`⚠️ Pull request creation failed: ${prResult.error}`);
         }
+        // Log phase failure
+        await logFeaturePhaseEvent({
+            featureId,
+            eventType: 'phase_failed',
+            phase: 'pull_request',
+            result: 'error',
+            errorMessage: prResult.error,
+            metadata: {
+                timestamp: new Date().toISOString(),
+            },
+        }, verbose);
         return false;
     }
 }

package/dist/services/audit-logs.d.ts

@@ -5,7 +5,7 @@
 export interface LogPhaseEventParams {
     featureId: string;
     eventType: 'phase_started' | 'phase_completed' | 'phase_failed';
-    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'code_refine' | 'code_refine_verification' | 'code_review';
+    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'pull_request' | 'code_review' | 'code_refine' | 'code_refine_verification';
     result?: 'success' | 'error' | 'warning' | 'info';
     metadata?: Record<string, any>;
     errorMessage?: string;
@@ -19,7 +19,7 @@ export interface LogChecklistEventParams {
 }
 export interface LogVerificationEventParams {
     featureId: string;
-    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'code_refine' | 'code_refine_verification' | 'code_review';
+    phase: 'feature_analysis' | 'technical_design' | 'code_implementation' | 'functional_testing' | 'pull_request' | 'code_review' | 'code_refine' | 'code_refine_verification';
     iteration: number;
     result: 'success' | 'error';
     verificationData: {

package/dist/types/pipeline.d.ts

@@ -3,7 +3,7 @@
  */
 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_code_refine' | 'only_code_review' | 'from_feature_analysis' | 'from_technical_design' | 'from_code_implementation' | 'from_functional_testing' | 'from_code_review';
+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 interface PipelinePhaseOptions {
     readonly featureId: string;
     readonly verbose?: boolean;

package/package.json

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