@iloom/cli 0.10.0 → 0.10.2

package/dist/{chunk-UD3WJDIV.js → chunk-3F27M7ZD.js}

@@ -1,14 +1,11 @@
 #!/usr/bin/env node
 import {
   PRManager
-} from "./chunk-ZW2LKWWE.js";
-import {
-  archiveRecap
-} from "./chunk-Y4YZTHZE.js";
+} from "./chunk-2VEWSM34.js";
 import {
   calculatePortForBranch,
   calculatePortFromIdentifier
-} from "./chunk-3D7WQM7I.js";
+} from "./chunk-LLHXQS3C.js";
 import {
   installDependencies,
   runScript
@@ -19,28 +16,19 @@ import {
 } from "./chunk-YQ57ORTV.js";
 import {
   generateRandomSessionId
-} from "./chunk-ONQYPICO.js";
+} from "./chunk-PZ5WSR5Z.js";
 import {
   GitCommandError,
   PLACEHOLDER_COMMIT_PREFIX,
   branchExists,
-  checkRemoteBranchStatus,
   ensureRepositoryHasCommits,
   executeGitCommand,
   extractIssueNumber,
   extractPRNumber,
   fetchOrigin,
-  findMainWorktreePathWithSettings,
-  findWorktreeForBranch,
-  getMergeTargetBranch,
-  hasUncommittedChanges,
-  isBranchMergedIntoMain,
   isFileTrackedByGit,
   pushBranchToRemote
-} from "./chunk-MNHZB4Z2.js";
-import {
-  SettingsManager
-} from "./chunk-YYAKPQBT.js";
+} from "./chunk-4FGEGQW4.js";
 import {
   MetadataManager
 } from "./chunk-KB64WNBZ.js";
@@ -445,8 +433,8 @@ ${issueData.body}` : "";
     const setArguments = (_k = input.options) == null ? void 0 : _k.setArguments;
     const executablePath = (_l = input.options) == null ? void 0 : _l.executablePath;
     if (enableClaude || enableCode || enableDevServer || enableTerminal) {
-      const { LoomLauncher } = await import("./LoomLauncher-L64HHS3T.js");
-      const { ClaudeContextManager } = await import("./ClaudeContextManager-QXX6ZFST.js");
+      const { LoomLauncher } = await import("./LoomLauncher-FRECYMXS.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-ZKTUVQB2.js");
       const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
       const launcher = new LoomLauncher(claudeContext, this.settings);
       await launcher.launchLoom({
@@ -601,7 +589,7 @@ ${issueData.body}` : "";
   async checkAndWarnChildLooms(branchName) {
     let targetBranch = branchName;
     if (!targetBranch) {
-      const { getCurrentBranch } = await import("./git-ET64COO3.js");
+      const { getCurrentBranch } = await import("./git-GTLKAZRJ.js");
       targetBranch = await getCurrentBranch();
     }
     if (!targetBranch) {
@@ -1149,8 +1137,8 @@ ${issueData.body}` : "";
     const executablePath = (_i = input.options) == null ? void 0 : _i.executablePath;
     if (enableClaude || enableCode || enableDevServer || enableTerminal) {
       getLogger().info("Launching workspace components...");
-      const { LoomLauncher } = await import("./LoomLauncher-L64HHS3T.js");
-      const { ClaudeContextManager } = await import("./ClaudeContextManager-QXX6ZFST.js");
+      const { LoomLauncher } = await import("./LoomLauncher-FRECYMXS.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-ZKTUVQB2.js");
       const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
       const launcher = new LoomLauncher(claudeContext, this.settings);
       await launcher.launchLoom({
@@ -1886,761 +1874,10 @@ var DatabaseManager = class {
   }
 };
 
-// src/lib/ResourceCleanup.ts
-import path4 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 = path4.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 = path4.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 {
   LoomManager,
   EnvironmentManager,
   CLIIsolationManager,
-  DatabaseManager,
-  ResourceCleanup
+  DatabaseManager
 };
-//# sourceMappingURL=chunk-UD3WJDIV.js.map
+//# sourceMappingURL=chunk-3F27M7ZD.js.map