edsger 0.26.0 → 0.26.2

package/dist/phases/pr-splitting/index.js

@@ -17,6 +17,13 @@ async function* prompt(analysisPrompt) {
     yield userMessage(analysisPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
+/**
+ * PR Splitting Phase: Analyze diff and create PR split plan
+ *
+ * This phase analyzes the actual code diff between dev/{featureId} and main,
+ * then uses AI to produce a PR split plan saved to the database.
+ * Human review is expected before running the pr-execution phase.
+ */
 export const splitFeatureIntoPRs = async (options, config) => {
     const { featureId, verbose, replaceExisting } = options;
     if (verbose) {
@@ -34,8 +41,14 @@ export const splitFeatureIntoPRs = async (options, config) => {
                 timestamp: new Date().toISOString(),
             },
         }, verbose);
-        // Fetch context
-        const context = await fetchPRSplittingContext(featureId, verbose);
+        // Fetch context (includes git diff from dev/{featureId} vs main)
+        const context = await fetchPRSplittingContext(featureId, verbose, replaceExisting);
+        if (context.changedFiles.length === 0) {
+            if (verbose) {
+                logInfo('No code changes detected between dev branch and main.');
+            }
+            return buildNoChangeResult(featureId, context.existing_pull_requests.length);
+        }
         // Fetch feedbacks for pr-splitting phase
         let feedbacksContext = null;
         let hasFeedbacks = false;
@@ -54,32 +67,37 @@ export const splitFeatureIntoPRs = async (options, config) => {
         // Determine operation mode
         const hasExistingPRs = context.existing_pull_requests.length > 0;
         const isIncrementalUpdate = hasExistingPRs && hasFeedbacks && !replaceExisting;
-        if (verbose) {
-            logInfo('\n📋 PR Splitting Mode Decision:');
-            logInfo(`   - Has existing PRs: ${hasExistingPRs} (${context.existing_pull_requests.length} PRs)`);
-            logInfo(`   - Has feedbacks: ${hasFeedbacks} (${feedbacksContext?.feedbacks.length || 0} feedbacks)`);
-            logInfo(`   - Replace existing: ${replaceExisting || false}`);
-            logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : hasExistingPRs && !replaceExisting ? '✅ No Change Needed' : '✨ New Planning'}`);
-        }
-        // Check if there are existing PRs and no feedbacks - no change needed
+        // Check if existing PRs already planned and no feedback
         if (hasExistingPRs && !hasFeedbacks && !replaceExisting) {
             if (verbose) {
-                logInfo(`Feature already has ${context.existing_pull_requests.length} PRs planned and no feedbacks to address.`);
+                logInfo(`Feature already has ${context.existing_pull_requests.length} PRs planned. No feedbacks to address.`);
                 logInfo('Use replaceExisting: true to re-plan.');
             }
             return buildNoChangeResult(featureId, context.existing_pull_requests.length);
         }
-        // Clear existing PRs if requested (full re-plan)
+        if (verbose) {
+            logInfo('\n📋 PR Splitting Mode:');
+            logInfo(`   - Has existing PRs: ${hasExistingPRs}`);
+            logInfo(`   - Has feedbacks: ${hasFeedbacks}`);
+            logInfo(`   - Replace existing: ${replaceExisting || false}`);
+            logInfo(`   - Mode: ${isIncrementalUpdate ? '🔄 Incremental Update' : '✨ New Planning'}`);
+            logInfo(`   - Changed files: ${context.changedFiles.length}`);
+        }
+        // Clear existing PRs if replacing
         if (replaceExisting && hasExistingPRs) {
             if (verbose) {
                 logInfo(`Clearing ${context.existing_pull_requests.length} existing PRs for full re-plan...`);
             }
             await clearPullRequests({ featureId, verbose }, true);
         }
-        // Format context for prompt
+        // ==============================
+        // Diff Analysis with AI Agent
+        // ==============================
+        if (verbose) {
+            logInfo('\n🔍 Analyzing code diff with AI...');
+        }
         const contextInfo = formatContextForPrompt(context.feature, context.product, context.existing_branches);
         const existingPRsInfo = formatExistingPRsForPrompt(context.existing_pull_requests);
-        // Create prompts based on mode
         const systemPrompt = createPRSplittingSystemPrompt(config, featureId);
         let userPrompt;
         if (isIncrementalUpdate && feedbacksContext) {
@@ -87,7 +105,6 @@ export const splitFeatureIntoPRs = async (options, config) => {
                 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);
@@ -96,39 +113,40 @@ export const splitFeatureIntoPRs = async (options, config) => {
             userPrompt = `${userPrompt}\n\n## Feature Context\n\n${contextInfo}`;
         }
         else {
-            userPrompt = createPRSplittingPromptWithContext(featureId, contextInfo, existingPRsInfo);
-        }
-        if (verbose) {
-            logInfo('Starting Claude Code query for PR splitting...');
+            userPrompt = createPRSplittingPromptWithContext(featureId, contextInfo, existingPRsInfo, context.diffStat, context.changedFiles);
         }
-        // Execute query
-        const result = await executePRSplittingQuery(userPrompt, systemPrompt, config, verbose);
+        // Execute agent query
+        const result = await executeAgentQuery(userPrompt, systemPrompt, config, verbose);
         if (!result ||
             !result.pullRequests ||
             result.pullRequests.length === 0) {
-            const errorMsg = 'No pull requests were generated';
-            logError(errorMsg);
-            return buildErrorResult(featureId, errorMsg);
+            return buildErrorResult(featureId, 'No pull requests were generated');
         }
         // Validate PRs
         const validation = validatePlannedPRs(result.pullRequests);
         if (!validation.valid) {
-            const errorMsg = `Invalid PR plan: ${validation.errors.join(', ')}`;
-            logError(errorMsg);
-            return buildErrorResult(featureId, errorMsg);
+            return buildErrorResult(featureId, `Invalid PR plan: ${validation.errors.join(', ')}`);
         }
-        // Sort PRs by dependency
         const sortedPRs = sortPRsByDependency(result.pullRequests);
-        // For incremental update mode, clear existing PRs before creating new ones
+        if (verbose) {
+            logInfo(`\n✅ ${sortedPRs.length} PRs planned:`);
+            sortedPRs.forEach((pr) => {
+                logInfo(`   ${pr.sequence}. ${pr.name} (${pr.branch_name})`);
+                if (pr.files) {
+                    logInfo(`      Files: ${pr.files.map((f) => f.path).join(', ')}`);
+                }
+            });
+        }
+        // Clear existing PRs for incremental update before creating new ones
         if (isIncrementalUpdate && hasExistingPRs) {
             if (verbose) {
-                logInfo(`🔄 Clearing ${context.existing_pull_requests.length} existing PRs for incremental update...`);
+                logInfo(`🔄 Clearing existing PRs for incremental update...`);
             }
             await clearPullRequests({ featureId, verbose: false }, true);
         }
-        // Create PRs in database with proper dependencies
-        const prBranchNameToId = new Map();
+        // Save PR plan to database
         const prInputs = [];
+        const prBranchNameToId = new Map();
         for (const pr of sortedPRs) {
             let basePrId;
             if (pr.depends_on_branch_name) {
@@ -143,22 +161,14 @@ export const splitFeatureIntoPRs = async (options, config) => {
                 files: pr.files,
             });
         }
-        const created = await createPullRequests({ featureId, verbose: false }, prInputs);
-        // Build the branch name to ID mapping from created PRs
-        created.forEach((createdPR) => {
+        const createdPRRecords = await createPullRequests({ featureId, verbose: false }, prInputs);
+        createdPRRecords.forEach((createdPR) => {
             if (createdPR.branch_name) {
                 prBranchNameToId.set(createdPR.branch_name, createdPR.id);
             }
         });
         if (verbose) {
-            const modeLabel = isIncrementalUpdate ? '🔄 Updated' : '✅ Created';
-            logInfo(`${modeLabel} ${sortedPRs.length} pull requests`);
-            sortedPRs.forEach((pr) => {
-                logInfo(`   ${pr.sequence}. ${pr.name}`);
-                if (pr.files) {
-                    logInfo(`      Files: ${pr.files.map((f) => f.path).join(', ')}`);
-                }
-            });
+            logInfo(`\n📝 Saved ${createdPRRecords.length} PR records to database. Awaiting human review before execution.`);
         }
         // Log phase completion
         await logFeaturePhaseEvent({
@@ -167,23 +177,19 @@ export const splitFeatureIntoPRs = async (options, config) => {
             phase: 'pr_splitting',
             result: 'success',
             metadata: {
-                prs_created: sortedPRs.length,
+                prs_planned: sortedPRs.length,
                 pr_names: sortedPRs.map((pr) => pr.name),
                 mode: isIncrementalUpdate ? 'incremental_update' : 'new_planning',
                 feedbacks_addressed: feedbacksContext?.feedbacks.length || 0,
                 timestamp: new Date().toISOString(),
             },
         }, verbose);
-        const summaryPrefix = isIncrementalUpdate
-            ? `Updated PR plan based on ${feedbacksContext?.feedbacks.length || 0} feedbacks.`
-            : '';
         return buildSuccessResult(featureId, sortedPRs, result.summary ||
-            `${summaryPrefix} ${sortedPRs.length} pull requests for incremental review`.trim(), result.rationale);
+            `Split feature into ${sortedPRs.length} pull requests for review`, result.rationale);
     }
     catch (error) {
         const errorMessage = error instanceof Error ? error.message : String(error);
         logError(`PR splitting failed: ${errorMessage}`);
-        // Log phase failure
         await logFeaturePhaseEvent({
             featureId,
             eventType: 'phase_failed',
@@ -198,9 +204,9 @@ export const splitFeatureIntoPRs = async (options, config) => {
     }
 };
 /**
- * Execute the PR splitting query and parse the result
+ * Execute an agent query and parse the result
  */
-async function executePRSplittingQuery(userPrompt, systemPrompt, config, verbose) {
+async function executeAgentQuery(userPrompt, systemPrompt, config, verbose) {
     let lastAssistantResponse = '';
     let structuredResult = null;
     if (verbose) {
@@ -245,7 +251,7 @@ async function executePRSplittingQuery(userPrompt, systemPrompt, config, verbose
                     structuredResult = parseJsonResponse(responseText, verbose);
                 }
                 catch (error) {
-                    logError(`Failed to parse PR splitting result: ${error}`);
+                    logError(`Failed to parse result: ${error}`);
                 }
             }
             else {

package/dist/phases/pr-splitting/prompts.d.ts

@@ -1,12 +1,12 @@
 import { EdsgerConfig } from '../../types/index.js';
 /**
- * Create the system prompt for PR splitting
+ * Create the system prompt for PR splitting: Diff analysis and PR planning
  */
 export declare function createPRSplittingSystemPrompt(config: EdsgerConfig, featureId: string): string;
 /**
- * Create the user prompt with context for PR splitting
+ * Create the user prompt with diff context for PR splitting
  */
-export declare function createPRSplittingPromptWithContext(featureId: string, contextInfo: string, existingPRsInfo: string): string;
+export declare function createPRSplittingPromptWithContext(featureId: string, contextInfo: string, existingPRsInfo: string, diffStat: string, changedFiles: string[]): string;
 /**
  * Format the context information for the prompt
  */
@@ -38,6 +38,6 @@ export declare function formatExistingPRsForPrompt(pullRequests: Array<{
     }> | null;
 }>): string;
 /**
- * Create improvement prompt for re-planning
+ * Create improvement prompt for re-planning based on feedback
  */
 export declare function createImprovementPrompt(feedback: string, currentPlan: string): string;

package/dist/phases/pr-splitting/prompts.js

@@ -1,10 +1,18 @@
 /**
- * Create the system prompt for PR splitting
+ * Create the system prompt for PR splitting: Diff analysis and PR planning
  */
 export function createPRSplittingSystemPrompt(config, featureId) {
-    return `You are an expert software architect specialized in splitting completed feature implementations into multiple smaller, reviewable pull requests.
+    return `You are an expert software architect specialized in splitting feature implementations into multiple smaller, reviewable pull requests.
 
-Your task is to analyze the completed code on the feature branch and split it into multiple logical PRs that can be reviewed and merged incrementally.
+Your task is to analyze the actual code changes on the \`dev/${featureId}\` branch compared to \`main\` and create a plan to split them into multiple logical PRs.
+
+## Your Environment
+
+You have full access to the repository. You can:
+- Run \`git diff main...dev/${featureId}\` to see all changes
+- Run \`git diff main...dev/${featureId} -- <path>\` to see changes for specific files
+- Read any file in the repository to understand context
+- Run \`git log main...dev/${featureId} --oneline\` to see commit history
 
 ## Key Principles
 
@@ -13,16 +21,15 @@ Your task is to analyze the completed code on the feature branch and split it in
 3. **Dependency Order**: PRs should be ordered so each one builds on the previous (database first, then API, then UI)
 4. **Independent Testability**: Each PR should not break the build when merged independently in order
 5. **Clear Boundaries**: Each PR should have clear scope — one concern per PR
+6. **Module-Based Splitting**: Split by module/domain, not just by layer. If a feature touches auth, payments, and notifications — those are separate PRs even if they're all "backend"
 
 ## PR Branch Naming Convention
 
-Branch names should follow this pattern:
-- \`pr/{featureId}/1-{short-description}\`
-- \`pr/{featureId}/2-{short-description}\`
+Branch names MUST follow this pattern:
+- \`pr/${featureId}/1-{short-description}\`
+- \`pr/${featureId}/2-{short-description}\`
 - etc.
 
-Feature ID for this feature: ${featureId}
-
 ## Output Format
 
 You MUST respond with a valid JSON object in this exact format:
@@ -57,72 +64,77 @@ You MUST respond with a valid JSON object in this exact format:
 ## PR Dependencies
 
 Use \`depends_on_branch_name\` to specify which PR must be merged before this one:
-- First PR: \`"depends_on_branch_name": null\` (merges to main or feat branch)
+- First PR: \`"depends_on_branch_name": null\` (merges directly to main)
 - Subsequent PRs: \`"depends_on_branch_name": "pr/${featureId}/1-database"\` (depends on previous PR)
 
 ## File Assignment Guidelines
 
 - **Database migrations and schema**: First PR
 - **Types and interfaces**: Can go with the PR that introduces them, or in a foundational PR
-- **Backend services and API routes**: Middle PRs
-- **Frontend components**: Later PRs that depend on backend
+- **Backend services and API routes**: Middle PRs, split by module/domain
+- **Frontend components**: Later PRs that depend on backend, split by feature area
 - **Tests**: Include with the code they test
 - **Configuration files**: Group with the feature they configure
 
 ## Handling Existing PRs During Re-sync
 
 When existing PRs are provided, respect their status:
-
-- **merged / closed**: NEVER modify these PRs. Do not reassign their files or change their plan.
-  - If new changes affect files that belong to a merged/closed PR, assign those changes to an existing open PR or create a new PR.
-- **pending / branch_created / pr_opened / in_review / approved**: These can be updated — you may reassign files, update descriptions, or adjust scope.
-- When creating new PRs to accommodate changes that can't go into merged/closed PRs, use the next available sequence number.
+- **merged / closed**: NEVER modify these PRs. Do not reassign their files.
+- **pending / branch_created / pr_opened / in_review / approved**: These can be updated.
+- When creating new PRs to accommodate changes, use the next available sequence number.
 
 ## Important Notes
 
 - Every changed file must be assigned to exactly one PR
 - If the feature is small enough, a single PR is fine
 - Consider the reviewer's perspective: each PR should tell a coherent story
-- Database migrations should be in the earliest PR possible`;
+- Database migrations should be in the earliest PR possible
+- Analyze the ACTUAL diff, not just file names — understand what the changes do`;
 }
 /**
- * Create the user prompt with context for PR splitting
+ * Create the user prompt with diff context for PR splitting
  */
-export function createPRSplittingPromptWithContext(featureId, contextInfo, existingPRsInfo) {
+export function createPRSplittingPromptWithContext(featureId, contextInfo, existingPRsInfo, diffStat, changedFiles) {
     let prompt = `# PR Splitting Task
 
-Please analyze the completed feature implementation and create a plan to split it into multiple smaller PRs for review.
+Please analyze the actual code changes on the \`dev/${featureId}\` branch and create a plan to split them into multiple smaller PRs for review.
 
 ## Feature Context
 
 ${contextInfo}
 
+## Code Changes Summary
+
+### Diff Stat
+\`\`\`
+${diffStat || 'No changes detected'}
+\`\`\`
+
+### Changed Files (${changedFiles.length} files)
+${changedFiles.map((f) => `- ${f}`).join('\n') || 'No files changed'}
+
 `;
     if (existingPRsInfo) {
         prompt += `## Existing Pull Requests
 
 ${existingPRsInfo}
 
-**Note**: There are already PRs for this feature. Merged/closed PRs are frozen — do not modify them or reassign their files. If new changes touch files from a frozen PR, assign those changes to an active PR or create a new one.
+**Note**: Merged/closed PRs are frozen — do not modify them or reassign their files.
 
 `;
     }
     prompt += `## Your Task
 
-Based on the feature implementation above:
-
-1. **Analyze all changed files**: Understand what was implemented
-2. **Identify logical groupings**: Find files that change together for the same reason
+1. **Examine the actual diff**: Run \`git diff main...dev/${featureId}\` or targeted diffs for specific files to understand what changed
+2. **Identify logical groupings**: Find files that change together for the same reason, considering module boundaries
 3. **Determine dependencies**: Figure out which groups must be merged first
 4. **Create PR plan**: Define PRs with clear scope, file assignments, and acceptance criteria
 
-Please provide your PR splitting plan as a JSON response following the format specified in the system prompt.
-
 **Remember**:
 - Every changed file must be assigned to exactly one PR
 - Smaller, focused PRs are better than large ones
-- Order PRs by their dependencies
-- Database schema → backend services → frontend components is a common pattern`;
+- Split by module/domain, not just by layer
+- Order PRs by their dependencies`;
     return prompt;
 }
 /**
@@ -181,7 +193,7 @@ export function formatExistingPRsForPrompt(pullRequests) {
     return result;
 }
 /**
- * Create improvement prompt for re-planning
+ * Create improvement prompt for re-planning based on feedback
  */
 export function createImprovementPrompt(feedback, currentPlan) {
     return `# PR Splitting Improvement

package/dist/phases/technical-design/analyzer-helpers.d.ts

@@ -0,0 +1,25 @@
+import { type ChecklistVerificationResult } from '../technical-design-verification/agent.js';
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: ChecklistVerificationResult;
+    iterations?: number;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+/**
+ * Build successful design result
+ */
+export declare function buildDesignResult(featureId: string, technicalDesign: string, summary: string, iterations: number, checklistItemResults?: any[]): TechnicalDesignResult;
+/**
+ * Build verification failure result
+ */
+export declare function buildVerificationFailureResult(featureId: string, technicalDesign: string, verificationResult: ChecklistVerificationResult, iterations: number): TechnicalDesignResult;
+/**
+ * Build error result when no design was generated
+ */
+export declare function buildNoResultsError(featureId: string): TechnicalDesignResult;

package/dist/phases/technical-design/analyzer-helpers.js

@@ -0,0 +1,39 @@
+/**
+ * Build successful design result
+ */
+export function buildDesignResult(featureId, technicalDesign, summary, iterations, checklistItemResults) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'success',
+        summary,
+        iterations,
+        data: checklistItemResults
+            ? { checklist_item_results: checklistItemResults }
+            : undefined,
+    };
+}
+/**
+ * Build verification failure result
+ */
+export function buildVerificationFailureResult(featureId, technicalDesign, verificationResult, iterations) {
+    return {
+        featureId,
+        technicalDesign,
+        status: 'error',
+        summary: `Checklist verification failed after ${iterations} iterations: ${verificationResult.summary}`,
+        verificationResult,
+        iterations,
+    };
+}
+/**
+ * Build error result when no design was generated
+ */
+export function buildNoResultsError(featureId) {
+    return {
+        featureId,
+        technicalDesign: null,
+        status: 'error',
+        summary: 'Failed to generate technical design - no valid result received',
+    };
+}

package/dist/phases/technical-design/analyzer.d.ts

@@ -0,0 +1,21 @@
+import { EdsgerConfig } from '../../types/index.js';
+import { ChecklistPhaseContext } from '../../services/checklist.js';
+export interface TechnicalDesignOptions {
+    featureId: string;
+    verbose?: boolean;
+    maxVerificationIterations?: number;
+}
+export interface TechnicalDesignResult {
+    featureId: string;
+    technicalDesign: string | null;
+    status: 'success' | 'error';
+    summary: string;
+    verificationResult?: any;
+    iterations?: number;
+    savedViaHttp?: boolean;
+    data?: {
+        checklist_item_results?: any[];
+        [key: string]: any;
+    };
+}
+export declare const generateTechnicalDesign: (options: TechnicalDesignOptions, config: EdsgerConfig, checklistContext?: ChecklistPhaseContext | null) => Promise<TechnicalDesignResult>;