edsger 0.30.0 → 0.30.1

package/.claude/settings.local.json

@@ -0,0 +1,8 @@
+{
+  "permissions": {
+    "allow": [
+      "Bash(npx tsc:*)",
+      "Bash(npm run:*)"
+    ]
+  }
+}

package/dist/phases/autonomous/index.js

@@ -14,6 +14,7 @@ import { createBranches, getCurrentBranch, updateBranch, } from '../../services/
 import { prepareCustomBranchGitEnvironmentAsync, resetUncommittedChanges, } from '../../utils/git-branch-manager.js';
 import { createBranchPullRequest, } from '../code-implementation/branch-pr-creator.js';
 import { getGitHubConfig } from '../../api/github.js';
+import { gitPush } from '../../utils/git-push.js';
 import { logFeaturePhaseEvent } from '../../services/audit-logs.js';
 import { createAutonomousSystemPrompt, createAutonomousUserPrompt, } from './prompts.js';
 /**
@@ -35,59 +36,6 @@ async function* prompt(userPrompt) {
     yield userMessage(userPrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-/**
- * Push branch to remote repository
- */
-async function pushToRemote(branchName, verbose) {
-    try {
-        const { execSync } = await import('child_process');
-        if (verbose) {
-            logInfo(`📤 Pushing branch ${branchName} to remote...`);
-        }
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch {
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch {
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    return { success: true };
-                }
-                catch (forceError) {
-                    return {
-                        success: false,
-                        error: forceError instanceof Error
-                            ? forceError.message
-                            : String(forceError),
-                    };
-                }
-            }
-        }
-    }
-    catch (error) {
-        return {
-            success: false,
-            error: error instanceof Error ? error.message : String(error),
-        };
-    }
-}
 /**
  * Run a single autonomous iteration using Claude Code SDK
  */
@@ -265,14 +213,19 @@ export async function runAutonomousDevelopment(options, config, _checklistContex
             logInfo(`⏱️  Iteration ${totalIterations} took ${(iterationDuration / 1000).toFixed(0)}s`);
             if (iterationResult.success) {
                 logInfo(`✅ Iteration ${totalIterations}: ${iterationResult.summary || 'completed'}`);
-                // Push to remote
-                const pushResult = await pushToRemote(devBranchName, verbose);
+                // Get GitHub config for push authentication and PR creation
+                const githubConfig = await getGitHubConfig(featureId, verbose);
+                // Push to remote with authentication
+                const pushResult = gitPush({
+                    branchName: devBranchName,
+                    token: githubConfig.configured ? githubConfig.token : undefined,
+                    verbose,
+                });
                 if (!pushResult.success && verbose) {
                     logError(`⚠️  Failed to push: ${pushResult.error}`);
                 }
                 // Create PR after first successful iteration
                 if (!prUrl) {
-                    const githubConfig = await getGitHubConfig(featureId, verbose);
                     if (githubConfig.configured &&
                         githubConfig.token &&
                         githubConfig.owner &&

package/dist/phases/code-implementation/branch-pr-creator.js

@@ -3,8 +3,8 @@
  * Creates pull requests from dev/ branches to feat/ branches
  */
 import { Octokit } from '@octokit/rest';
-import { execSync } from 'child_process';
 import { logInfo, logError } from '../../utils/logger.js';
+import { gitPush } from '../../utils/git-push.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
 const PR_TITLE_PREFIX = 'feat: ';
@@ -40,62 +40,6 @@ export function devBranchToFeatBranch(devBranchName) {
     // If already feat/ or other format, return as-is
     return devBranchName;
 }
-/**
- * Push a branch to remote
- * Falls back to force-with-lease if normal push fails (e.g., after rebase)
- */
-async function pushBranch(branchName, verbose) {
-    try {
-        if (verbose) {
-            logInfo(`📤 Pushing branch ${branchName} to remote...`);
-        }
-        // Try to push with -u flag (sets upstream if not already set)
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch (error) {
-            // If push fails, try without -u flag
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch (retryError) {
-                // If push still fails (likely non-fast-forward after rebase),
-                // use force-with-lease for safer force push
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    if (verbose) {
-                        logInfo(`✅ Successfully force pushed ${branchName}`);
-                    }
-                    return { success: true };
-                }
-                catch (forceError) {
-                    const errorMessage = forceError instanceof Error
-                        ? forceError.message
-                        : String(forceError);
-                    return { success: false, error: errorMessage };
-                }
-            }
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return { success: false, error: errorMessage };
-    }
-}
 /**
  * Create a pull request from a dev/ branch to its corresponding feat/ branch
  * This is used after code implementation in multi-branch features
@@ -115,7 +59,7 @@ export async function createBranchPullRequest(config, devBranchName, featureName
         if (verbose) {
             logInfo(`📤 Pushing ${devBranchName} to remote...`);
         }
-        const pushResult = await pushBranch(devBranchName, verbose);
+        const pushResult = gitPush({ branchName: devBranchName, token: githubToken, verbose });
         if (!pushResult.success) {
             return {
                 success: false,

package/dist/phases/code-implementation/index.js

@@ -1,6 +1,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logInfo, logError } from '../../utils/logger.js';
+import { gitPush } from '../../utils/git-push.js';
 import { formatChecklistsForContext, } from '../../services/checklist.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { fetchCodeImplementationContext, formatContextForPrompt, } from './context.js';
@@ -164,6 +165,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
     // Sync feat branch to main before rebase to ensure it's up to date
     // This prevents the PR (dev → feat) from showing extra commits
     let featSyncedToMain = false;
+    let githubTokenForPush;
     if (devBranchName.startsWith('dev/')) {
         try {
             const githubConfig = await getGitHubConfig(featureId, verbose);
@@ -171,6 +173,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
                 githubConfig.token &&
                 githubConfig.owner &&
                 githubConfig.repo) {
+                githubTokenForPush = githubConfig.token;
                 const { devBranchToFeatBranch } = await import('./branch-pr-creator.js');
                 const featBranchName = devBranchToFeatBranch(devBranchName);
                 if (verbose) {
@@ -200,6 +203,7 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
         },
         forcePushAfterRebase: featSyncedToMain, // Trigger GitHub to recalculate PR diff
         baseBranchCompleted, // Tell conflict resolver to use --theirs for all conflicts
+        githubToken: githubTokenForPush,
     });
     try {
         // Fetch all required context information via MCP endpoints
@@ -462,7 +466,11 @@ export const implementFeatureCode = async (options, config, checklistContext) =>
             if (verbose) {
                 logInfo(`📤 Pushing code to remote repository...`);
             }
-            const pushResult = await pushToRemote(structuredImplementationResult.branch_name || branchName, verbose);
+            const pushResult = gitPush({
+                branchName: structuredImplementationResult.branch_name || branchName,
+                token: githubTokenForPush,
+                verbose,
+            });
             if (!pushResult.success && verbose) {
                 logError(`⚠️  Failed to push to remote: ${pushResult.error}`);
                 logInfo('   Code is committed locally and will be reviewed. Manual push may be needed.');
@@ -854,69 +862,3 @@ const parseImplementationResponse = (response, featureId) => {
         };
     }
 };
-/**
- * Push branch to remote repository
- * Falls back to force-with-lease if normal push fails (e.g., after rebase)
- */
-async function pushToRemote(branchName, verbose) {
-    try {
-        // Import exec from child_process
-        const { execSync } = await import('child_process');
-        if (verbose) {
-            logInfo(`Pushing branch ${branchName} to remote...`);
-        }
-        // Try to push with -u flag (sets upstream if not already set)
-        try {
-            execSync(`git push -u origin ${branchName}`, {
-                encoding: 'utf-8',
-                stdio: verbose ? 'inherit' : 'pipe',
-            });
-            return { success: true };
-        }
-        catch (error) {
-            // If push fails, it might be because branch already has upstream
-            // Try without -u flag
-            try {
-                execSync(`git push origin ${branchName}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                return { success: true };
-            }
-            catch (retryError) {
-                // If push still fails (likely non-fast-forward after rebase),
-                // use force-with-lease for safer force push
-                // force-with-lease ensures we don't overwrite others' work by checking remote state
-                if (verbose) {
-                    logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-                }
-                try {
-                    execSync(`git push --force-with-lease origin ${branchName}`, {
-                        encoding: 'utf-8',
-                        stdio: verbose ? 'inherit' : 'pipe',
-                    });
-                    if (verbose) {
-                        logInfo(`✅ Successfully force pushed ${branchName}`);
-                    }
-                    return { success: true };
-                }
-                catch (forceError) {
-                    const errorMessage = forceError instanceof Error
-                        ? forceError.message
-                        : String(forceError);
-                    return {
-                        success: false,
-                        error: errorMessage,
-                    };
-                }
-            }
-        }
-    }
-    catch (error) {
-        const errorMessage = error instanceof Error ? error.message : String(error);
-        return {
-            success: false,
-            error: errorMessage,
-        };
-    }
-}

package/dist/phases/code-refine/index.js

@@ -6,7 +6,7 @@
 import { query } from '@anthropic-ai/claude-agent-sdk';
 import { DEFAULT_MODEL } from '../../constants.js';
 import { logInfo, logError } from '../../utils/logger.js';
-import { execSync } from 'child_process';
+import { gitPushCurrentBranch } from '../../utils/git-push.js';
 import { fetchCodeRefineContext, } from './context.js';
 import { getFeedbacksForPhase, formatFeedbacksForContext, } from '../../services/feedbacks.js';
 import { createSystemPrompt, createCodeRefinePrompt } from './prompts.js';
@@ -26,41 +26,6 @@ async function* prompt(refinePrompt) {
     yield userMessage(refinePrompt);
     await new Promise((res) => setTimeout(res, 10000));
 }
-// Git utility functions are now imported from shared module
-/**
- * Push changes to remote branch
- */
-const pushChanges = (verbose) => {
-    try {
-        if (verbose) {
-            logInfo(`📤 Pushing changes to remote...`);
-        }
-        execSync('git push origin $(git branch --show-current)', {
-            encoding: 'utf-8',
-        });
-        if (verbose) {
-            logInfo(`✅ Successfully pushed changes`);
-        }
-    }
-    catch (error) {
-        // If push fails due to non-fast-forward, use force-with-lease for safer force push
-        // force-with-lease ensures we don't overwrite others' work by checking remote state
-        if (verbose) {
-            logInfo(`⚠️  Push rejected, attempting force push with lease...`);
-        }
-        try {
-            execSync('git push --force-with-lease origin $(git branch --show-current)', {
-                encoding: 'utf-8',
-            });
-            if (verbose) {
-                logInfo(`✅ Successfully force pushed changes`);
-            }
-        }
-        catch (forceError) {
-            throw new Error(`Failed to push changes: ${forceError instanceof Error ? forceError.message : String(forceError)}`);
-        }
-    }
-};
 /**
  * Main code refine function with built-in verification loop
  * Similar to technical-design, this includes an iterative improvement cycle:
@@ -178,6 +143,7 @@ export const refineCodeFromPRFeedback = async (options, config, checklistContext
             },
             forcePushAfterRebase: featSyncedToMain,
             baseBranchCompleted: baseBranchCompletedForRebase,
+            githubToken,
         })
         : await preparePhaseGitEnvironmentAsync(featureId, 'main', verbose, true, {
             model: DEFAULT_MODEL,
@@ -258,7 +224,10 @@ Please ensure Claude Code commits all changes before completing the refine phase
                 logInfo('✅ All changes committed. Pushing to remote...');
             }
             try {
-                pushChanges(verbose);
+                const pushResult = gitPushCurrentBranch({ token: githubToken, verbose });
+                if (!pushResult.success) {
+                    throw new Error(pushResult.error || 'Push failed');
+                }
             }
             catch (pushError) {
                 logError(`Failed to push changes: ${pushError}`);

package/dist/phases/code-review/index.js

@@ -232,6 +232,7 @@ export const reviewPullRequest = async (options, config, checklistContext) => {
             },
             forcePushAfterRebase: featSyncedToMain,
             baseBranchCompleted: baseBranchCompletedForRebase,
+            githubToken,
         })
         : await preparePhaseGitEnvironmentAsync(featureId, 'main', verbose, true, {
             model: DEFAULT_MODEL,

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

@@ -108,6 +108,7 @@ export const executeFeaturePRs = async (options, config) => {
             repo: context.githubConfig.repo,
             forkInfo: context.forkInfo,
             verbose,
+            token: context.githubConfig.token,
         };
         const executionSummary = {
             branchesCreated: 0,

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

@@ -8,6 +8,7 @@ export interface PRExecutionConfig {
     repo: string;
     forkInfo: RepoForkInfo;
     verbose?: boolean;
+    token?: string;
 }
 export interface PRBranchResult {
     branchName: string;
@@ -19,7 +20,7 @@ export interface PRBranchResult {
 /**
  * Push a branch to remote with force-with-lease fallback
  */
-export declare function pushBranch(branchName: string, verbose?: boolean): void;
+export declare function pushBranch(branchName: string, verbose?: boolean, token?: string): void;
 /**
  * Get the HEAD SHA of a local branch
  */

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

@@ -2,53 +2,24 @@
  * PR Executor for pushing branches to remote and generating compare URLs
  * Handles fork-aware URL construction for manual PR creation
  */
-import { execSync } from 'child_process';
 import { logInfo } from '../../utils/logger.js';
 import { updatePullRequest } from '../../services/pull-requests.js';
+import { gitPush } from '../../utils/git-push.js';
+import { execFileSync } from 'child_process';
 /**
  * Push a branch to remote with force-with-lease fallback
  */
-export 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)}`);
+export function pushBranch(branchName, verbose, token) {
+    const result = gitPush({ branchName, token, verbose });
+    if (!result.success) {
+        throw new Error(`Failed to push branch ${branchName}: ${result.error}`);
     }
 }
 /**
  * Get the HEAD SHA of a local branch
  */
 export function getLocalBranchSha(branchName) {
-    return execSync(`git rev-parse ${branchName}`, {
+    return execFileSync('git', ['rev-parse', branchName], {
         encoding: 'utf-8',
     }).trim();
 }
@@ -68,10 +39,10 @@ export function buildCompareUrl(forkInfo, owner, repo, branchName, base = 'main'
  * Push a branch and build the compare URL
  */
 export function pushBranchAndBuildUrl(config, branchName) {
-    const { owner, repo, forkInfo, verbose } = config;
+    const { owner, repo, forkInfo, verbose, token } = config;
     const headSha = getLocalBranchSha(branchName);
     try {
-        pushBranch(branchName, verbose);
+        pushBranch(branchName, verbose, token);
         const compareUrl = buildCompareUrl(forkInfo, owner, repo, branchName);
         if (verbose) {
             logInfo(`🔗 Compare URL: ${compareUrl}`);

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

@@ -4,6 +4,7 @@
  */
 import { Octokit } from '@octokit/rest';
 import { execSync } from 'child_process';
+import { gitPush } from '../../utils/git-push.js';
 // GitHub PR title best practice: keep under 72 characters
 const MAX_PR_TITLE_LENGTH = 72;
 const PR_TITLE_PREFIX = 'feat: ';
@@ -115,39 +116,6 @@ const switchToBranch = (branch, verbose) => {
         throw new Error(`Failed to switch to branch ${branch}: ${error}`);
     }
 };
-/**
- * Push current branch to remote
- * Falls back to force-with-lease if normal push fails (e.g., after rebase)
- */
-const pushBranch = (branch, verbose) => {
-    try {
-        if (verbose) {
-            console.log(`📤 Pushing branch ${branch} to remote...`);
-        }
-        execSync(`git push -u origin ${branch}`, { encoding: 'utf-8' });
-        if (verbose) {
-            console.log(`✅ Branch pushed successfully`);
-        }
-    }
-    catch (error) {
-        // If push fails (likely non-fast-forward after rebase),
-        // use force-with-lease for safer force push
-        if (verbose) {
-            console.log(`⚠️  Push rejected, attempting force push with lease...`);
-        }
-        try {
-            execSync(`git push --force-with-lease origin ${branch}`, {
-                encoding: 'utf-8',
-            });
-            if (verbose) {
-                console.log(`✅ Successfully force pushed ${branch}`);
-            }
-        }
-        catch (forceError) {
-            throw new Error(`Failed to push branch: ${forceError}`);
-        }
-    }
-};
 /**
  * Switch to main branch
  */
@@ -276,7 +244,10 @@ export async function createPullRequest(config, feature) {
             }
             try {
                 // Push current branch to remote first
-                pushBranch(currentBranch, verbose);
+                const pushResult = gitPush({ branchName: currentBranch, token: githubToken, verbose });
+                if (!pushResult.success) {
+                    throw new Error(`Failed to push branch: ${pushResult.error}`);
+                }
                 // Get the base branch (main) SHA to create feat/ branch from
                 const { data: baseBranchData } = await octokit.repos.getBranch({
                     owner,
@@ -306,7 +277,10 @@ export async function createPullRequest(config, feature) {
         }
         else {
             // If not a dev/ branch, push it normally
-            pushBranch(currentBranch, verbose);
+            const pushResult = gitPush({ branchName: currentBranch, token: githubToken, verbose });
+            if (!pushResult.success) {
+                throw new Error(`Failed to push branch: ${pushResult.error}`);
+            }
         }
         // Generate PR title and body
         const title = generatePRTitle(feature.name);

package/dist/utils/git-branch-manager.d.ts

@@ -212,6 +212,8 @@ export interface RebaseWithConflictResolutionOptions {
      * GitHub to recalculate the PR diff.
      */
     forcePushAfterRebase?: boolean;
+    /** GitHub App installation token for authenticated push */
+    githubToken?: string;
 }
 /**
  * Switch to feature branch and rebase with base branch, with optional automatic conflict resolution

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

@@ -7,6 +7,7 @@ import * as fs from 'fs';
 import * as path from 'path';
 import { Octokit } from '@octokit/rest';
 import { logInfo, logError } from './logger.js';
+import { gitForcePush } from './git-push.js';
 /**
  * Get current Git branch name
  */
@@ -689,7 +690,7 @@ export async function syncFeatBranchWithMain(featBranch, githubToken, owner, rep
  * @returns Object containing the previous branch name and conflict resolution result
  */
 export async function switchToFeatureBranchAndRebaseAsync(options) {
-    const { featureBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, } = options;
+    const { featureBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, githubToken, } = options;
     // Determine the actual target branch for rebase
     // If rebaseTargetBranch is set (e.g., main), use it; otherwise use baseBranch
     const actualRebaseTarget = rebaseTargetBranch || baseBranch;
@@ -864,23 +865,9 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
         }
         // Force push after rebase to trigger GitHub to recalculate PR diff
         if (forcePushAfterRebase) {
-            try {
-                if (verbose) {
-                    logInfo(`📤 Force pushing ${featureBranch} to trigger PR diff recalculation...`);
-                }
-                execSync(`git push --force-with-lease origin ${featureBranch}`, {
-                    encoding: 'utf-8',
-                    stdio: verbose ? 'inherit' : 'pipe',
-                });
-                if (verbose) {
-                    logInfo(`✅ Successfully force pushed ${featureBranch}`);
-                }
-            }
-            catch (pushError) {
-                if (verbose) {
-                    logInfo(`⚠️  Could not force push ${featureBranch}: ${pushError instanceof Error ? pushError.message : String(pushError)}`);
-                }
-                // Don't fail the whole process if push fails
+            const pushResult = gitForcePush({ branchName: featureBranch, token: githubToken, verbose });
+            if (!pushResult.success && verbose) {
+                logInfo(`⚠️  Could not force push ${featureBranch}: ${pushResult.error}`);
             }
         }
         return { previousBranch };
@@ -908,23 +895,9 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
                 }
                 // Force push after rebase to trigger GitHub to recalculate PR diff
                 if (forcePushAfterRebase) {
-                    try {
-                        if (verbose) {
-                            logInfo(`📤 Force pushing ${featureBranch} to trigger PR diff recalculation...`);
-                        }
-                        execSync(`git push --force-with-lease origin ${featureBranch}`, {
-                            encoding: 'utf-8',
-                            stdio: verbose ? 'inherit' : 'pipe',
-                        });
-                        if (verbose) {
-                            logInfo(`✅ Successfully force pushed ${featureBranch}`);
-                        }
-                    }
-                    catch (pushError) {
-                        if (verbose) {
-                            logInfo(`⚠️  Could not force push ${featureBranch}: ${pushError instanceof Error ? pushError.message : String(pushError)}`);
-                        }
-                        // Don't fail the whole process if push fails
+                    const pushResult = gitForcePush({ branchName: featureBranch, token: githubToken, verbose });
+                    if (!pushResult.success && verbose) {
+                        logInfo(`⚠️  Could not force push ${featureBranch}: ${pushResult.error}`);
                     }
                 }
                 return {

package/dist/utils/git-push.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Shared git push utilities with GitHub App credential helper support.
+ *
+ * Uses `git -c credential.helper=...` to pass the token securely per-command,
+ * matching the pattern established in workspace-manager.ts for clone/fetch.
+ * Uses `execFileSync` instead of `execSync` to avoid shell metacharacter injection.
+ */
+export interface GitPushOptions {
+    branchName: string;
+    token?: string;
+    verbose?: boolean;
+    cwd?: string;
+}
+export interface GitPushResult {
+    success: boolean;
+    error?: string;
+    method?: 'push-u' | 'push' | 'force-with-lease';
+}
+/**
+ * Build git args with optional credential helper prefix.
+ * When a token is provided, prepends `-c credential.helper=...` so git
+ * authenticates with the GitHub App installation token.
+ */
+export declare function buildCredentialArgs(token?: string): string[];
+/**
+ * Push a branch to remote with three-level fallback:
+ *   1. git push -u origin <branch>
+ *   2. git push origin <branch>
+ *   3. git push --force-with-lease origin <branch>
+ *
+ * When `token` is provided, each command uses a credential helper for authentication.
+ */
+export declare function gitPush(options: GitPushOptions): GitPushResult;
+/**
+ * Force push a branch using --force-with-lease.
+ * Used after rebase operations to update the remote branch.
+ */
+export declare function gitForcePush(options: GitPushOptions): GitPushResult;
+/**
+ * Push the current branch to remote.
+ * Resolves the current branch name first, then delegates to gitPush.
+ */
+export declare function gitPushCurrentBranch(options: Omit<GitPushOptions, 'branchName'>): GitPushResult;

package/dist/utils/git-push.js

@@ -0,0 +1,125 @@
+/**
+ * Shared git push utilities with GitHub App credential helper support.
+ *
+ * Uses `git -c credential.helper=...` to pass the token securely per-command,
+ * matching the pattern established in workspace-manager.ts for clone/fetch.
+ * Uses `execFileSync` instead of `execSync` to avoid shell metacharacter injection.
+ */
+import { execFileSync } from 'child_process';
+import { logInfo } from './logger.js';
+/**
+ * Build git args with optional credential helper prefix.
+ * When a token is provided, prepends `-c credential.helper=...` so git
+ * authenticates with the GitHub App installation token.
+ */
+export function buildCredentialArgs(token) {
+    if (!token)
+        return [];
+    const credentialHelper = `!f() { echo "username=x-access-token"; echo "password=${token}"; }; f`;
+    return ['-c', `credential.helper=${credentialHelper}`];
+}
+/**
+ * Push a branch to remote with three-level fallback:
+ *   1. git push -u origin <branch>
+ *   2. git push origin <branch>
+ *   3. git push --force-with-lease origin <branch>
+ *
+ * When `token` is provided, each command uses a credential helper for authentication.
+ */
+export function gitPush(options) {
+    const { branchName, token, verbose, cwd } = options;
+    const credArgs = buildCredentialArgs(token);
+    const execOpts = {
+        cwd,
+        stdio: (verbose ? 'inherit' : 'pipe'),
+    };
+    if (verbose) {
+        logInfo(`📤 Pushing branch ${branchName} to remote...`);
+    }
+    // Try 1: push -u (set upstream tracking)
+    try {
+        execFileSync('git', [...credArgs, 'push', '-u', 'origin', branchName], execOpts);
+        return { success: true, method: 'push-u' };
+    }
+    catch {
+        // fall through
+    }
+    // Try 2: plain push
+    try {
+        execFileSync('git', [...credArgs, 'push', 'origin', branchName], execOpts);
+        return { success: true, method: 'push' };
+    }
+    catch {
+        // fall through
+    }
+    // Try 3: force push with lease
+    if (verbose) {
+        logInfo(`⚠️  Push rejected, attempting force push with lease...`);
+    }
+    try {
+        execFileSync('git', [...credArgs, 'push', '--force-with-lease', 'origin', branchName], execOpts);
+        if (verbose) {
+            logInfo(`✅ Successfully force pushed ${branchName}`);
+        }
+        return { success: true, method: 'force-with-lease' };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Force push a branch using --force-with-lease.
+ * Used after rebase operations to update the remote branch.
+ */
+export function gitForcePush(options) {
+    const { branchName, token, verbose, cwd } = options;
+    const credArgs = buildCredentialArgs(token);
+    const execOpts = {
+        cwd,
+        stdio: (verbose ? 'inherit' : 'pipe'),
+    };
+    if (verbose) {
+        logInfo(`📤 Force pushing ${branchName} to remote...`);
+    }
+    try {
+        execFileSync('git', [...credArgs, 'push', '--force-with-lease', 'origin', branchName], execOpts);
+        if (verbose) {
+            logInfo(`✅ Successfully force pushed ${branchName}`);
+        }
+        return { success: true, method: 'force-with-lease' };
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: error instanceof Error ? error.message : String(error),
+        };
+    }
+}
+/**
+ * Push the current branch to remote.
+ * Resolves the current branch name first, then delegates to gitPush.
+ */
+export function gitPushCurrentBranch(options) {
+    const { token, verbose, cwd } = options;
+    let branchName;
+    try {
+        branchName = execFileSync('git', ['branch', '--show-current'], {
+            encoding: 'utf-8',
+            cwd,
+            stdio: 'pipe',
+        }).trim();
+    }
+    catch (error) {
+        return {
+            success: false,
+            error: `Failed to resolve current branch: ${error instanceof Error ? error.message : String(error)}`,
+        };
+    }
+    if (!branchName) {
+        return { success: false, error: 'Could not determine current branch (detached HEAD?)' };
+    }
+    return gitPush({ branchName, token, verbose, cwd });
+}

package/package.json

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