Update createBranch method to return IGitRef object, enable temp worktree service, improve branch checkout handling, and refactor configuration management

Author: zaknafeyn

.gitignore

@@ -12,3 +12,5 @@ coverage/
 post-log.json
 *.tsbuildinfo
 TODO*
+
+*.log

package.json

@@ -173,13 +173,12 @@
         "git-smart-checkout.showStatusBar": {
           "type": "boolean",
           "default": true,
-          "description": "Show or hide the extension's status bar item"
+          "description": "Show the extension's status bar item"
         },
         "git-smart-checkout.useInPlaceCherryPick": {
           "type": "boolean",
           "default": true,
-          "description": "(READONLY!) Use in-place cherry-pick instead of temporary worktree for PR cloning",
-          "scope": "machine"
+          "description": "Use in-place cherry-pick instead of temporary worktree for PR cloning (this method doesn't allow to solve conflicts, so use when completely sure that there will be no conflicts during cherry pick"
         }
       }
     }

src/commands/checkoutToCommand/index.ts

@@ -9,6 +9,7 @@ import {
   getRefLabel,
   ICON_BRANCH,
   ICON_PLUS,
+  ICON_REMOTE_BRANCH,
 } from '../utils/refFormatting';
 import { getMergedBranchLists } from '../utils/getMergedBranchLists';
 import {
@@ -176,18 +177,33 @@ export class CheckoutToCommand extends BaseCommand {
     };
   }
 
-  async getTargetBranch(git: GitExecutor, selection: string, branchList: IGitRef[]) {
+  async getTargetBranch(
+    git: GitExecutor,
+    selection: string,
+    branchList: IGitRef[]
+  ): Promise<IGitRef> {
+    const iconsToRemove = [ICON_BRANCH, ICON_REMOTE_BRANCH];
+
     switch (true) {
       case selection === LABEL_CREATE_NEW_BRANCH:
         return await this.createNewBranch(git);
       case selection === LABEL_CREATE_NEW_BRANCH_FROM:
         return await this.createNewBranchFrom(git, branchList);
       default:
-        return selection.replace(`${ICON_BRANCH} `, '');
+        const branchName = iconsToRemove.reduce(
+          (prev, icon) => prev.replace(`${icon} `, ''),
+          selection
+        );
+        const branch = branchList.find((ref) => ref.fullName === branchName);
+        if (!branch) {
+          throw new Error(`Cannot find appropriate object for a ref ${branchName}`);
+        }
+
+        return branch;
     }
   }
 
-  async createNewBranch(git: GitExecutor) {
+  async createNewBranch(git: GitExecutor): Promise<IGitRef> {
     const newBranchName = await vscode.window.showInputBox({
       placeHolder: 'Branch name',
       prompt: 'Please provide a new branch name',
@@ -198,8 +214,8 @@ export class CheckoutToCommand extends BaseCommand {
     }
 
     try {
-      await git.createBranch(newBranchName);
-      return newBranchName;
+      const newBranch = await git.createBranch(newBranchName);
+      return newBranch;
     } catch (e) {
       await vscode.window.showErrorMessage('Failed to create the new branch.', 'OK');
       throw new Error('Failed to create the new branch.');
@@ -227,9 +243,8 @@ export class CheckoutToCommand extends BaseCommand {
     }
 
     try {
-      await git.createBranch(newBranchName, baseBranchName);
-
-      return newBranchName;
+      const newBranch = await git.createBranch(newBranchName, baseBranchName);
+      return newBranch;
     } catch (e) {
       throw new Error('Failed to create the new branch.');
     }
@@ -286,30 +301,36 @@ export class CheckoutToCommand extends BaseCommand {
   async checkoutAndStashChanges(
     git: GitExecutor,
     currentBranch: string,
-    newBranch: string,
+    newBranch: IGitRef,
     autoStashMode: TAutoStashMode = AUTO_STASH_CURRENT_BRANCH
   ) {
+    const newBranchName = newBranch.name;
     const isWorkdirHasChanges = await git.isWorkdirHasChanges();
     switch (autoStashMode) {
       case AUTO_STASH_CURRENT_BRANCH:
-        await this.doAutoStashCurrentBranch(git, currentBranch, newBranch, isWorkdirHasChanges);
+        await this.doAutoStashCurrentBranch(git, currentBranch, newBranchName, isWorkdirHasChanges);
         break;
       case AUTO_STASH_AND_POP_IN_NEW_BRANCH:
-        await this.doAutoStashAndPopInNewBranch(git, currentBranch, newBranch, isWorkdirHasChanges);
+        await this.doAutoStashAndPopInNewBranch(
+          git,
+          currentBranch,
+          newBranchName,
+          isWorkdirHasChanges
+        );
         break;
       case AUTO_STASH_AND_APPLY_IN_NEW_BRANCH:
         await this.doAutoStashAndPopInNewBranch(
           git,
           currentBranch,
-          newBranch,
+          newBranchName,
           isWorkdirHasChanges,
           true
         );
         break;
       case AUTO_STASH_IGNORE:
       default:
         try {
-          await git.checkout(newBranch);
+          await git.checkout(newBranchName);
         } catch (e) {
           throw new Error('Failed to checkout the selected branch.');
         }

src/common/git/gitExecutor.ts

@@ -51,17 +51,26 @@ export class GitExecutor {
   }
 
   async #checkLocalBranchExists(branchName: string): Promise<boolean> {
+    const command = `git show-ref --verify --quiet refs/heads/${branchName}`;
+
     try {
-      await this.#execGitCommand(`git show-ref --verify --quiet refs/heads/${branchName}`);
+      await this.#execGitCommand(command);
+
       return true;
     } catch {
       return false;
     }
   }
 
-  async #checkRemoteBranchExists(branchName: string): Promise<boolean> {
+  async #checkRemoteBranchExists(
+    branchName: string,
+    includeRemoteName = false,
+    remoteName = 'origin'
+  ): Promise<boolean> {
+    const command = `git show-ref --verify --quiet refs/remotes${includeRemoteName ? `/${remoteName}` : ''}/${branchName}`;
+
     try {
-      await this.#execGitCommand(`git show-ref --verify --quiet refs/remotes/origin/${branchName}`);
+      await this.#execGitCommand(command);
       return true;
     } catch {
       return false;
@@ -105,14 +114,14 @@ export class GitExecutor {
     return branchName;
   }
 
-  async checkout(branchName: string) {
+  async checkout(branchName: string, remoteName = 'origin') {
     // Check if it's a remote branch that doesn't have a local counterpart
     const localBranchExists = await this.#checkLocalBranchExists(branchName);
     const remoteBranchExists = await this.#checkRemoteBranchExists(branchName);
 
     if (!localBranchExists && remoteBranchExists) {
       // Create a local tracked branch for the remote branch
-      const command = `git checkout -b ${branchName} origin/${branchName}`;
+      const command = `git checkout -b ${branchName} ${remoteName}/${branchName}`;
       const { stdout } = await this.#execGitCommand(command);
       return stdout;
     } else {
@@ -134,12 +143,29 @@ export class GitExecutor {
     return stdout;
   }
 
-  async createBranch(branchName: string, sourceBranch: string | undefined = undefined) {
+  async createBranch(
+    branchName: string,
+    sourceBranch: string | undefined = undefined
+  ): Promise<IGitRef> {
     const command = `git checkout -b ${branchName} ${sourceBranch ? sourceBranch : ''}`;
 
-    const { stdout } = await this.#execGitCommand(command);
+    await this.#execGitCommand(command);
 
-    return stdout;
+    // Get detailed information about the newly created branch
+    const SEPARATOR = '|';
+    const branchInfoCommand = `git for-each-ref --format="%(refname)${SEPARATOR}%(objectname:short)${SEPARATOR}%(committerdate:unix)${SEPARATOR}%(subject)${SEPARATOR}%(authorname)" refs/heads/${branchName}`;
+    const { stdout: branchInfo } = await this.#execGitCommand(branchInfoCommand);
+
+    const [, hash, committerDate, comment, authorName] = branchInfo.trim().split(SEPARATOR);
+
+    return {
+      name: branchName,
+      fullName: branchName,
+      hash,
+      comment,
+      authorName,
+      committerDate,
+    };
   }
 
   async createStash(stashName: string, include: 'all' | 'untracked' | 'none' = 'untracked') {
@@ -431,21 +457,11 @@ export class GitExecutor {
   }
 
   async branchExist(branchName: string) {
-    const command = `git show-ref --verify --quiet refs/heads/${branchName}`;
-    const commandRemote = `git show-ref --verify --quiet refs/remotes/origin/${branchName}`;
-
-    try {
-      await this.#execGitCommand(command);
+    if (await this.#checkLocalBranchExists(branchName)) {
       return true;
-    } catch (error) {
-      //verify remote branch
-      try {
-        await this.#execGitCommand(commandRemote);
-        return true;
-      } catch {
-        return false;
-      }
     }
+
+    return await this.#checkRemoteBranchExists(branchName);
   }
 
   async pushBranchToGitHub(branchName: string): Promise<void> {

src/configuration/configurationManager.ts

@@ -14,9 +14,7 @@ export class ConfigurationManager {
       showStatusBar: vscodeConfig.get('showStatusBar', true),
       defaultTargetBranch: vscodeConfig.get('defaultTargetBranch', 'main'),
       prBranchPrefix: vscodeConfig.get('prBranchPrefix', ''),
-      // todo: update when tem dir cherry pick service is ready
-      useInPlaceCherryPick: true,
-      // useInPlaceCherryPick: vscodeConfig.get('useInPlaceCherryPick', true),
+      useInPlaceCherryPick: vscodeConfig.get('useInPlaceCherryPick', true),
       logging: {
         enabled: vscodeConfig.get('logging.enabled', true),
       },
@@ -32,9 +30,7 @@ export class ConfigurationManager {
       showStatusBar: vscodeConfig.get('showStatusBar', true),
       defaultTargetBranch: vscodeConfig.get('defaultTargetBranch', 'main'),
       prBranchPrefix: vscodeConfig.get('prBranchPrefix', ''),
-      // todo: update when tem dir cherry pick service is ready
-      useInPlaceCherryPick: true,
-      // useInPlaceCherryPick: vscodeConfig.get('useInPlaceCherryPick', true),
+      useInPlaceCherryPick: vscodeConfig.get('useInPlaceCherryPick', true),
       logging: {
         enabled: vscodeConfig.get('logging.enabled', true),
       },

src/services/prCloneInPlaceService.ts

@@ -264,6 +264,11 @@ export class PrCloneInPlaceService extends PrCloneServiceBase {
     }
   }
 
+  dispose() {
+    this.cleanUpActionEnd = [];
+    this.cleanUpActionBegin = [];
+  }
+
   private async createGitHubPR(
     originalPr: GitHubPR,
     featureBranch: string,
@@ -274,8 +279,8 @@ export class PrCloneInPlaceService extends PrCloneServiceBase {
     const prBody = description;
 
     // Extract labels and assignees from original PR
-    const labels = originalPr.labels?.map(label => label.name) || [];
-    const assignees = originalPr.assignees?.map(assignee => assignee.login) || [];
+    const labels = originalPr.labels?.map((label) => label.name) || [];
+    const assignees = originalPr.assignees?.map((assignee) => assignee.login) || [];
 
     // Create PR using the GitHub API
     const newPr = await this.ghClient.createPullRequest(

src/services/prCloneService.ts

@@ -8,6 +8,7 @@ import { ConfigurationManager } from '../configuration/configurationManager';
 // import { PrCloneTempWorktreeService } from './prCloneTempWorktreeService';
 import { PrCloneInPlaceService } from './prCloneInPlaceService';
 import { setContextIsCloning } from '../utils/setContext';
+import { PrCloneTempWorktreeService } from './prCloneTempWorktreeService';
 
 export interface PrCloneData {
   prData: GitHubPR;
@@ -24,8 +25,7 @@ export interface ICleanUpActions {
 }
 
 export class PrCloneService {
-  // todo: uncomment when PrCloneTempWorktreeService is ready
-  // private _tempWorktreeService?: PrCloneTempWorktreeService;
+  private _tempWorktreeService?: PrCloneTempWorktreeService;
   private _inPlaceService?: PrCloneInPlaceService;
   private _git?: GitExecutor;
   private _ghClient?: GitHubClient;
@@ -44,13 +44,13 @@ export class PrCloneService {
     return this._isInited;
   }
 
-  // get TempWorktreeService(): PrCloneTempWorktreeService {
-  //   if (!this.isInited || !this._tempWorktreeService) {
-  //     throw new Error(`Getter "TempWorktreeService" is not initialized`);
-  //   }
+  get TempWorktreeService(): PrCloneTempWorktreeService {
+    if (!this.isInited || !this._tempWorktreeService) {
+      throw new Error(`Getter "TempWorktreeService" is not initialized`);
+    }
 
-  //   return this._tempWorktreeService;
-  // }
+    return this._tempWorktreeService;
+  }
 
   get InPlaceService(): PrCloneInPlaceService {
     if (!this.isInited || !this._inPlaceService) {
@@ -84,11 +84,11 @@ export class PrCloneService {
       this._git = git;
       this._ghClient = ghClient;
 
-      // this._tempWorktreeService = new PrCloneTempWorktreeService(
-      //   this.git,
-      //   this.ghClient,
-      //   this.loggingService
-      // );
+      this._tempWorktreeService = new PrCloneTempWorktreeService(
+        this.git,
+        this.ghClient,
+        this.loggingService
+      );
 
       this._inPlaceService = new PrCloneInPlaceService(
         this.git,
@@ -104,11 +104,9 @@ export class PrCloneService {
     setContextIsCloning(true);
 
     if (config.useInPlaceCherryPick) {
-      // todo: remove inPlaceService and clean up class
-      // await this.inPlaceService.clonePR(data);
       await this.InPlaceService.clonePR(data);
     } else {
-      // await this.TempWorktreeService.clonePR(data);
+      await this.TempWorktreeService.clonePR(data);
     }
   }
 
@@ -118,8 +116,7 @@ export class PrCloneService {
     if (config.useInPlaceCherryPick) {
       await this.InPlaceService.cherryPickNext(isContinue);
     } else {
-      // todo: add cherryPickNext to temp workdir flow
-      // await this.TempWorktreeService.clonePR(data);
+      await this.TempWorktreeService.cherryPickNext();
     }
   }
 
@@ -133,13 +130,15 @@ export class PrCloneService {
 
   addCleanUpActions(cleanUpActions: ICleanUpActions) {
     this.InPlaceService.addCleanUpActions(cleanUpActions);
+    this.TempWorktreeService.addCleanUpActions(cleanUpActions);
   }
 
   dispose(): void {
     if (!this.init) {
       return;
     }
 
-    // this.TempWorktreeService.dispose();
+    this.TempWorktreeService.dispose();
+    this.TempWorktreeService.dispose();
   }
 }