@akiojin/gwt 4.10.0 → 4.12.0

package/src/worktree.ts

@@ -1,12 +1,16 @@
 import { execa } from "execa";
-import fs from "node:fs/promises";
+import { lstat, mkdir, readFile, rm } from "node:fs/promises";
 import path from "node:path";
 import chalk from "chalk";
+import { createLogger } from "./logging/logger.js";
+
+const logger = createLogger({ category: "worktree" });
 import {
   WorktreeConfig,
   WorktreeWithPR,
   CleanupTarget,
   CleanupReason,
+  CleanupStatus,
 } from "./cli/ui/types.js";
 import { getPullRequestByBranch } from "./github.js";
 import {
@@ -44,6 +48,65 @@ async function getUpstreamBranch(branch: string): Promise<string | null> {
   }
 }
 
+const parseRemoteRef = (
+  ref: string,
+): { remote: string; branch: string } | null => {
+  const segments = ref.split("/");
+  if (segments.length < 2) {
+    return null;
+  }
+  const [remote, ...rest] = segments;
+  const branch = rest.join("/");
+  if (!remote || !branch) {
+    return null;
+  }
+  return { remote, branch };
+};
+
+async function resolveUpstreamStatus(
+  branch: string,
+  repoRoot: string,
+): Promise<{ upstream: string | null; hasUpstream: boolean }> {
+  const upstream = await getUpstreamBranch(branch);
+  if (!upstream) {
+    return { upstream: null, hasUpstream: false };
+  }
+  const parsed = parseRemoteRef(upstream);
+  if (!parsed) {
+    return { upstream, hasUpstream: false };
+  }
+  if (parsed.branch !== branch) {
+    return { upstream, hasUpstream: false };
+  }
+  const exists = await checkRemoteBranchExists(parsed.branch, parsed.remote, {
+    cwd: repoRoot,
+  });
+  return { upstream, hasUpstream: exists };
+}
+
+const buildCleanupReasons = ({
+  hasUniqueCommits,
+  hasUncommitted,
+  hasUnpushed,
+  hasUpstream,
+}: {
+  hasUniqueCommits: boolean;
+  hasUncommitted: boolean;
+  hasUnpushed: boolean;
+  hasUpstream: boolean;
+}): CleanupReason[] => {
+  if (!hasUpstream) {
+    return [];
+  }
+  if (!hasUniqueCommits && !hasUncommitted && !hasUnpushed) {
+    return ["no-diff-with-base"];
+  }
+  if (hasUniqueCommits && !hasUncommitted && !hasUnpushed) {
+    return ["remote-synced"];
+  }
+  return [];
+};
+
 // Re-export WorktreeConfig for external use
 export type { WorktreeConfig };
 
@@ -109,9 +172,13 @@ export interface WorktreeInfo {
   path: string;
   branch: string;
   head: string;
+  locked?: boolean;
+  prunable?: boolean;
   isAccessible?: boolean;
   invalidReason?: string;
   hasUncommittedChanges?: boolean;
+  isLocked?: boolean;
+  isPrunable?: boolean;
 }
 
 async function listWorktrees(): Promise<WorktreeInfo[]> {
@@ -131,11 +198,37 @@ async function listWorktrees(): Promise<WorktreeInfo[]> {
         if (currentWorktree.path) {
           worktrees.push(currentWorktree as WorktreeInfo);
         }
-        currentWorktree = { path: line.substring(9) };
+        currentWorktree = {
+          path: line.substring(9),
+          locked: false,
+          prunable: false,
+          isLocked: false,
+          isPrunable: false,
+        };
       } else if (line.startsWith("HEAD ")) {
         currentWorktree.head = line.substring(5);
       } else if (line.startsWith("branch ")) {
         currentWorktree.branch = line.substring(7).replace("refs/heads/", "");
+      } else if (line === "locked" || line.startsWith("locked ")) {
+        currentWorktree.locked = true;
+        currentWorktree.isLocked = true;
+        if (line.startsWith("locked ")) {
+          const reason = line.substring(7).trim();
+          if (reason) {
+            currentWorktree.invalidReason ??= reason;
+          }
+        }
+      } else if (line === "prunable" || line.startsWith("prunable ")) {
+        currentWorktree.prunable = true;
+        currentWorktree.isPrunable = true;
+        if (line.startsWith("prunable ")) {
+          const reason = line.substring(9).trim();
+          if (reason) {
+            currentWorktree.invalidReason ??= reason;
+          }
+        }
+      } else if (line.startsWith("reason ")) {
+        currentWorktree.invalidReason = line.substring(7);
       } else if (line === "") {
         if (currentWorktree.path) {
           worktrees.push(currentWorktree as WorktreeInfo);
@@ -154,6 +247,10 @@ async function listWorktrees(): Promise<WorktreeInfo[]> {
   }
 }
 
+export async function listAllWorktrees(): Promise<WorktreeInfo[]> {
+  return listWorktrees();
+}
+
 /**
  * 追加のworktree（メインworktreeを除く）の一覧を取得
  * @returns {Promise<WorktreeInfo[]>} worktree情報の配列
@@ -173,7 +270,8 @@ export async function listAdditionalWorktrees(): Promise<WorktreeInfo[]> {
       .filter((worktree) => worktree.path !== repoRoot)
       .map((worktree) => {
         // パスの存在を確認
-        const isAccessible = fs.existsSync(worktree.path);
+        const exists = fs.existsSync(worktree.path);
+        const isAccessible = exists && !worktree.prunable;
 
         const result: WorktreeInfo = {
           ...worktree,
@@ -181,7 +279,11 @@ export async function listAdditionalWorktrees(): Promise<WorktreeInfo[]> {
         };
 
         if (!isAccessible) {
-          result.invalidReason = "Path not accessible in current environment";
+          if (!exists) {
+            result.invalidReason = "Path not accessible in current environment";
+          } else if (worktree.prunable && !result.invalidReason) {
+            result.invalidReason = "Worktree is marked prunable";
+          }
         }
 
         return result;
@@ -313,9 +415,9 @@ async function assessStaleWorktreeDirectory(
     return { status: "stale", reason: "missing .git" };
   }
 
-  let gitMetaStat: Awaited<ReturnType<typeof fs.lstat>>;
+  let gitMetaStat: Awaited<ReturnType<typeof lstat>>;
   try {
-    gitMetaStat = await fs.lstat(gitMetaPath);
+    gitMetaStat = await lstat(gitMetaPath);
   } catch {
     return { status: "unknown", reason: "unable to stat .git" };
   }
@@ -330,7 +432,7 @@ async function assessStaleWorktreeDirectory(
 
   let gitMetaContents = "";
   try {
-    gitMetaContents = await fs.readFile(gitMetaPath, "utf8");
+    gitMetaContents = await readFile(gitMetaPath, "utf8");
   } catch {
     return { status: "unknown", reason: "unable to read .git" };
   }
@@ -371,7 +473,7 @@ export async function createWorktree(config: WorktreeConfig): Promise<void> {
   try {
     const staleness = await assessStaleWorktreeDirectory(config.worktreePath);
     if (staleness.status === "stale") {
-      await fs.rm(config.worktreePath, { recursive: true, force: true });
+      await rm(config.worktreePath, { recursive: true, force: true });
     } else if (staleness.status === "unknown") {
       const reason = staleness.reason ? ` (${staleness.reason})` : "";
       throw new WorktreeError(
@@ -382,7 +484,7 @@ export async function createWorktree(config: WorktreeConfig): Promise<void> {
     const worktreeParentDir = path.dirname(config.worktreePath);
 
     try {
-      await fs.mkdir(worktreeParentDir, { recursive: true });
+      await mkdir(worktreeParentDir, { recursive: true });
     } catch (error: unknown) {
       const errorWithCode = error as { code?: unknown; message?: unknown };
       const code =
@@ -536,6 +638,174 @@ export async function removeWorktree(
   }
 }
 
+export interface RepairResult {
+  repairedCount: number;
+  failedCount: number;
+  failures: Array<{ path: string; error: string }>;
+}
+
+/**
+ * Worktreeパス修復の結果
+ */
+export interface RepairPathResult {
+  /** 修復成功 (git worktree repair) */
+  repaired: boolean;
+  /** 古いメタデータ削除成功 (git worktree remove --force) */
+  removed: boolean;
+  /** 修復後の新しいパス (repaired=trueの場合のみ) */
+  newPath?: string;
+}
+
+/**
+ * 単一のworktreeパスを修復する共通関数
+ *
+ * パターンA: 期待されるパスにディレクトリが存在する
+ *   → git worktree repair <expectedPath> で修復
+ *
+ * パターンB: ディレクトリが存在しない（リモート環境で作成されたメタデータのみ残っている）
+ *   → git worktree remove --force <currentPath> でメタデータを削除
+ *
+ * @param branch ブランチ名
+ * @param currentPath 現在gitメタデータに記録されているパス
+ * @param repoRoot リポジトリルートパス
+ * @returns 修復結果
+ */
+export async function repairWorktreePath(
+  branch: string,
+  currentPath: string,
+  repoRoot: string,
+): Promise<RepairPathResult> {
+  const expectedPath = await generateWorktreePath(repoRoot, branch);
+  const fsSync = await import("node:fs");
+
+  if (fsSync.existsSync(expectedPath)) {
+    // パターンA: ディレクトリが存在する → repair
+    logger.info(
+      { branch, expectedPath, currentPath },
+      "repairWorktreePath: directory exists, attempting repair",
+    );
+    try {
+      await execa("git", ["worktree", "repair", expectedPath], {
+        cwd: repoRoot,
+      });
+      return { repaired: true, removed: false, newPath: expectedPath };
+    } catch (error) {
+      logger.warn(
+        { branch, expectedPath, error },
+        "repairWorktreePath: repair failed",
+      );
+      return { repaired: false, removed: false };
+    }
+  } else {
+    // パターンB: ディレクトリが存在しない → 古いメタデータを削除
+    logger.info(
+      { branch, currentPath, expectedPath },
+      "repairWorktreePath: directory not found, removing stale metadata",
+    );
+    try {
+      await execa("git", ["worktree", "remove", "--force", currentPath], {
+        cwd: repoRoot,
+      });
+      return { repaired: false, removed: true };
+    } catch (error) {
+      logger.warn(
+        { branch, currentPath, error },
+        "repairWorktreePath: remove failed",
+      );
+      return { repaired: false, removed: false };
+    }
+  }
+}
+
+/**
+ * Worktreeのパス不整合を修復
+ * 共通関数repairWorktreePathを使用して各ブランチを修復
+ * @param targetBranches 修復対象のブランチ名配列
+ * @returns 修復結果（成功数、失敗数、失敗詳細）
+ */
+export async function repairWorktrees(
+  targetBranches: string[],
+): Promise<RepairResult> {
+  const result: RepairResult = {
+    repairedCount: 0,
+    failedCount: 0,
+    failures: [],
+  };
+
+  if (targetBranches.length === 0) {
+    return result;
+  }
+
+  // 修復前のworktree一覧を取得（現在のパスを知るため）
+  const beforeWorktrees = await listAdditionalWorktrees();
+  const worktreePathMap = new Map(
+    beforeWorktrees.map((w) => [w.branch, w.path]),
+  );
+
+  // デバッグログ: worktreeリストのブランチ名を出力
+  logger.info(
+    {
+      targetBranches,
+      worktreeBranches: beforeWorktrees.map((w) => ({
+        branch: w.branch,
+        path: w.path,
+        isAccessible: w.isAccessible,
+      })),
+    },
+    "repairWorktrees: before state",
+  );
+
+  const repoRoot = await getRepositoryRoot();
+
+  // 対象ブランチごとに共通関数を使用して修復
+  for (const branch of targetBranches) {
+    const currentPath = worktreePathMap.get(branch);
+    if (!currentPath) {
+      logger.warn({ branch }, "repairWorktrees: branch not found in worktrees");
+      result.failedCount++;
+      result.failures.push({
+        path: branch,
+        error: "Branch not found in worktrees",
+      });
+      continue;
+    }
+
+    const repairResult = await repairWorktreePath(
+      branch,
+      currentPath,
+      repoRoot,
+    );
+
+    if (repairResult.repaired) {
+      result.repairedCount++;
+    } else if (repairResult.removed) {
+      // メタデータ削除は「修復」としてカウント（新規作成が可能になるため）
+      result.repairedCount++;
+    } else {
+      result.failedCount++;
+      result.failures.push({
+        path: branch,
+        error: "Worktree repair failed",
+      });
+    }
+  }
+
+  // 修復後のアクセス可能性を確認（デバッグログ用）
+  const afterWorktrees = await listAdditionalWorktrees();
+  logger.info(
+    {
+      afterWorktrees: afterWorktrees.map((w) => ({
+        branch: w.branch,
+        path: w.path,
+        isAccessible: w.isAccessible,
+      })),
+    },
+    "repairWorktrees: after state",
+  );
+
+  return result;
+}
+
 async function getWorktreesWithPRStatus(): Promise<WorktreeWithPR[]> {
   const worktrees = await listAdditionalWorktrees();
   const worktreesWithPR: WorktreeWithPR[] = [];
@@ -558,13 +828,15 @@ async function getWorktreesWithPRStatus(): Promise<WorktreeWithPR[]> {
  * worktreeに存在しないローカルブランチのクリーンアップ候補を取得
  * @returns {Promise<CleanupTarget[]>} クリーンアップ候補の配列
  */
-async function getOrphanedLocalBranches({
+async function getOrphanedLocalBranchStatuses({
   baseBranch,
   repoRoot,
+  onProgress,
 }: {
   baseBranch: string;
   repoRoot: string;
-}): Promise<CleanupTarget[]> {
+  onProgress?: (status: CleanupStatus) => void;
+}): Promise<CleanupStatus[]> {
   try {
     // 並列実行で高速化
     const [localBranches, worktrees] = await Promise.all([
@@ -572,7 +844,7 @@ async function getOrphanedLocalBranches({
       listAdditionalWorktrees(),
     ]);
 
-    const cleanupTargets: CleanupTarget[] = [];
+    const statuses: CleanupStatus[] = [];
     const worktreeBranches = new Set(
       worktrees.map((w) => w.branch).filter(Boolean),
     );
@@ -616,20 +888,23 @@ async function getOrphanedLocalBranches({
           hasUnpushed = true;
         }
 
-        const reasons: CleanupReason[] = [];
-
-        const upstreamBranch = await getUpstreamBranch(localBranch.name);
-        const comparisonBase = upstreamBranch ?? baseBranch;
+        const { upstream, hasUpstream } = await resolveUpstreamStatus(
+          localBranch.name,
+          repoRoot,
+        );
 
         const hasUniqueCommits = await branchHasUniqueCommitsComparedToBase(
           localBranch.name,
-          comparisonBase,
+          baseBranch,
           repoRoot,
         );
 
-        if (!hasUniqueCommits) {
-          reasons.push("no-diff-with-base");
-        }
+        const reasons = buildCleanupReasons({
+          hasUniqueCommits,
+          hasUncommitted: false,
+          hasUnpushed,
+          hasUpstream,
+        });
 
         if (process.env.DEBUG_CLEANUP) {
           console.log(
@@ -639,41 +914,30 @@ async function getOrphanedLocalBranches({
           );
         }
 
-        let hasRemoteBranch = false;
-        try {
-          hasRemoteBranch = await checkRemoteBranchExists(localBranch.name);
-        } catch {
-          hasRemoteBranch = false;
-        }
-
-        if (!hasUnpushed && hasRemoteBranch && hasUniqueCommits) {
-          reasons.push("remote-synced");
-        }
-
-        if (reasons.length > 0) {
-          cleanupTargets.push({
-            worktreePath: null, // worktreeは存在しない
-            branch: localBranch.name,
-            pullRequest: null,
-            hasUncommittedChanges: false, // worktreeが存在しないため常にfalse
-            hasUnpushedCommits: hasUnpushed,
-            cleanupType: "branch-only",
-            hasRemoteBranch,
-            reasons,
-          });
-        }
+        const status: CleanupStatus = {
+          worktreePath: null, // worktreeは存在しない
+          branch: localBranch.name,
+          hasUncommittedChanges: false, // worktreeが存在しないため常にfalse
+          hasUnpushedCommits: hasUnpushed,
+          cleanupType: "branch-only",
+          hasRemoteBranch: hasUpstream,
+          hasUniqueCommits,
+          hasUpstream,
+          upstream,
+          reasons,
+        };
+        statuses.push(status);
+        onProgress?.(status);
       }
     }
 
     if (process.env.DEBUG_CLEANUP) {
       console.log(
-        chalk.cyan(
-          `Debug: Found ${cleanupTargets.length} orphaned branch cleanup targets`,
-        ),
+        chalk.cyan(`Debug: Found ${statuses.length} orphaned branch statuses`),
       );
     }
 
-    return cleanupTargets;
+    return statuses;
   } catch (error) {
     console.error(chalk.red("Error: Failed to get orphaned local branches"));
     if (process.env.DEBUG_CLEANUP) {
@@ -683,11 +947,11 @@ async function getOrphanedLocalBranches({
   }
 }
 
-/**
- * マージ済みPRに関連するworktreeおよびローカルブランチのクリーンアップ候補を取得
- * @returns {Promise<CleanupTarget[]>} クリーンアップ候補の配列
- */
-export async function getMergedPRWorktrees(): Promise<CleanupTarget[]> {
+export async function getCleanupStatus({
+  onProgress,
+}: {
+  onProgress?: (status: CleanupStatus) => void;
+} = {}): Promise<CleanupStatus[]> {
   const [config, repoRoot, worktreesWithPR] = await Promise.all([
     getConfig(),
     getRepositoryRoot(),
@@ -695,11 +959,12 @@ export async function getMergedPRWorktrees(): Promise<CleanupTarget[]> {
   ]);
   const baseBranch = config.defaultBaseBranch || GIT_CONFIG.DEFAULT_BASE_BRANCH;
 
-  const orphanedBranches = await getOrphanedLocalBranches({
+  const orphanedStatuses = await getOrphanedLocalBranchStatuses({
     baseBranch,
     repoRoot,
+    ...(onProgress ? { onProgress } : {}),
   });
-  const cleanupTargets: CleanupTarget[] = [];
+  const statuses: CleanupStatus[] = [];
 
   if (process.env.DEBUG_CLEANUP) {
     console.log(chalk.cyan("Debug: Available worktrees:"));
@@ -709,32 +974,19 @@ export async function getMergedPRWorktrees(): Promise<CleanupTarget[]> {
   }
 
   for (const worktree of worktreesWithPR) {
-    // 保護対象ブランチはスキップ
-    if (isProtectedBranchName(worktree.branch)) {
-      if (process.env.DEBUG_CLEANUP) {
-        console.log(
-          chalk.yellow(`Debug: Skipping protected branch ${worktree.branch}`),
-        );
-      }
-      continue;
-    }
-
     if (process.env.DEBUG_CLEANUP) {
       console.log(chalk.gray(`Debug: Checking worktree ${worktree.branch}`));
     }
 
-    const cleanupReasons: CleanupReason[] = [];
-
     // worktreeパスの存在を確認
-    const fs = await import("node:fs");
-    // Some test environments mock node:fs without existsSync on the module root.
+    const fsSync = await import("node:fs");
     const existsSync =
-      typeof fs.existsSync === "function"
-        ? fs.existsSync
-        : typeof (fs as { default?: { existsSync?: unknown } }).default
+      typeof fsSync.existsSync === "function"
+        ? fsSync.existsSync
+        : typeof (fsSync as { default?: { existsSync?: unknown } }).default
               ?.existsSync === "function"
-          ? (fs as { default: { existsSync: (p: string) => boolean } }).default
-              .existsSync
+          ? (fsSync as { default: { existsSync: (p: string) => boolean } })
+              .default.existsSync
           : null;
 
     const isAccessible = existsSync ? existsSync(worktree.worktreePath) : false;
@@ -743,14 +995,12 @@ export async function getMergedPRWorktrees(): Promise<CleanupTarget[]> {
     let hasUnpushed = false;
 
     if (isAccessible) {
-      // worktreeが存在する場合のみ状態をチェック
       try {
         [hasUncommitted, hasUnpushed] = await Promise.all([
           hasUncommittedChanges(worktree.worktreePath),
           hasUnpushedCommits(worktree.worktreePath, worktree.branch),
         ]);
       } catch (error) {
-        // エラーが発生した場合はデフォルト値を使用
         if (process.env.DEBUG_CLEANUP) {
           console.log(
             chalk.yellow(
@@ -761,77 +1011,99 @@ export async function getMergedPRWorktrees(): Promise<CleanupTarget[]> {
       }
     }
 
-    let hasRemoteBranch = false;
-    try {
-      hasRemoteBranch = await checkRemoteBranchExists(worktree.branch);
-    } catch {
-      hasRemoteBranch = false;
-    }
-
-    const upstreamBranch = await getUpstreamBranch(worktree.branch);
-    const comparisonBase = upstreamBranch ?? baseBranch;
+    const { upstream, hasUpstream } = await resolveUpstreamStatus(
+      worktree.branch,
+      repoRoot,
+    );
 
     const hasUniqueCommits = await branchHasUniqueCommitsComparedToBase(
       worktree.branch,
-      comparisonBase,
+      baseBranch,
       repoRoot,
     );
 
-    // 差分がない場合はベース同等としてクリーンアップ候補
-    if (!hasUniqueCommits) {
-      cleanupReasons.push("no-diff-with-base");
-    } else if (!hasUncommitted && !hasUnpushed && hasRemoteBranch) {
-      // 未マージでも、ローカルに未コミット/未プッシュがなくリモートが最新ならローカルのみクリーンアップ許可
-      cleanupReasons.push("remote-synced");
-    }
+    const reasons = buildCleanupReasons({
+      hasUniqueCommits,
+      hasUncommitted,
+      hasUnpushed,
+      hasUpstream,
+    });
 
     if (process.env.DEBUG_CLEANUP) {
       console.log(
         chalk.gray(
-          `Debug: Cleanup reasons for ${worktree.branch}: ${cleanupReasons.length > 0 ? cleanupReasons.join(", ") : "none"}`,
+          `Debug: Cleanup reasons for ${worktree.branch}: ${reasons.length > 0 ? reasons.join(", ") : "none"}`,
         ),
       );
     }
 
-    if (cleanupReasons.length === 0) {
-      continue;
-    }
-
-    const target: CleanupTarget = {
+    const status: CleanupStatus = {
       worktreePath: worktree.worktreePath,
       branch: worktree.branch,
-      pullRequest: null,
       hasUncommittedChanges: hasUncommitted,
       hasUnpushedCommits: hasUnpushed,
       cleanupType: "worktree-and-branch",
-      hasRemoteBranch,
+      hasRemoteBranch: hasUpstream,
+      hasUniqueCommits,
+      hasUpstream,
+      upstream,
       isAccessible,
-      reasons: cleanupReasons,
+      reasons,
+      ...(isAccessible
+        ? {}
+        : { invalidReason: "Path not accessible in current environment" }),
     };
-
-    if (!isAccessible) {
-      target.invalidReason = "Path not accessible in current environment";
-    }
-
-    cleanupTargets.push(target);
+    statuses.push(status);
+    onProgress?.(status);
   }
 
-  // orphanedBranches (ローカルブランチのみの削除対象) を追加
-  cleanupTargets.push(...orphanedBranches);
+  statuses.push(...orphanedStatuses);
 
   if (process.env.DEBUG_CLEANUP) {
-    const worktreeTargets = cleanupTargets.filter(
-      (t) => t.cleanupType === "worktree-and-branch",
+    const worktreeTargets = statuses.filter(
+      (t) => t.cleanupType === "worktree-and-branch" && t.reasons.length > 0,
     ).length;
-    const branchOnlyTargets = cleanupTargets.filter(
-      (t) => t.cleanupType === "branch-only",
+    const branchOnlyTargets = statuses.filter(
+      (t) => t.cleanupType === "branch-only" && t.reasons.length > 0,
     ).length;
     console.log(
       chalk.cyan(
-        `Debug: Found ${cleanupTargets.length} cleanup targets (${worktreeTargets} worktree+branch, ${branchOnlyTargets} branch-only)`,
+        `Debug: Found ${worktreeTargets + branchOnlyTargets} cleanup targets (${worktreeTargets} worktree+branch, ${branchOnlyTargets} branch-only)`,
       ),
     );
   }
 
+  return statuses;
+}
+
+/**
+ * マージ済みPRに関連するworktreeおよびローカルブランチのクリーンアップ候補を取得
+ * @returns {Promise<CleanupTarget[]>} クリーンアップ候補の配列
+ */
+export async function getMergedPRWorktrees(): Promise<CleanupTarget[]> {
+  const statuses = await getCleanupStatus();
+  const cleanupTargets = statuses
+    .filter((status) => status.reasons.length > 0)
+    .filter((status) => !isProtectedBranchName(status.branch))
+    .map((status) => {
+      const target: CleanupTarget = {
+        worktreePath: status.worktreePath,
+        branch: status.branch,
+        pullRequest: null,
+        hasUncommittedChanges: status.hasUncommittedChanges,
+        hasUnpushedCommits: status.hasUnpushedCommits,
+        cleanupType: status.cleanupType,
+        hasRemoteBranch: status.hasRemoteBranch,
+        reasons: status.reasons,
+      };
+      if (status.isAccessible !== undefined) {
+        target.isAccessible = status.isAccessible;
+      }
+      if (status.invalidReason) {
+        target.invalidReason = status.invalidReason;
+      }
+      return target;
+    });
+
   return cleanupTargets;
 }