edsger 0.50.0 → 0.52.0

package/dist/utils/formatters.js

@@ -29,19 +29,19 @@ export function formatTestCases(cases) {
  * Format technical design context for Claude Code prompts
  */
 export async function formatTechnicalDesignContext(context) {
-    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.issue.description || 'No description provided', context.issue.id // Use issue ID for directory naming
     );
     const content = `# Technical Design Context
 
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
+## Issue Information
+- **ID**: ${context.issue.id}
+- **Name**: ${context.issue.name}
 - **Description**:
 ${processedMarkdown}
 
 ${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
 
-- **Current Status**: ${context.feature.status}
+- **Current Status**: ${context.issue.status}
 
 ## Product Information
 - **Product**: ${context.product.name}
@@ -55,30 +55,30 @@ ${formatUserStories(context.user_stories)}
 ${formatTestCases(context.test_cases)}
 
 ## Current Technical Design
-${context.feature.technical_design || 'No existing technical design found'}
+${context.issue.technical_design || 'No existing technical design found'}
 
 ---
 
-**Design Instructions**: Based on the above feature requirements, user stories, and test cases, create or enhance the comprehensive technical design. Focus on system architecture, component design, database schema, API specifications, security considerations, and implementation strategy.`;
+**Design Instructions**: Based on the above issue requirements, user stories, and test cases, create or enhance the comprehensive technical design. Focus on system architecture, component design, database schema, API specifications, security considerations, and implementation strategy.`;
     return { content, downloadedImages };
 }
 /**
- * Format feature analysis context for Claude Code prompts
+ * Format issue analysis context for Claude Code prompts
  */
-export async function formatFeatureAnalysisContext(context) {
-    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+export async function formatIssueAnalysisContext(context) {
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.issue.description || 'No description provided', context.issue.id // Use issue ID for directory naming
     );
-    const content = `# Feature Analysis Context
+    const content = `# Issue Analysis Context
 
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
+## Issue Information
+- **ID**: ${context.issue.id}
+- **Name**: ${context.issue.name}
 - **Description**:
 ${processedMarkdown}
 
 ${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
 
-- **Current Status**: ${context.feature.status}
+- **Current Status**: ${context.issue.status}
 
 ## Product Information
 - **Product**: ${context.product.name}
@@ -92,30 +92,30 @@ ${formatUserStories(context.existing_user_stories)}
 ${formatTestCases(context.existing_test_cases)}
 
 ## Current Technical Design
-${context.feature.technical_design || 'No technical design available yet'}
+${context.issue.technical_design || 'No technical design available yet'}
 
 ---
 
-**Analysis Instructions**: Based on the above feature information and existing user stories/test cases, conduct comprehensive business analysis to identify gaps and create additional user stories and test cases that add business value.`;
+**Analysis Instructions**: Based on the above issue information and existing user stories/test cases, conduct comprehensive business analysis to identify gaps and create additional user stories and test cases that add business value.`;
     return { content, downloadedImages };
 }
 /**
  * Format code implementation context for Claude Code prompts
  */
 export async function formatCodeImplementationContext(context) {
-    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.issue.description || 'No description provided', context.issue.id // Use issue ID for directory naming
     );
     const content = `# Code Implementation Context
 
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
+## Issue Information
+- **ID**: ${context.issue.id}
+- **Name**: ${context.issue.name}
 - **Description**:
 ${processedMarkdown}
 
 ${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
 
-- **Current Status**: ${context.feature.status}
+- **Current Status**: ${context.issue.status}
 
 ## Product Information
 - **Product**: ${context.product.name}
@@ -133,26 +133,26 @@ ${context.technical_design || 'No technical design available - implement based o
 
 ---
 
-**Implementation Instructions**: Based on the above requirements, user stories, test cases, and technical design, implement the complete feature functionality. Ensure all user stories are implemented and all test cases can pass.`;
+**Implementation Instructions**: Based on the above requirements, user stories, test cases, and technical design, implement the complete issue functionality. Ensure all user stories are implemented and all test cases can pass.`;
     return { content, downloadedImages };
 }
 /**
  * Format functional testing context for Claude Code prompts
  */
 export async function formatFunctionalTestingContext(context) {
-    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.feature.description || 'No description provided', context.feature.id // Use feature ID for directory naming
+    const { processedMarkdown, downloadedImages } = await downloadImagesForClaudeCode(context.issue.description || 'No description provided', context.issue.id // Use issue ID for directory naming
     );
     const content = `# Functional Testing Context
 
-## Feature Information
-- **ID**: ${context.feature.id}
-- **Name**: ${context.feature.name}
+## Issue Information
+- **ID**: ${context.issue.id}
+- **Name**: ${context.issue.name}
 - **Description**:
 ${processedMarkdown}
 
 ${downloadedImages.length > 0 ? '**IMPORTANT**: The description contains images that have been downloaded locally. Please use the Read tool to view these images to fully understand the requirements.' : ''}
 
-- **Current Status**: ${context.feature.status}
+- **Current Status**: ${context.issue.status}
 
 ## Product Information
 - **Product**: ${context.product.name}
@@ -167,6 +167,6 @@ ${formatTestCases(context.test_cases)}
 
 ---
 
-**Testing Instructions**: The feature has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
+**Testing Instructions**: The issue has been implemented. Execute comprehensive functional testing using headless Playwright to verify all user stories work correctly and all test cases pass. Test both positive and negative scenarios.`;
     return { content, downloadedImages };
 }

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

@@ -29,7 +29,7 @@ export declare function syncFeatBranchWithMain(opts: SyncFeatBranchOptions): Pro
  * Options for async rebase with conflict resolution
  */
 export interface RebaseWithConflictResolutionOptions {
-    featureBranch: string;
+    issueBranch: string;
     /**
      * Base branch to create new branches from.
      * For merged parent branches, this is feat/xxx.
@@ -72,13 +72,13 @@ export interface RebaseWithConflictResolutionOptions {
     githubToken?: string;
 }
 /**
- * Switch to feature branch and rebase with base branch, with optional automatic conflict resolution
+ * Switch to issue branch and rebase with base branch, with optional automatic conflict resolution
  * This is the async version that supports conflict resolution using Claude agent
  *
  * @param options - Options for the rebase operation
  * @returns Object containing the previous branch name and conflict resolution result
  */
-export declare function switchToFeatureBranchAndRebaseAsync(options: RebaseWithConflictResolutionOptions): Promise<{
+export declare function switchToIssueBranchAndRebaseAsync(options: RebaseWithConflictResolutionOptions): Promise<{
     previousBranch: string;
     conflictsResolved?: boolean;
     resolvedFiles?: string[];
@@ -88,7 +88,7 @@ export declare function switchToFeatureBranchAndRebaseAsync(options: RebaseWithC
  *
  * Usage:
  *   const cleanup = await prepareCustomBranchGitEnvironmentAsync({
- *     featureBranch: 'feat/123/2-api',
+ *     issueBranch: 'feat/123/2-api',
  *     baseBranch: 'feat/123/1-database',
  *     verbose: true,
  *     resolveConflicts: true,
@@ -110,14 +110,14 @@ export declare function prepareCustomBranchGitEnvironmentAsync(options: RebaseWi
 /**
  * Async version of preparePhaseGitEnvironment with conflict resolution support.
  *
- * @param featureId - The feature ID (will be used to construct branch name "dev/{featureId}")
+ * @param issueId - The issue ID (will be used to construct branch name "dev/{issueId}")
  * @param baseBranch - The base branch to rebase from (default: "main")
  * @param verbose - Whether to log verbose output
  * @param resolveConflicts - Whether to automatically resolve conflicts using Claude
  * @param conflictResolverConfig - Configuration for the conflict resolver
  * @returns Cleanup function and conflict resolution info
  */
-export declare function preparePhaseGitEnvironmentAsync(featureId: string, baseBranch?: string, verbose?: boolean, resolveConflicts?: boolean, conflictResolverConfig?: {
+export declare function preparePhaseGitEnvironmentAsync(issueId: string, baseBranch?: string, verbose?: boolean, resolveConflicts?: boolean, conflictResolverConfig?: {
     model?: string;
     maxTurns?: number;
 }): Promise<{

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

@@ -100,36 +100,36 @@ export async function syncFeatBranchWithMain(opts) {
     }
 }
 /**
- * Switch to feature branch and rebase with base branch, with optional automatic conflict resolution
+ * Switch to issue branch and rebase with base branch, with optional automatic conflict resolution
  * This is the async version that supports conflict resolution using Claude agent
  *
  * @param options - Options for the rebase operation
  * @returns Object containing the previous branch name and conflict resolution result
  */
 // eslint-disable-next-line complexity -- async git branch management with rebase, conflict resolution, and recovery
-export async function switchToFeatureBranchAndRebaseAsync(options) {
-    const { featureBranch, baseBranch = 'main', rebaseTargetBranch, originalBaseBranch, verbose, resolveConflicts = false, conflictResolverConfig, forcePushAfterRebase = false, baseBranchCompleted = false, githubToken, } = options;
+export async function switchToIssueBranchAndRebaseAsync(options) {
+    const { issueBranch, 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;
     const previousBranch = getCurrentBranch();
     if (verbose) {
-        logInfo(`\n🔄 Preparing feature branch: ${featureBranch}`);
+        logInfo(`\n🔄 Preparing issue branch: ${issueBranch}`);
         logInfo(`   Current branch: ${previousBranch}`);
     }
-    // If feature branch doesn't exist, we need to create it from base branch
-    if (!branchExists(featureBranch)) {
+    // If issue branch doesn't exist, we need to create it from base branch
+    if (!branchExists(issueBranch)) {
         if (verbose) {
-            logInfo(`   Feature branch ${featureBranch} doesn't exist, will create from ${baseBranch}`);
+            logInfo(`   Issue branch ${issueBranch} doesn't exist, will create from ${baseBranch}`);
         }
-        // First, ensure we're on the base branch to create feature branch from it
+        // First, ensure we're on the base branch to create issue branch from it
         if (previousBranch !== baseBranch) {
             if (verbose) {
                 logInfo(`   Switching to ${baseBranch} first...`);
             }
             switchToBranch(baseBranch, verbose);
         }
-        // Pull latest base branch before creating feature branch
+        // Pull latest base branch before creating issue branch
         try {
             if (verbose) {
                 logInfo(`   Pulling latest ${baseBranch}...`);
@@ -142,12 +142,12 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             }
         }
     }
-    // Switch to feature branch (will create if doesn't exist)
+    // Switch to issue branch (will create if doesn't exist)
     // Default behavior now checks remote first (handles multi-clone scenarios)
-    if (getCurrentBranch() !== featureBranch) {
-        switchToBranch(featureBranch, verbose, { githubToken });
+    if (getCurrentBranch() !== issueBranch) {
+        switchToBranch(issueBranch, verbose, { githubToken });
     }
-    // Sync with remote feature branch if it exists and local branch needs updating
+    // Sync with remote issue branch if it exists and local branch needs updating
     // This handles the case where local branch exists but is behind remote
     try {
         if (hasUncommittedChanges()) {
@@ -163,57 +163,57 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             stdio: 'pipe',
         });
         try {
-            execSync(`git rev-parse --verify origin/${featureBranch}`, {
+            execSync(`git rev-parse --verify origin/${issueBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             });
             // Remote branch exists, check if we need to sync
             // Get local and remote commit SHAs
-            const localSha = execSync(`git rev-parse ${featureBranch}`, {
+            const localSha = execSync(`git rev-parse ${issueBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             }).trim();
-            const remoteSha = execSync(`git rev-parse origin/${featureBranch}`, {
+            const remoteSha = execSync(`git rev-parse origin/${issueBranch}`, {
                 encoding: 'utf-8',
                 stdio: 'pipe',
             }).trim();
             if (localSha !== remoteSha) {
                 // Local and remote differ, reset to remote
                 if (verbose) {
-                    logInfo(`📥 Syncing with remote feature branch origin/${featureBranch}...`);
+                    logInfo(`📥 Syncing with remote issue branch origin/${issueBranch}...`);
                     logInfo(`   Local:  ${localSha.substring(0, 7)}`);
                     logInfo(`   Remote: ${remoteSha.substring(0, 7)}`);
                 }
-                execSync(`git reset --hard origin/${featureBranch}`, {
+                execSync(`git reset --hard origin/${issueBranch}`, {
                     encoding: 'utf-8',
                     stdio: 'pipe',
                 });
                 if (verbose) {
-                    logInfo(`✅ Synced local branch with origin/${featureBranch}`);
+                    logInfo(`✅ Synced local branch with origin/${issueBranch}`);
                 }
             }
             else if (verbose) {
-                logInfo(`✅ Local branch is up to date with origin/${featureBranch}`);
+                logInfo(`✅ Local branch is up to date with origin/${issueBranch}`);
             }
         }
         catch (_e) {
             if (verbose) {
-                logInfo(`   Remote branch origin/${featureBranch} doesn't exist yet, will create on push`);
+                logInfo(`   Remote branch origin/${issueBranch} doesn't exist yet, will create on push`);
             }
         }
     }
     catch (_error) {
         if (verbose) {
-            logInfo(`⚠️  Could not sync with remote feature branch, continuing with local branch`);
+            logInfo(`⚠️  Could not sync with remote issue branch, continuing with local branch`);
         }
     }
-    // Rebase feature branch with latest target branch
+    // Rebase issue branch with latest target branch
     if (verbose) {
         if (originalBaseBranch) {
-            logInfo(`📥 Rebasing ${featureBranch} onto origin/${actualRebaseTarget} (from ${originalBaseBranch})...`);
+            logInfo(`📥 Rebasing ${issueBranch} onto origin/${actualRebaseTarget} (from ${originalBaseBranch})...`);
         }
         else {
-            logInfo(`📥 Rebasing ${featureBranch} with origin/${actualRebaseTarget}...`);
+            logInfo(`📥 Rebasing ${issueBranch} with origin/${actualRebaseTarget}...`);
         }
     }
     try {
@@ -284,17 +284,17 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             });
         }
         if (verbose) {
-            logInfo(`✅ Successfully rebased ${featureBranch} with origin/${actualRebaseTarget}\n`);
+            logInfo(`✅ Successfully rebased ${issueBranch} with origin/${actualRebaseTarget}\n`);
         }
         // Force push after rebase to trigger GitHub to recalculate PR diff
         if (forcePushAfterRebase) {
             const pushResult = gitForcePush({
-                branchName: featureBranch,
+                branchName: issueBranch,
                 token: githubToken,
                 verbose,
             });
             if (!pushResult.success && verbose) {
-                logInfo(`⚠️  Could not force push ${featureBranch}: ${pushResult.error}`);
+                logInfo(`⚠️  Could not force push ${issueBranch}: ${pushResult.error}`);
             }
         }
         return { previousBranch };
@@ -311,24 +311,24 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
                 model: conflictResolverConfig?.model,
                 maxTurns: conflictResolverConfig?.maxTurns,
                 verbose,
-                featureBranch,
+                issueBranch,
                 baseBranch,
                 originalBaseBranch,
                 baseBranchCompleted,
             });
             if (result.success) {
                 if (verbose) {
-                    logInfo(`✅ Successfully resolved conflicts and rebased ${featureBranch} with origin/${actualRebaseTarget}\n`);
+                    logInfo(`✅ Successfully resolved conflicts and rebased ${issueBranch} with origin/${actualRebaseTarget}\n`);
                 }
                 // Force push after rebase to trigger GitHub to recalculate PR diff
                 if (forcePushAfterRebase) {
                     const pushResult = gitForcePush({
-                        branchName: featureBranch,
+                        branchName: issueBranch,
                         token: githubToken,
                         verbose,
                     });
                     if (!pushResult.success && verbose) {
-                        logInfo(`⚠️  Could not force push ${featureBranch}: ${pushResult.error}`);
+                        logInfo(`⚠️  Could not force push ${issueBranch}: ${pushResult.error}`);
                     }
                 }
                 return {
@@ -339,7 +339,7 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
             }
             // Conflict resolution failed, abort rebase
             abortRebase(verbose);
-            throw new Error(`Failed to automatically resolve conflicts during rebase ${featureBranch} with ${actualRebaseTarget}.\n` +
+            throw new Error(`Failed to automatically resolve conflicts during rebase ${issueBranch} with ${actualRebaseTarget}.\n` +
                 `${result.error || 'Unknown error'}\n` +
                 `Please resolve conflicts manually and try again.`);
         }
@@ -349,8 +349,8 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
         if (verbose) {
             logError(`❌ Rebase failed and was aborted. Repository is in clean state.`);
         }
-        throw new Error(`Failed to rebase ${featureBranch} with ${actualRebaseTarget}: ${error instanceof Error ? error.message : String(error)}\n` +
-            `This usually means there are conflicts between your feature branch and base branch.\n` +
+        throw new Error(`Failed to rebase ${issueBranch} with ${actualRebaseTarget}: ${error instanceof Error ? error.message : String(error)}\n` +
+            `This usually means there are conflicts between your issue branch and base branch.\n` +
             `Please resolve conflicts manually and try again.`);
     }
 }
@@ -359,7 +359,7 @@ export async function switchToFeatureBranchAndRebaseAsync(options) {
  *
  * Usage:
  *   const cleanup = await prepareCustomBranchGitEnvironmentAsync({
- *     featureBranch: 'feat/123/2-api',
+ *     issueBranch: 'feat/123/2-api',
  *     baseBranch: 'feat/123/1-database',
  *     verbose: true,
  *     resolveConflicts: true,
@@ -380,7 +380,7 @@ export async function prepareCustomBranchGitEnvironmentAsync(options) {
         returnToMainBranch('main', verbose);
     };
     try {
-        const result = await switchToFeatureBranchAndRebaseAsync(options);
+        const result = await switchToIssueBranchAndRebaseAsync(options);
         return {
             cleanup,
             conflictsResolved: result.conflictsResolved,
@@ -402,17 +402,17 @@ export async function prepareCustomBranchGitEnvironmentAsync(options) {
 /**
  * Async version of preparePhaseGitEnvironment with conflict resolution support.
  *
- * @param featureId - The feature ID (will be used to construct branch name "dev/{featureId}")
+ * @param issueId - The issue ID (will be used to construct branch name "dev/{issueId}")
  * @param baseBranch - The base branch to rebase from (default: "main")
  * @param verbose - Whether to log verbose output
  * @param resolveConflicts - Whether to automatically resolve conflicts using Claude
  * @param conflictResolverConfig - Configuration for the conflict resolver
  * @returns Cleanup function and conflict resolution info
  */
-export async function preparePhaseGitEnvironmentAsync(featureId, baseBranch = 'main', verbose, resolveConflicts, conflictResolverConfig) {
-    const featureBranch = `dev/${featureId}`;
+export async function preparePhaseGitEnvironmentAsync(issueId, baseBranch = 'main', verbose, resolveConflicts, conflictResolverConfig) {
+    const issueBranch = `dev/${issueId}`;
     return prepareCustomBranchGitEnvironmentAsync({
-        featureBranch,
+        issueBranch,
         baseBranch,
         verbose,
         resolveConflicts,

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

@@ -103,15 +103,15 @@ export declare function switchToBranch(branch: string, verbose?: boolean, option
  */
 export declare function pullLatestFromBranch(branch: string, verbose?: boolean, githubToken?: string): void;
 /**
- * Switch to feature branch and rebase with main
+ * Switch to issue branch and rebase with main
  * This should be called at the START of each phase
  *
- * @param featureBranch - The feature branch to switch to (e.g., "dev/feature-id")
+ * @param issueBranch - The issue branch to switch to (e.g., "dev/issue-id")
  * @param baseBranch - The base branch to rebase from (usually "main")
  * @param verbose - Whether to log verbose output
  * @returns Object containing the previous branch name
  */
-export declare function switchToFeatureBranchAndRebase(featureBranch: string, baseBranch?: string, verbose?: boolean, githubToken?: string): {
+export declare function switchToIssueBranchAndRebase(issueBranch: string, baseBranch?: string, verbose?: boolean, githubToken?: string): {
     previousBranch: string;
 };
 /**
@@ -120,9 +120,9 @@ export declare function switchToFeatureBranchAndRebase(featureBranch: string, ba
  */
 export declare function returnToMainBranch(baseBranch?: string, verbose?: boolean): void;
 /**
- * Full phase lifecycle: switch to feature branch, rebase with main, and return a cleanup function
+ * Full phase lifecycle: switch to issue branch, rebase with main, and return a cleanup function
  * Usage:
- *   const cleanup = preparePhaseGitEnvironment(featureId, baseBranch, verbose)
+ *   const cleanup = preparePhaseGitEnvironment(issueId, baseBranch, verbose)
  *   try {
  *     // ... phase logic ...
  *   } finally {
@@ -133,15 +133,15 @@ export declare function returnToMainBranch(baseBranch?: string, verbose?: boolea
  * is in a clean state (rebase aborted). The caller should still call the cleanup function
  * in a finally block to return to the main branch.
  *
- * @param featureId - The feature ID (will be used to construct branch name "dev/{featureId}")
+ * @param issueId - The issue ID (will be used to construct branch name "dev/{issueId}")
  * @param baseBranch - The base branch to rebase from (default: "main")
  * @param verbose - Whether to log verbose output
  * @returns Cleanup function that will return to main branch
  */
-export declare function preparePhaseGitEnvironment(featureId: string, baseBranch?: string, verbose?: boolean): () => void;
+export declare function preparePhaseGitEnvironment(issueId: string, baseBranch?: string, verbose?: boolean): () => void;
 /**
  * Full phase lifecycle with custom branch names for branch chaining support.
- * This allows creating a feature branch from another feature branch (not just main).
+ * This allows creating a issue branch from another issue branch (not just main).
  *
  * Usage:
  *   const cleanup = prepareCustomBranchGitEnvironment('feat/123/2-api', 'feat/123/1-database', verbose)
@@ -151,10 +151,10 @@ export declare function preparePhaseGitEnvironment(featureId: string, baseBranch
  *     cleanup()
  *   }
  *
- * @param featureBranch - The feature branch to switch to (e.g., "feat/123/2-api")
+ * @param issueBranch - The issue branch to switch to (e.g., "feat/123/2-api")
  * @param baseBranch - The base branch to rebase from (e.g., "main" or "feat/123/1-database")
  * @param verbose - Whether to log verbose output
  * @returns Cleanup function that will return to main branch
  */
-export declare function prepareCustomBranchGitEnvironment(featureBranch: string, baseBranch?: string, verbose?: boolean): () => void;
-export { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, type RebaseWithConflictResolutionOptions, switchToFeatureBranchAndRebaseAsync, type SyncFeatBranchOptions, syncFeatBranchWithMain, } from './git-branch-manager-async.js';
+export declare function prepareCustomBranchGitEnvironment(issueBranch: string, baseBranch?: string, verbose?: boolean): () => void;
+export { prepareCustomBranchGitEnvironmentAsync, preparePhaseGitEnvironmentAsync, type RebaseWithConflictResolutionOptions, switchToIssueBranchAndRebaseAsync, type SyncFeatBranchOptions, syncFeatBranchWithMain, } from './git-branch-manager-async.js';