edsger 0.19.2 → 0.19.4

package/dist/phases/branch-planning/index.js

@@ -1,10 +1,11 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { logInfo, logError } from '../../utils/logger.js';
 import { fetchBranchPlanningContext } from './context.js';
-import { createBranchPlanningSystemPrompt, createBranchPlanningPromptWithContext, formatContextForPrompt, formatExistingBranchesForPrompt, } from './prompts.js';
+import { createBranchPlanningSystemPrompt, createBranchPlanningPromptWithContext, createImprovementPrompt, formatContextForPrompt, formatExistingBranchesForPrompt, } from './prompts.js';
 import { buildSuccessResult, buildErrorResult, buildNoChangeResult, validatePlannedBranches, sortBranchesByDependency, } from './outcome.js';
 import { createFeatureBranches, clearFeatureBranches, } from '../../services/feature-branches.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
+import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 function userMessage(content) {
     return {
         type: 'user',
@@ -34,27 +35,71 @@ export const planFeatureBranches = async (options, config) => {
         }, verbose);
         // Fetch context
         const context = await fetchBranchPlanningContext(featureId, verbose);
-        // Check if there are existing branches
-        if (context.existing_branches.length > 0 && !replaceExisting) {
+        // Fetch feedbacks for branch_planning phase
+        let feedbacksContext = null;
+        let hasFeedbacks = false;
+        try {
+            feedbacksContext = await getFeedbacksForPhase({ featureId, verbose }, 'branch-planning');
+            hasFeedbacks = feedbacksContext.feedbacks.length > 0;
+            if (verbose) {
+                logInfo(`📋 Feedbacks fetched: ${feedbacksContext.feedbacks.length} feedbacks found`);
+            }
+        }
+        catch (error) {
+            if (verbose) {
+                logError(`Failed to fetch feedbacks: ${error instanceof Error ? error.message : String(error)}`);
+            }
+        }
+        // Determine operation mode
+        const hasExistingBranches = context.existing_branches.length > 0;
+        const isIncrementalUpdate = hasExistingBranches && hasFeedbacks && !replaceExisting;
+        if (verbose) {
+            logInfo('\n📋 Branch Planning Mode Decision:');
+            logInfo(`   - Has existing branches: ${hasExistingBranches} (${context.existing_branches.length} branches)`);
+            logInfo(`   - Has feedbacks: ${hasFeedbacks} (${feedbacksContext?.feedbacks.length || 0} feedbacks)`);
+            logInfo(`   - Replace existing: ${replaceExisting || false}`);
+            logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : hasExistingBranches && !replaceExisting ? '✅ No Change Needed' : '✨ New Planning'}`);
+        }
+        // Check if there are existing branches and no feedbacks - no change needed
+        if (hasExistingBranches && !hasFeedbacks && !replaceExisting) {
             if (verbose) {
-                logInfo(`Feature already has ${context.existing_branches.length} branches planned.`);
+                logInfo(`Feature already has ${context.existing_branches.length} branches planned and no feedbacks to address.`);
                 logInfo('Use replaceExisting: true to re-plan.');
             }
             return buildNoChangeResult(featureId, context.existing_branches.length);
         }
-        // Clear existing branches if requested
-        if (replaceExisting && context.existing_branches.length > 0) {
+        // Clear existing branches if requested (full re-plan)
+        if (replaceExisting && hasExistingBranches) {
             if (verbose) {
-                logInfo(`Clearing ${context.existing_branches.length} existing branches...`);
+                logInfo(`Clearing ${context.existing_branches.length} existing branches for full re-plan...`);
             }
             await clearFeatureBranches({ featureId, verbose }, true);
         }
         // Format context for prompt
         const contextInfo = formatContextForPrompt(context.feature, context.product, context.user_stories, context.test_cases);
         const existingBranchesInfo = formatExistingBranchesForPrompt(context.existing_branches);
-        // Create prompts
+        // Create prompts based on mode
         const systemPrompt = createBranchPlanningSystemPrompt(config, featureId);
-        const userPrompt = createBranchPlanningPromptWithContext(featureId, contextInfo, existingBranchesInfo);
+        let userPrompt;
+        if (isIncrementalUpdate && feedbacksContext) {
+            // Incremental update mode: adjust existing branches based on feedbacks
+            if (verbose) {
+                logInfo('\n🎯 Feedbacks that will be addressed:');
+                feedbacksContext.feedbacks.forEach((fb, idx) => {
+                    logInfo(`   ${idx + 1}. [${fb.feedback_type}] ${fb.title}`);
+                    logInfo(`      ${fb.content.substring(0, 100)}${fb.content.length > 100 ? '...' : ''}`);
+                });
+            }
+            const feedbacksInfo = await formatFeedbacksForContext(feedbacksContext);
+            const currentPlanInfo = existingBranchesInfo || 'No existing branch plan documented.';
+            userPrompt = createImprovementPrompt(feedbacksInfo, currentPlanInfo);
+            // Add context info to the improvement prompt
+            userPrompt = `${userPrompt}\n\n## Feature Context\n\n${contextInfo}`;
+        }
+        else {
+            // New planning mode
+            userPrompt = createBranchPlanningPromptWithContext(featureId, contextInfo, existingBranchesInfo);
+        }
         if (verbose) {
             logInfo('Starting Claude Code query for branch planning...');
         }
@@ -74,6 +119,14 @@ export const planFeatureBranches = async (options, config) => {
         }
         // Sort branches by dependency
         const sortedBranches = sortBranchesByDependency(result.branches);
+        // For incremental update mode, clear existing branches before creating new ones
+        // This is because the AI may have reorganized the branch structure
+        if (isIncrementalUpdate && hasExistingBranches) {
+            if (verbose) {
+                logInfo(`🔄 Clearing ${context.existing_branches.length} existing branches for incremental update...`);
+            }
+            await clearFeatureBranches({ featureId, verbose: false }, true);
+        }
         // Create branches in database with proper dependencies
         // We need to create them one by one to get IDs for base_branch_id
         const createdBranches = [];
@@ -104,7 +157,8 @@ export const planFeatureBranches = async (options, config) => {
             }
         }
         if (verbose) {
-            logInfo(`✅ Created ${sortedBranches.length} feature branches`);
+            const modeLabel = isIncrementalUpdate ? '🔄 Updated' : '✅ Created';
+            logInfo(`${modeLabel} ${sortedBranches.length} feature branches`);
             sortedBranches.forEach((b, idx) => {
                 logInfo(`   ${idx + 1}. ${b.name}`);
                 if (b.scope) {
@@ -121,11 +175,16 @@ export const planFeatureBranches = async (options, config) => {
             metadata: {
                 branches_created: sortedBranches.length,
                 branch_names: sortedBranches.map((b) => b.name),
+                mode: isIncrementalUpdate ? 'incremental_update' : 'new_planning',
+                feedbacks_addressed: feedbacksContext?.feedbacks.length || 0,
                 timestamp: new Date().toISOString(),
             },
         }, verbose);
+        const summaryPrefix = isIncrementalUpdate
+            ? `Updated branch plan based on ${feedbacksContext?.feedbacks.length || 0} feedbacks.`
+            : '';
         return buildSuccessResult(featureId, sortedBranches, result.summary ||
-            `Created ${sortedBranches.length} branches for incremental development`, result.rationale);
+            `${summaryPrefix} ${sortedBranches.length} branches for incremental development`.trim(), result.rationale);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);

package/package.json

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