@iloom/cli 0.10.0 → 0.10.2

package/dist/chunk-RJ3VBUFK.js

@@ -0,0 +1,781 @@
+#!/usr/bin/env node
+import {
+  archiveRecap
+} from "./chunk-LUKXJSRI.js";
+import {
+  calculatePortFromIdentifier
+} from "./chunk-LLHXQS3C.js";
+import {
+  checkRemoteBranchStatus,
+  executeGitCommand,
+  extractIssueNumber,
+  findMainWorktreePathWithSettings,
+  findWorktreeForBranch,
+  getMergeTargetBranch,
+  hasUncommittedChanges,
+  isBranchMergedIntoMain
+} from "./chunk-4FGEGQW4.js";
+import {
+  SettingsManager
+} from "./chunk-7VHJNVLF.js";
+import {
+  MetadataManager
+} from "./chunk-KB64WNBZ.js";
+import {
+  getLogger
+} from "./chunk-6MLEBAYZ.js";
+
+// src/lib/ResourceCleanup.ts
+import path from "path";
+var ResourceCleanup = class {
+  constructor(gitWorktree, processManager, database, cliIsolation, settingsManager) {
+    this.gitWorktree = gitWorktree;
+    this.processManager = processManager;
+    this.database = database;
+    this.cliIsolation = cliIsolation;
+    this.settingsManager = settingsManager ?? new SettingsManager();
+    this.metadataManager = new MetadataManager();
+  }
+  /**
+   * Cleanup a worktree and associated resources
+   * Main orchestration method
+   *
+   * @param parsed - ParsedInput from IdentifierParser with type information
+   * @param options - Cleanup options
+   */
+  async cleanupWorktree(parsed, options = {}) {
+    var _a, _b, _c;
+    const operations = [];
+    const errors = [];
+    const displayIdentifier = parsed.branchName ?? ((_a = parsed.number) == null ? void 0 : _a.toString()) ?? parsed.originalInput;
+    getLogger().info(`Starting cleanup for: ${displayIdentifier}`);
+    const number = parsed.number;
+    if (number !== void 0) {
+      const settings = await this.settingsManager.loadSettings();
+      const basePort = ((_c = (_b = settings == null ? void 0 : settings.capabilities) == null ? void 0 : _b.web) == null ? void 0 : _c.basePort) ?? 3e3;
+      const port = calculatePortFromIdentifier(number, basePort);
+      if (options.dryRun) {
+        operations.push({
+          type: "dev-server",
+          success: true,
+          message: `[DRY RUN] Would check for dev server on port ${port}`
+        });
+      } else {
+        try {
+          const terminated = await this.terminateDevServer(port);
+          operations.push({
+            type: "dev-server",
+            success: true,
+            message: terminated ? `Dev server on port ${port} terminated` : `No dev server running on port ${port}`
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error("Unknown error");
+          errors.push(err);
+          operations.push({
+            type: "dev-server",
+            success: false,
+            message: `Failed to terminate dev server`,
+            error: err.message
+          });
+        }
+      }
+    }
+    let worktree = null;
+    try {
+      if (options.worktree) {
+        worktree = {
+          path: options.worktree.path,
+          branch: options.worktree.branch,
+          commit: "",
+          bare: false,
+          detached: false,
+          locked: false
+        };
+        getLogger().debug(`Using pre-resolved worktree: path="${worktree.path}", branch="${worktree.branch}"`);
+      } else {
+        if (parsed.type === "pr" && parsed.number !== void 0) {
+          const prNumber = typeof parsed.number === "number" ? parsed.number : Number(parsed.number);
+          if (isNaN(prNumber) || !isFinite(prNumber)) {
+            throw new Error(`Invalid PR number: ${parsed.number}. PR numbers must be numeric.`);
+          }
+          worktree = await this.gitWorktree.findWorktreeForPR(prNumber, "");
+        } else if (parsed.type === "issue" && parsed.number !== void 0) {
+          worktree = await this.gitWorktree.findWorktreeForIssue(parsed.number);
+        } else if (parsed.type === "branch" && parsed.branchName) {
+          worktree = await this.gitWorktree.findWorktreeForBranch(parsed.branchName);
+        }
+      }
+      if (!worktree) {
+        throw new Error(`No worktree found for identifier: ${displayIdentifier}`);
+      }
+      getLogger().debug(`Found worktree: path="${worktree.path}", branch="${worktree.branch}"`);
+    } catch (error) {
+      const err = error instanceof Error ? error : new Error("Unknown error");
+      errors.push(err);
+      return {
+        identifier: displayIdentifier,
+        success: false,
+        operations,
+        errors,
+        rollbackRequired: false
+      };
+    }
+    let safetyCheckPassed = false;
+    if (!options.force) {
+      const shouldCheckMergeSafety = options.checkMergeSafety ?? options.deleteBranch === true;
+      const shouldCheckRemoteBranch = options.checkRemoteBranch ?? false;
+      const safety = await this.validateWorktreeSafety(worktree, parsed.originalInput, shouldCheckMergeSafety, shouldCheckRemoteBranch);
+      if (!safety.isSafe) {
+        const blockerMessage = safety.blockers.join("\n\n");
+        throw new Error(`Cannot cleanup:
+
+${blockerMessage}`);
+      }
+      safetyCheckPassed = true;
+      if (safety.warnings.length > 0) {
+        safety.warnings.forEach((warning) => {
+          getLogger().warn(warning);
+        });
+      }
+    }
+    let databaseConfig = null;
+    if (!options.keepDatabase && worktree) {
+      const envFilePath = path.join(worktree.path, ".env");
+      try {
+        const shouldCleanup = this.database ? await this.database.shouldUseDatabaseBranching(envFilePath) : false;
+        databaseConfig = { shouldCleanup, envFilePath };
+      } catch (error) {
+        getLogger().warn(
+          `Failed to read database config from ${envFilePath}, skipping database cleanup: ${error instanceof Error ? error.message : String(error)}`
+        );
+        databaseConfig = { shouldCleanup: false, envFilePath };
+      }
+    }
+    let mainWorktreePath = null;
+    if (!options.dryRun) {
+      try {
+        mainWorktreePath = await findMainWorktreePathWithSettings(worktree.path, this.settingsManager);
+      } catch (error) {
+        getLogger().warn(
+          `Failed to find main worktree path: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    let mergeTargetBranch = null;
+    if (options.deleteBranch && worktree && !options.dryRun) {
+      try {
+        mergeTargetBranch = await getMergeTargetBranch(worktree.path, {
+          settingsManager: this.settingsManager,
+          metadataManager: this.metadataManager
+        });
+        getLogger().debug(`Pre-fetched merge target branch: ${mergeTargetBranch}`);
+      } catch (error) {
+        getLogger().warn(
+          `Failed to pre-fetch merge target branch: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    if (options.dryRun) {
+      operations.push({
+        type: "worktree",
+        success: true,
+        message: `[DRY RUN] Would remove worktree: ${worktree.path}`
+      });
+    } else {
+      try {
+        const worktreeOptions = {
+          removeDirectory: true,
+          removeBranch: false
+          // Handle branch separately
+        };
+        if (options.force !== void 0) {
+          worktreeOptions.force = options.force;
+        }
+        await this.gitWorktree.removeWorktree(worktree.path, worktreeOptions);
+        operations.push({
+          type: "worktree",
+          success: true,
+          message: `Worktree removed: ${worktree.path}`
+        });
+      } catch (error) {
+        const err = error instanceof Error ? error : new Error("Unknown error");
+        errors.push(err);
+        operations.push({
+          type: "worktree",
+          success: false,
+          message: `Failed to remove worktree`,
+          error: err.message
+        });
+      }
+    }
+    if (worktree) {
+      if (options.dryRun) {
+        operations.push({
+          type: "recap",
+          success: true,
+          message: `[DRY RUN] Would archive recap file for: ${worktree.path}`
+        });
+      } else {
+        try {
+          await archiveRecap(worktree.path);
+          operations.push({
+            type: "recap",
+            success: true,
+            message: `Recap file archived`
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error("Unknown error");
+          getLogger().warn(`Recap archival failed: ${err.message}`);
+          operations.push({
+            type: "recap",
+            success: false,
+            message: "Recap archival failed (non-fatal)",
+            error: err.message
+          });
+        }
+      }
+    }
+    if (options.deleteBranch && worktree) {
+      if (options.dryRun) {
+        operations.push({
+          type: "branch",
+          success: true,
+          message: `[DRY RUN] Would delete branch: ${worktree.branch}`
+        });
+      } else {
+        try {
+          const branchOptions = {
+            dryRun: false,
+            safetyVerified: safetyCheckPassed
+          };
+          if (mergeTargetBranch !== null) {
+            branchOptions.mergeTargetBranch = mergeTargetBranch;
+          }
+          if (options.force !== void 0) {
+            branchOptions.force = options.force;
+          }
+          await this.deleteBranch(worktree.branch, branchOptions, mainWorktreePath ?? void 0);
+          operations.push({
+            type: "branch",
+            success: true,
+            message: `Branch deleted: ${worktree.branch}`
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error("Unknown error");
+          errors.push(err);
+          operations.push({
+            type: "branch",
+            success: false,
+            message: `Failed to delete branch`,
+            error: err.message
+          });
+        }
+      }
+    }
+    const cliIdentifier = parsed.number ?? parsed.branchName;
+    if (this.cliIsolation && cliIdentifier !== void 0) {
+      if (options.dryRun) {
+        operations.push({
+          type: "cli-symlinks",
+          success: true,
+          message: `[DRY RUN] Would cleanup CLI symlinks for: ${cliIdentifier}`
+        });
+      } else {
+        try {
+          const removed = await this.cliIsolation.cleanupVersionedExecutables(cliIdentifier);
+          operations.push({
+            type: "cli-symlinks",
+            success: true,
+            message: removed.length > 0 ? `CLI symlinks removed: ${removed.length}` : "No CLI symlinks to cleanup"
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error("Unknown error");
+          errors.push(err);
+          getLogger().warn(
+            `CLI symlink cleanup failed: ${err.message}`
+          );
+          operations.push({
+            type: "cli-symlinks",
+            success: false,
+            message: "CLI symlink cleanup failed (non-fatal)"
+          });
+        }
+      }
+    }
+    if (databaseConfig && worktree) {
+      if (options.dryRun) {
+        operations.push({
+          type: "database",
+          success: true,
+          message: `[DRY RUN] Would cleanup database branch for: ${worktree.branch}`
+        });
+      } else {
+        try {
+          if (databaseConfig.shouldCleanup && this.database) {
+            try {
+              const deletionResult = await this.database.deleteBranchIfConfigured(
+                worktree.branch,
+                databaseConfig.shouldCleanup,
+                false,
+                // isPreview
+                mainWorktreePath ?? void 0
+              );
+              if (deletionResult.deleted) {
+                getLogger().info(`Database branch deleted: ${worktree.branch}`);
+                operations.push({
+                  type: "database",
+                  success: true,
+                  message: `Database branch deleted`,
+                  deleted: true
+                });
+              } else if (deletionResult.notFound) {
+                getLogger().debug(`No database branch found for: ${worktree.branch}`);
+                operations.push({
+                  type: "database",
+                  success: true,
+                  message: `No database branch found (skipped)`,
+                  deleted: false
+                });
+              } else if (deletionResult.userDeclined) {
+                getLogger().info("Preview database deletion declined by user");
+                operations.push({
+                  type: "database",
+                  success: true,
+                  message: `Database cleanup skipped (user declined)`,
+                  deleted: false
+                });
+              } else if (!deletionResult.success) {
+                const errorMsg = deletionResult.error ?? "Unknown error";
+                errors.push(new Error(errorMsg));
+                getLogger().warn(`Database cleanup failed: ${errorMsg}`);
+                operations.push({
+                  type: "database",
+                  success: false,
+                  // Non-fatal, but report error
+                  message: `Database cleanup failed`,
+                  error: errorMsg,
+                  deleted: false
+                });
+              } else {
+                errors.push(new Error("Database cleanup in an unknown state"));
+                getLogger().warn("Database deletion returned unexpected result state");
+                operations.push({
+                  type: "database",
+                  success: false,
+                  message: `Database cleanup in an unknown state`,
+                  deleted: false
+                });
+              }
+            } catch (error) {
+              errors.push(error instanceof Error ? error : new Error(String(error)));
+              getLogger().warn(
+                `Unexpected database cleanup exception: ${error instanceof Error ? error.message : String(error)}`
+              );
+              operations.push({
+                type: "database",
+                success: false,
+                message: `Database cleanup failed`,
+                error: error instanceof Error ? error.message : String(error),
+                deleted: false
+              });
+            }
+          } else {
+            operations.push({
+              type: "database",
+              success: true,
+              message: `Database cleanup skipped (not available)`,
+              deleted: false
+            });
+          }
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error("Unknown error");
+          errors.push(err);
+          operations.push({
+            type: "database",
+            success: false,
+            message: `Database cleanup failed`,
+            error: err.message,
+            deleted: false
+          });
+        }
+      }
+    }
+    if (worktree) {
+      if (options.dryRun) {
+        const action = options.archive ? "archive" : "delete";
+        operations.push({
+          type: "metadata",
+          success: true,
+          message: `[DRY RUN] Would ${action} metadata for worktree: ${worktree.path}`
+        });
+      } else if (options.archive) {
+        try {
+          await this.metadataManager.archiveMetadata(worktree.path);
+          getLogger().info(`Metadata archived for worktree: ${worktree.path}`);
+          operations.push({
+            type: "metadata",
+            success: true,
+            message: "Metadata archived"
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          errors.push(err);
+          getLogger().warn(`Metadata archival failed: ${err.message}`);
+          operations.push({
+            type: "metadata",
+            success: false,
+            message: "Metadata archival failed (non-fatal)",
+            error: err.message
+          });
+        }
+      } else {
+        try {
+          await this.metadataManager.deleteMetadata(worktree.path);
+          getLogger().info(`Metadata deleted for worktree: ${worktree.path}`);
+          operations.push({
+            type: "metadata",
+            success: true,
+            message: "Metadata deleted"
+          });
+        } catch (error) {
+          const err = error instanceof Error ? error : new Error(String(error));
+          errors.push(err);
+          getLogger().warn(`Metadata deletion failed: ${err.message}`);
+          operations.push({
+            type: "metadata",
+            success: false,
+            message: "Metadata deletion failed (non-fatal)",
+            error: err.message
+          });
+        }
+      }
+    }
+    const success = errors.length === 0;
+    return {
+      identifier: displayIdentifier,
+      branchName: worktree == null ? void 0 : worktree.branch,
+      success,
+      operations,
+      errors,
+      rollbackRequired: false
+      // Cleanup operations are generally not reversible
+    };
+  }
+  /**
+   * Terminate dev server on specified port
+   */
+  async terminateDevServer(port) {
+    getLogger().debug(`Checking for dev server on port ${port}`);
+    const processInfo = await this.processManager.detectDevServer(port);
+    if (!processInfo) {
+      getLogger().debug(`No process found on port ${port}`);
+      return false;
+    }
+    if (!processInfo.isDevServer) {
+      getLogger().warn(
+        `Process on port ${port} (${processInfo.name}) doesn't appear to be a dev server, skipping`
+      );
+      return false;
+    }
+    getLogger().info(`Terminating dev server: ${processInfo.name} (PID: ${processInfo.pid})`);
+    await this.processManager.terminateProcess(processInfo.pid);
+    const isFree = await this.processManager.verifyPortFree(port);
+    if (!isFree) {
+      throw new Error(`Dev server may still be running on port ${port}`);
+    }
+    return true;
+  }
+  /**
+   * Delete a Git branch with safety checks
+   *
+   * @param branchName - Name of the branch to delete
+   * @param options - Delete options (force, dryRun)
+   * @param cwd - Working directory to execute git command from (defaults to finding main worktree)
+   */
+  async deleteBranch(branchName, options = {}, cwd) {
+    const protectedBranches = await this.settingsManager.getProtectedBranches(cwd);
+    if (protectedBranches.includes(branchName)) {
+      throw new Error(`Cannot delete protected branch: ${branchName}`);
+    }
+    const workingDir = cwd ?? await findMainWorktreePathWithSettings(void 0, this.settingsManager);
+    try {
+      await executeGitCommand(["rev-parse", "--verify", `refs/heads/${branchName}`], {
+        cwd: workingDir
+      });
+    } catch {
+      getLogger().debug(`Branch ${branchName} does not exist, skipping deletion`);
+      return true;
+    }
+    if (options.dryRun) {
+      getLogger().info(`[DRY RUN] Would delete branch: ${branchName}`);
+      return true;
+    }
+    let deleteCwd = workingDir;
+    try {
+      let deleteFlag = "-d";
+      if (options.force) {
+        deleteFlag = "-D";
+      } else if (options.mergeTargetBranch) {
+        const mergeTarget = options.mergeTargetBranch;
+        try {
+          const targetWorktreePath = await findWorktreeForBranch(mergeTarget, workingDir);
+          getLogger().debug(`Running branch delete from worktree where '${mergeTarget}' is checked out: ${targetWorktreePath}`);
+          deleteCwd = targetWorktreePath;
+        } catch {
+          getLogger().debug(`Could not find worktree for branch '${mergeTarget}', falling back to merge check`);
+          const isMerged = await isBranchMergedIntoMain(branchName, mergeTarget, workingDir);
+          if (isMerged) {
+            getLogger().debug(`Branch '${branchName}' verified merged into '${mergeTarget}', using force delete`);
+            deleteFlag = "-D";
+          }
+        }
+      } else if (options.worktreePath) {
+        getLogger().warn("deleteBranch called with worktreePath but no mergeTargetBranch - this may fail if worktree was deleted");
+        try {
+          const mergeTarget = await getMergeTargetBranch(options.worktreePath, {
+            settingsManager: this.settingsManager,
+            metadataManager: this.metadataManager
+          });
+          try {
+            const targetWorktreePath = await findWorktreeForBranch(mergeTarget, workingDir);
+            getLogger().debug(`Running branch delete from worktree where '${mergeTarget}' is checked out: ${targetWorktreePath}`);
+            deleteCwd = targetWorktreePath;
+          } catch {
+            getLogger().debug(`Could not find worktree for branch '${mergeTarget}', falling back to merge check`);
+            const isMerged = await isBranchMergedIntoMain(branchName, mergeTarget, workingDir);
+            if (isMerged) {
+              getLogger().debug(`Branch '${branchName}' verified merged into '${mergeTarget}', using force delete`);
+              deleteFlag = "-D";
+            }
+          }
+        } catch (error) {
+          getLogger().debug(`Could not read merge target from worktreePath: ${error instanceof Error ? error.message : String(error)}`);
+        }
+      }
+      await executeGitCommand(["branch", deleteFlag, branchName], {
+        cwd: deleteCwd
+      });
+      getLogger().info(`Branch deleted: ${branchName}`);
+      return true;
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("not found") || errorMessage.includes("does not exist")) {
+        getLogger().debug(`Branch ${branchName} already deleted`);
+        return true;
+      }
+      if (options.force) {
+        throw error;
+      }
+      if (errorMessage.includes("not fully merged")) {
+        if (options.safetyVerified) {
+          getLogger().info(`Branch '${branchName}' not merged into HEAD but safety verified - using force delete`);
+          await executeGitCommand(["branch", "-D", branchName], { cwd: deleteCwd });
+          getLogger().info(`Branch deleted: ${branchName}`);
+          return true;
+        }
+        throw new Error(
+          `Cannot delete unmerged branch '${branchName}'. Use --force to delete anyway.`
+        );
+      }
+      throw error;
+    }
+  }
+  /**
+   * Cleanup database branch
+   * Gracefully handles missing DatabaseManager
+   *
+   * @deprecated This method is deprecated and should not be used for post-deletion cleanup.
+   * Use the pre-fetch mechanism in cleanupWorktree() instead.
+   * This method will fail if called after worktree deletion because
+   * it attempts to read the .env file which has been deleted.
+   *
+   * @param branchName - Name of the branch to delete
+   * @param worktreePath - Path to worktree (must still exist with .env file)
+   */
+  async cleanupDatabase(branchName, worktreePath) {
+    if (!this.database) {
+      getLogger().debug("Database manager not available, skipping database cleanup");
+      return false;
+    }
+    try {
+      const envFilePath = path.join(worktreePath, ".env");
+      const shouldCleanup = await this.database.shouldUseDatabaseBranching(envFilePath);
+      let cwd;
+      try {
+        cwd = await findMainWorktreePathWithSettings(worktreePath, this.settingsManager);
+      } catch (error) {
+        getLogger().debug(
+          `Could not find main worktree path, using current directory: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+      const result = await this.database.deleteBranchIfConfigured(
+        branchName,
+        shouldCleanup,
+        false,
+        // isPreview
+        cwd
+      );
+      if (result.deleted) {
+        getLogger().info(`Database branch deleted: ${branchName}`);
+        return true;
+      } else if (result.notFound) {
+        getLogger().debug(`No database branch found for: ${branchName}`);
+        return false;
+      } else if (result.userDeclined) {
+        getLogger().info("Preview database deletion declined by user");
+        return false;
+      } else if (!result.success) {
+        getLogger().warn(`Database cleanup failed: ${result.error ?? "Unknown error"}`);
+        return false;
+      } else {
+        getLogger().debug("Database deletion returned unexpected result");
+        return false;
+      }
+    } catch (error) {
+      getLogger().warn(
+        `Unexpected database cleanup error: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return false;
+    }
+  }
+  /**
+   * Cleanup multiple worktrees
+   */
+  async cleanupMultipleWorktrees(identifiers, options = {}) {
+    const results = [];
+    for (const identifier of identifiers) {
+      const parsed = this.parseIdentifier(identifier);
+      const result = await this.cleanupWorktree(parsed, options);
+      results.push(result);
+    }
+    return results;
+  }
+  /**
+   * Validate worktree safety given a worktree object
+   * Private method used internally when worktree is already known
+   *
+   * @param worktree - The worktree to validate
+   * @param identifier - The original identifier used (for error messages)
+   * @param checkBranchMerge - Whether to check if branch is merged into main (for branch deletion)
+   * @param checkRemoteBranch - Whether to check if branch exists on remote (for GitHub-PR mode)
+   */
+  async validateWorktreeSafety(worktree, identifier, checkBranchMerge = false, checkRemoteBranch = false) {
+    const warnings = [];
+    const blockers = [];
+    const isMain = await this.gitWorktree.isMainWorktree(worktree, this.settingsManager);
+    if (isMain) {
+      blockers.push(`Cannot cleanup main worktree: "${worktree.branch}" @ "${worktree.path}"`);
+    }
+    const hasChanges = await hasUncommittedChanges(worktree.path);
+    if (hasChanges) {
+      const blockerMessage = `Worktree has uncommitted changes.
+
+Please resolve before cleanup - you have some options:
+  \u2022 Commit changes: cd ${worktree.path} && git commit -am "message"
+  \u2022 Stash changes: cd ${worktree.path} && git stash
+  \u2022 Force cleanup: il cleanup ${identifier} --force (WARNING: will discard changes)`;
+      blockers.push(blockerMessage);
+    }
+    if ((checkBranchMerge || checkRemoteBranch) && worktree.branch) {
+      const mainBranch = await getMergeTargetBranch(worktree.path, {
+        settingsManager: this.settingsManager,
+        metadataManager: this.metadataManager
+      });
+      const remoteStatus = await checkRemoteBranchStatus(worktree.branch, worktree.path);
+      if (remoteStatus.networkError) {
+        const blockerMessage = `Cannot verify remote branch status due to network error.
+
+Error: ${remoteStatus.errorMessage ?? "Unknown network error"}
+
+Unable to determine if branch '${worktree.branch}' is safely backed up.
+Use --force to proceed without verification.`;
+        blockers.push(blockerMessage);
+      } else if (remoteStatus.exists && remoteStatus.localAhead) {
+        const blockerMessage = `Branch '${worktree.branch}' has unpushed commits that would be lost.
+The remote branch exists but your local branch is ahead.
+
+Please resolve before cleanup:
+  \u2022 Push your commits: git push origin ${worktree.branch}
+  \u2022 Force cleanup: il cleanup ${identifier} --force (WARNING: will lose commits)`;
+        blockers.push(blockerMessage);
+      } else if (remoteStatus.exists && !remoteStatus.localAhead) {
+      } else if (!remoteStatus.exists) {
+        const isMerged = await isBranchMergedIntoMain(worktree.branch, mainBranch, worktree.path);
+        if (isMerged) {
+        } else {
+          const blockerMessage = `Branch '${worktree.branch}' has not been pushed to remote and is not merged into '${mainBranch}'.
+Deleting this branch would result in data loss.
+
+Please resolve before cleanup - you have some options:
+  \u2022 Push to remote: git push -u origin ${worktree.branch}
+  \u2022 Merge to ${mainBranch}: git checkout ${mainBranch} && git merge ${worktree.branch}
+  \u2022 Force cleanup: il cleanup ${identifier} --force (WARNING: will lose commits)`;
+          blockers.push(blockerMessage);
+        }
+      }
+    }
+    return {
+      isSafe: blockers.length === 0,
+      warnings,
+      blockers
+    };
+  }
+  /**
+   * Validate cleanup safety
+   */
+  async validateCleanupSafety(identifier) {
+    const warnings = [];
+    const blockers = [];
+    const worktrees = await this.gitWorktree.findWorktreesByIdentifier(identifier);
+    if (worktrees.length === 0) {
+      blockers.push(`No worktree found for: ${identifier}`);
+      return { isSafe: false, warnings, blockers };
+    }
+    const worktree = worktrees[0];
+    if (!worktree) {
+      blockers.push(`No worktree found for: ${identifier}`);
+      return { isSafe: false, warnings, blockers };
+    }
+    return await this.validateWorktreeSafety(worktree, identifier);
+  }
+  /**
+   * Parse identifier to determine type and extract number
+   * Helper method for port calculation
+   */
+  parseIdentifier(identifier) {
+    const issueId = extractIssueNumber(identifier);
+    if (issueId !== null) {
+      return {
+        type: "issue",
+        number: issueId,
+        originalInput: identifier
+      };
+    }
+    const prMatch = identifier.match(/(?:pr|PR)[/-](\d+)/);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      return {
+        type: "pr",
+        number: parseInt(prMatch[1], 10),
+        originalInput: identifier
+      };
+    }
+    const numericMatch = identifier.match(/^#?(\d+)$/);
+    if (numericMatch == null ? void 0 : numericMatch[1]) {
+      return {
+        type: "issue",
+        number: parseInt(numericMatch[1], 10),
+        originalInput: identifier
+      };
+    }
+    return {
+      type: "branch",
+      branchName: identifier,
+      originalInput: identifier
+    };
+  }
+};
+
+export {
+  ResourceCleanup
+};
+//# sourceMappingURL=chunk-RJ3VBUFK.js.map