edsger 0.26.0 → 0.26.2

package/dist/phases/pr-execution/outcome.js

@@ -0,0 +1,34 @@
+/**
+ * Build a successful execution result
+ */
+export function buildExecutionSuccessResult(featureId, executionSummary, summary) {
+    const details = executionSummary.branchesUpdated > 0
+        ? `${executionSummary.branchesUpdated} branches updated, ${executionSummary.prsUpdated} PRs updated`
+        : `${executionSummary.branchesCreated} branches created, ${executionSummary.prsCreated} PRs created`;
+    return {
+        featureId,
+        status: 'success',
+        summary: `${summary} (${details})`,
+        executionSummary,
+    };
+}
+/**
+ * Build an error result
+ */
+export function buildExecutionErrorResult(featureId, errorMessage) {
+    return {
+        featureId,
+        status: 'error',
+        summary: `PR execution failed: ${errorMessage}`,
+    };
+}
+/**
+ * Build a no-change result
+ */
+export function buildNoChangeResult(featureId, prCount) {
+    return {
+        featureId,
+        status: 'success',
+        summary: `All ${prCount} PR branches are already synced to latest commit. No changes needed.`,
+    };
+}

package/dist/phases/pr-execution/pr-executor.d.ts

@@ -0,0 +1,28 @@
+/**
+ * PR Executor for pushing branches and creating GitHub pull requests
+ * Handles fork-aware PR creation
+ */
+import type { RepoForkInfo } from '../../utils/github-repo-info.js';
+export interface PRExecutionConfig {
+    githubToken: string;
+    owner: string;
+    repo: string;
+    forkInfo: RepoForkInfo;
+    verbose?: boolean;
+}
+export interface PRExecutionResult {
+    branchName: string;
+    prUrl?: string;
+    prNumber?: number;
+    headSha: string;
+    success: boolean;
+    error?: string;
+}
+/**
+ * Push a branch and create a GitHub PR (fork-aware)
+ */
+export declare function pushAndCreateGitHubPR(config: PRExecutionConfig, branchName: string, title: string, description: string): Promise<PRExecutionResult>;
+/**
+ * Update a PR record in the database with GitHub PR info and sync commit
+ */
+export declare function updatePRDatabaseRecord(prId: string, prUrl: string, prNumber: number, headSha: string, verbose?: boolean): Promise<void>;

package/dist/phases/pr-execution/pr-executor.js

@@ -0,0 +1,152 @@
+/**
+ * PR Executor for pushing branches and creating GitHub pull requests
+ * Handles fork-aware PR creation
+ */
+import { Octokit } from '@octokit/rest';
+import { execSync } from 'child_process';
+import { logInfo, logError } from '../../utils/logger.js';
+import { updatePullRequest } from '../../services/pull-requests.js';
+/**
+ * Push a branch to remote with force-with-lease fallback
+ */
+function pushBranch(branchName, verbose) {
+    try {
+        if (verbose) {
+            logInfo(`📤 Pushing branch ${branchName} to remote...`);
+        }
+        try {
+            execSync(`git push -u origin ${branchName}`, {
+                encoding: 'utf-8',
+                stdio: verbose ? 'inherit' : 'pipe',
+            });
+        }
+        catch {
+            try {
+                execSync(`git push origin ${branchName}`, {
+                    encoding: 'utf-8',
+                    stdio: verbose ? 'inherit' : 'pipe',
+                });
+            }
+            catch {
+                if (verbose) {
+                    logInfo(`⚠️ Push rejected, attempting force push with lease...`);
+                }
+                execSync(`git push --force-with-lease origin ${branchName}`, {
+                    encoding: 'utf-8',
+                    stdio: verbose ? 'inherit' : 'pipe',
+                });
+                if (verbose) {
+                    logInfo(`✅ Successfully force pushed ${branchName}`);
+                }
+            }
+        }
+    }
+    catch (error) {
+        throw new Error(`Failed to push branch ${branchName}: ${error instanceof Error ? error.message : String(error)}`);
+    }
+}
+/**
+ * Get the HEAD SHA of a local branch
+ */
+function getLocalBranchSha(branchName) {
+    return execSync(`git rev-parse ${branchName}`, {
+        encoding: 'utf-8',
+    }).trim();
+}
+/**
+ * Push a branch and create a GitHub PR (fork-aware)
+ */
+export async function pushAndCreateGitHubPR(config, branchName, title, description) {
+    const { githubToken, owner, repo, forkInfo, verbose } = config;
+    const headSha = getLocalBranchSha(branchName);
+    try {
+        // Push the branch to origin
+        pushBranch(branchName, verbose);
+        const octokit = new Octokit({ auth: githubToken });
+        // Determine PR target based on fork status
+        let prOwner;
+        let prRepo;
+        let prHead;
+        const prBase = 'main';
+        if (forkInfo.isFork && forkInfo.upstream) {
+            prOwner = forkInfo.upstream.owner;
+            prRepo = forkInfo.upstream.repo;
+            prHead = `${owner}:${branchName}`;
+            if (verbose) {
+                logInfo(`📝 Creating PR on upstream ${prOwner}/${prRepo}: ${prHead} → ${prBase}`);
+            }
+        }
+        else {
+            prOwner = owner;
+            prRepo = repo;
+            prHead = branchName;
+            if (verbose) {
+                logInfo(`📝 Creating PR on ${prOwner}/${prRepo}: ${prHead} → ${prBase}`);
+            }
+        }
+        // Check for existing open PR
+        const { data: existingPRs } = await octokit.pulls.list({
+            owner: prOwner,
+            repo: prRepo,
+            head: forkInfo.isFork ? prHead : `${prOwner}:${prHead}`,
+            base: prBase,
+            state: 'open',
+        });
+        if (existingPRs.length > 0) {
+            const existingPR = existingPRs[0];
+            if (verbose) {
+                logInfo(`ℹ️ Found existing PR #${existingPR.number}: ${existingPR.html_url}`);
+            }
+            return {
+                branchName,
+                prUrl: existingPR.html_url,
+                prNumber: existingPR.number,
+                headSha,
+                success: true,
+            };
+        }
+        // Create new PR
+        const { data: newPR } = await octokit.pulls.create({
+            owner: prOwner,
+            repo: prRepo,
+            title,
+            body: description,
+            head: prHead,
+            base: prBase,
+            draft: false,
+        });
+        if (verbose) {
+            logInfo(`✅ Pull request created: ${newPR.html_url}`);
+        }
+        return {
+            branchName,
+            prUrl: newPR.html_url,
+            prNumber: newPR.number,
+            headSha,
+            success: true,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        if (verbose) {
+            logError(`❌ Failed to create PR for ${branchName}: ${errorMessage}`);
+        }
+        return {
+            branchName,
+            headSha,
+            success: false,
+            error: errorMessage,
+        };
+    }
+}
+/**
+ * Update a PR record in the database with GitHub PR info and sync commit
+ */
+export async function updatePRDatabaseRecord(prId, prUrl, prNumber, headSha, verbose) {
+    await updatePullRequest(prId, {
+        pull_request_url: prUrl,
+        pull_request_number: prNumber,
+        status: 'pr_opened',
+        last_synced_commit: headSha,
+    }, verbose);
+}

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

@@ -0,0 +1,17 @@
+import type { PullRequest } from '../../services/pull-requests.js';
+/**
+ * Create the system prompt for branch creation and code splitting
+ */
+export declare function createPRExecutionSystemPrompt(featureId: string, devBranchName: string): string;
+/**
+ * Create the system prompt for incremental sync (re-runs)
+ */
+export declare function createIncrementalSyncSystemPrompt(featureId: string, devBranchName: string): string;
+/**
+ * Create the user prompt for first-time branch creation
+ */
+export declare function createPRExecutionPrompt(featureId: string, devBranchName: string, pullRequests: PullRequest[]): string;
+/**
+ * Create the user prompt for incremental sync
+ */
+export declare function createIncrementalSyncPrompt(featureId: string, devBranchName: string, pullRequests: PullRequest[], lastSyncedCommit: string, diffStat: string, changedFiles: string[]): string;

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

@@ -0,0 +1,208 @@
+/**
+ * Create the system prompt for branch creation and code splitting
+ */
+export function createPRExecutionSystemPrompt(featureId, devBranchName) {
+    return `You are a git operations expert. Your task is to create PR branches and move the right code changes to each branch.
+
+## Task
+
+You will receive a PR plan with file assignments. For each PR in sequence order, you must:
+
+1. Switch to \`main\` branch
+2. Create a new branch \`pr/${featureId}/N-description\` from \`main\`
+3. Apply ONLY the relevant file changes from the \`${devBranchName}\` branch to this new branch
+4. Commit the changes with a meaningful commit message
+
+## Strategy for Moving Code
+
+Choose the best approach for each PR:
+
+### Option A: Selective file checkout (recommended for most cases)
+\`\`\`bash
+git checkout main
+git checkout -b pr/${featureId}/1-description
+git checkout ${devBranchName} -- path/to/file1 path/to/file2
+git commit -m "feat: descriptive message"
+\`\`\`
+
+### Option B: Using git diff + apply (for partial file changes)
+\`\`\`bash
+git checkout main
+git checkout -b pr/${featureId}/1-description
+git diff main...${devBranchName} -- path/to/file | git apply
+git add -A
+git commit -m "feat: descriptive message"
+\`\`\`
+
+## Rules
+
+1. **Always start each PR branch from \`main\`** — never from another PR branch
+2. **Each branch must be independent** — it should compile/build on its own when merged to main
+3. **Do NOT push branches** — just create them locally. Pushing is handled separately.
+4. **Verify after each branch**: Run \`git diff --stat main...pr/${featureId}/N-description\` to confirm only the expected files changed
+5. **Commit all changes** before switching branches
+6. **Handle new files**: For newly added files, use \`git checkout ${devBranchName} -- path/to/new/file\`
+7. **Handle deleted files**: For deleted files, use \`git rm path/to/deleted/file\`
+8. **After all branches are created**, switch back to \`main\`
+
+## Output
+
+After creating all branches, respond with:
+
+\`\`\`json
+{
+  "execution_result": {
+    "status": "success",
+    "branches_created": ["pr/${featureId}/1-desc", "pr/${featureId}/2-desc"],
+    "summary": "Brief description of what was done"
+  }
+}
+\`\`\`
+
+If any branch fails, include the error but continue with remaining branches:
+
+\`\`\`json
+{
+  "execution_result": {
+    "status": "partial",
+    "branches_created": ["pr/${featureId}/1-desc"],
+    "branches_failed": [{"branch": "pr/${featureId}/2-desc", "error": "..."}],
+    "summary": "..."
+  }
+}
+\`\`\``;
+}
+/**
+ * Create the system prompt for incremental sync (re-runs)
+ */
+export function createIncrementalSyncSystemPrompt(featureId, devBranchName) {
+    return `You are a git operations expert. Your task is to update existing PR branches with new changes from the dev branch.
+
+## Task
+
+The PR branches already exist from a previous run. New changes have been made on \`${devBranchName}\` since the last sync. You need to update each PR branch with the relevant new changes.
+
+## Strategy for Updating Branches
+
+For each existing PR branch:
+
+1. Switch to the PR branch: \`git checkout pr/${featureId}/N-description\`
+2. Apply the relevant NEW changes from \`${devBranchName}\`
+3. Commit the changes
+
+### Option A: Selective file checkout (for files entirely owned by this PR)
+\`\`\`bash
+git checkout pr/${featureId}/1-description
+git checkout ${devBranchName} -- path/to/file1 path/to/file2
+git commit -m "sync: update with latest changes from dev"
+\`\`\`
+
+### Option B: Using diff + apply (for partial changes)
+\`\`\`bash
+git checkout pr/${featureId}/1-description
+git diff <last_synced_commit>...${devBranchName} -- path/to/file | git apply
+git add -A
+git commit -m "sync: update with latest changes from dev"
+\`\`\`
+
+## Rules
+
+1. **Only update files that belong to each PR** according to the file assignments
+2. **Do NOT push branches** — just update them locally. Pushing is handled separately.
+3. **If a branch doesn't exist locally**, check remote and create a tracking branch
+4. **Verify after each update**: Check that the branch has the expected changes
+5. **Commit all changes** before switching branches
+6. **After all branches are updated**, switch back to \`main\`
+
+## Output
+
+After updating all branches, respond with:
+
+\`\`\`json
+{
+  "execution_result": {
+    "status": "success",
+    "branches_updated": ["pr/${featureId}/1-desc", "pr/${featureId}/2-desc"],
+    "summary": "Brief description of what was done"
+  }
+}
+\`\`\``;
+}
+/**
+ * Create the user prompt for first-time branch creation
+ */
+export function createPRExecutionPrompt(featureId, devBranchName, pullRequests) {
+    const prList = pullRequests
+        .map((pr) => {
+        const files = pr.files
+            ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
+            : '    (no files specified)';
+        return `### PR ${pr.sequence}: ${pr.name}
+- Branch: \`${pr.branch_name}\`
+- Description: ${pr.description}
+- Files:
+${files}`;
+    })
+        .join('\n\n');
+    return `# Create PR Branches
+
+Create the following PR branches from \`main\`, applying the relevant changes from \`${devBranchName}\`:
+
+${prList}
+
+## Instructions
+
+For each PR above (in sequence order):
+1. \`git checkout main\`
+2. Create the branch: \`git checkout -b <branch_name>\`
+3. Apply only the listed files from \`${devBranchName}\`
+4. Commit with a descriptive message
+5. Verify with \`git diff --stat main...<branch_name>\`
+
+After all branches are created, switch back to \`main\` and provide the execution result JSON.`;
+}
+/**
+ * Create the user prompt for incremental sync
+ */
+export function createIncrementalSyncPrompt(featureId, devBranchName, pullRequests, lastSyncedCommit, diffStat, changedFiles) {
+    const prList = pullRequests
+        .map((pr) => {
+        const files = pr.files
+            ? pr.files.map((f) => `    - ${f.path} (${f.change_type})`).join('\n')
+            : '    (no files specified)';
+        return `### PR ${pr.sequence}: ${pr.name}
+- Branch: \`${pr.branch_name}\`
+- Files:
+${files}`;
+    })
+        .join('\n\n');
+    return `# Sync PR Branches with Latest Changes
+
+New changes have been made on \`${devBranchName}\` since the last sync at commit \`${lastSyncedCommit}\`.
+
+## New Changes Since Last Sync
+
+### Diff Stat
+\`\`\`
+${diffStat || 'No changes detected'}
+\`\`\`
+
+### Changed Files (${changedFiles.length} files)
+${changedFiles.map((f) => `- ${f}`).join('\n') || 'No files changed'}
+
+## Existing PR Branches
+
+${prList}
+
+## Instructions
+
+For each PR branch that has files affected by the new changes:
+1. Switch to the PR branch
+2. Apply the relevant new changes from \`${devBranchName}\`
+3. Commit with a sync message
+4. Verify the branch state
+
+If a PR branch has no files affected by the new changes, skip it.
+
+After all branches are updated, switch back to \`main\` and provide the execution result JSON.`;
+}

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

@@ -2,13 +2,27 @@ import type { FeatureInfo } from '../../types/features.js';
 import { type ProductInfo } from '../../api/products.js';
 import { type Branch } from '../../services/branches.js';
 import { type PullRequest } from '../../services/pull-requests.js';
+import { type RepoForkInfo } from '../../utils/github-repo-info.js';
+export interface GitHubConfigInfo {
+    configured: boolean;
+    token?: string;
+    owner?: string;
+    repo?: string;
+    message?: string;
+}
 export interface PRSplittingContext {
     feature: FeatureInfo;
     product: ProductInfo;
     existing_branches: Branch[];
     existing_pull_requests: PullRequest[];
+    diffStat: string;
+    changedFiles: string[];
+    devBranchName: string;
+    devBranchHeadSha: string;
+    githubConfig: GitHubConfigInfo;
+    forkInfo: RepoForkInfo;
 }
 /**
- * Fetch all context information needed for PR splitting via MCP endpoints
+ * Fetch all context information needed for PR splitting
  */
-export declare function fetchPRSplittingContext(featureId: string, verbose?: boolean): Promise<PRSplittingContext>;
+export declare function fetchPRSplittingContext(featureId: string, verbose?: boolean, replaceExisting?: boolean): Promise<PRSplittingContext>;

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

@@ -1,36 +1,159 @@
+import { execSync } from 'child_process';
 import { logInfo, logError } from '../../utils/logger.js';
 import { getFeature } from '../../api/features/index.js';
 import { getProduct } from '../../api/products.js';
 import { getBranches } from '../../services/branches.js';
 import { getPullRequests, } from '../../services/pull-requests.js';
+import { getGitHubConfig } from '../../api/github.js';
+import { getRepoForkInfo, } from '../../utils/github-repo-info.js';
+import { branchExists, remoteBranchExists, } from '../../utils/git-branch-manager.js';
 /**
- * Fetch all context information needed for PR splitting via MCP endpoints
+ * Get the dev branch name for a feature
  */
-export async function fetchPRSplittingContext(featureId, verbose) {
+function getDevBranchName(featureId) {
+    return `dev/${featureId}`;
+}
+/**
+ * Get the HEAD SHA of a branch
+ */
+function getBranchHeadSha(branchName) {
+    return execSync(`git rev-parse ${branchName}`, { encoding: 'utf-8' }).trim();
+}
+/**
+ * Get diff stat between two refs
+ */
+function getDiffStat(baseRef, headRef) {
+    try {
+        return execSync(`git diff --stat ${baseRef}...${headRef}`, {
+            encoding: 'utf-8',
+        }).trim();
+    }
+    catch {
+        return '';
+    }
+}
+/**
+ * Get list of changed files between two refs
+ */
+function getChangedFiles(baseRef, headRef) {
+    try {
+        const output = execSync(`git diff --name-only ${baseRef}...${headRef}`, { encoding: 'utf-8' }).trim();
+        if (!output)
+            return [];
+        return output.split('\n').filter((f) => f.length > 0);
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Determine the diff base ref for incremental re-runs
+ * If existing PRs have last_synced_commit, use the earliest one
+ * Otherwise use main
+ */
+function determineDiffBaseRef(existingPRs, replaceExisting) {
+    if (replaceExisting || existingPRs.length === 0) {
+        return 'main';
+    }
+    // Find the minimum last_synced_commit (earliest sync point)
+    const syncedCommits = existingPRs
+        .map((pr) => pr.last_synced_commit)
+        .filter((c) => c !== null);
+    if (syncedCommits.length === 0) {
+        return 'main';
+    }
+    // All PRs should have been synced to the same commit
+    // Use the first one (they should all be equal after a successful sync)
+    return syncedCommits[0];
+}
+/**
+ * Fetch all context information needed for PR splitting
+ */
+export async function fetchPRSplittingContext(featureId, verbose, replaceExisting) {
     try {
         if (verbose) {
             logInfo(`Fetching PR splitting context for feature: ${featureId}`);
         }
-        // Fetch all required data in parallel for better performance
+        const devBranchName = getDevBranchName(featureId);
+        // Verify dev branch exists
+        const localExists = branchExists(devBranchName);
+        const remoteExists = !localExists && remoteBranchExists(devBranchName);
+        if (!localExists && !remoteExists) {
+            throw new Error(`Development branch '${devBranchName}' does not exist. ` +
+                `The feature must have code on the dev branch before PR splitting.`);
+        }
+        // If branch only exists on remote, fetch it
+        if (!localExists && remoteExists) {
+            if (verbose) {
+                logInfo(`Fetching remote branch ${devBranchName}...`);
+            }
+            execSync(`git fetch origin ${devBranchName}`, {
+                encoding: 'utf-8',
+                stdio: 'pipe',
+            });
+        }
+        // Fetch database data in parallel
         const [feature, existing_branches, existing_pull_requests] = await Promise.all([
             getFeature(featureId, verbose),
             getBranches({ featureId, verbose }).catch(() => []),
             getPullRequests({ featureId, verbose }).catch(() => []),
         ]);
         const product = await getProduct(feature.product_id, verbose);
+        // Fetch GitHub config
+        const githubConfig = await getGitHubConfig(featureId, verbose);
+        // Detect fork status
+        let forkInfo = { isFork: false };
+        if (githubConfig.configured && githubConfig.token && githubConfig.owner && githubConfig.repo) {
+            try {
+                forkInfo = await getRepoForkInfo(githubConfig.token, githubConfig.owner, githubConfig.repo);
+                if (verbose) {
+                    logInfo(forkInfo.isFork
+                        ? `📌 Repository is a fork of ${forkInfo.upstream?.owner}/${forkInfo.upstream?.repo}`
+                        : `📌 Repository is not a fork`);
+                }
+            }
+            catch (error) {
+                if (verbose) {
+                    logError(`Failed to detect fork status: ${error instanceof Error ? error.message : String(error)}`);
+                }
+            }
+        }
+        // Determine diff range
+        const devRef = localExists ? devBranchName : `origin/${devBranchName}`;
+        const baseRef = determineDiffBaseRef(existing_pull_requests, replaceExisting);
+        const devBranchHeadSha = getBranchHeadSha(devRef);
+        // Check if there are new changes since last sync
+        if (baseRef !== 'main' && baseRef === devBranchHeadSha) {
+            if (verbose) {
+                logInfo(`No new changes since last sync (HEAD: ${devBranchHeadSha})`);
+            }
+        }
+        // Get diff information
+        const diffStat = getDiffStat(baseRef, devRef);
+        const changedFiles = getChangedFiles(baseRef, devRef);
         if (verbose) {
             logInfo(`✅ PR splitting context fetched successfully:`);
             logInfo(`   Feature: ${feature.name}`);
             logInfo(`   Product: ${product.name}`);
-            logInfo(`   Technical Design: ${feature.technical_design ? 'Yes' : 'No'}`);
+            logInfo(`   Dev Branch: ${devBranchName}`);
+            logInfo(`   Dev Branch HEAD: ${devBranchHeadSha}`);
+            logInfo(`   Diff Base: ${baseRef}`);
+            logInfo(`   Changed Files: ${changedFiles.length}`);
             logInfo(`   Existing Branches: ${existing_branches.length}`);
             logInfo(`   Existing Pull Requests: ${existing_pull_requests.length}`);
+            logInfo(`   GitHub: ${githubConfig.configured ? 'Configured' : 'Not configured'}`);
         }
         return {
             feature,
             product,
             existing_branches,
             existing_pull_requests,
+            diffStat,
+            changedFiles,
+            devBranchName,
+            devBranchHeadSha,
+            githubConfig,
+            forkInfo,
         };
     }
     catch (error) {

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

@@ -24,6 +24,13 @@ export interface PRSplittingResult {
     summary: string;
     rationale?: string;
 }
+/**
+ * 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 declare const splitFeatureIntoPRs: (options: PRSplittingOptions, config: EdsgerConfig) => Promise<PRSplittingResult>;
 export { fetchPRSplittingContext } from './context.js';
 export type { PRSplittingContext } from './context.js';