@iloom/cli 0.9.2 → 0.10.1

package/dist/{chunk-SOSQILHO.js → chunk-ZNMPGMHY.js}

@@ -1,46 +1,43 @@
 #!/usr/bin/env node
 import {
   PRManager
-} from "./chunk-DGG2VY7B.js";
+} from "./chunk-KVHIAWVT.js";
 import {
   calculatePortForBranch,
   calculatePortFromIdentifier
-} from "./chunk-NUACL52E.js";
+} from "./chunk-LLHXQS3C.js";
 import {
   installDependencies,
   runScript
-} from "./chunk-4LKGCFGG.js";
+} from "./chunk-WWKOVDWC.js";
 import {
   getPackageConfig,
   hasScript
-} from "./chunk-VOGGLPG5.js";
+} from "./chunk-YQ57ORTV.js";
+import {
+  generateRandomSessionId
+} from "./chunk-UR5DGNUO.js";
 import {
   GitCommandError,
   PLACEHOLDER_COMMIT_PREFIX,
   branchExists,
-  checkRemoteBranchStatus,
   ensureRepositoryHasCommits,
   executeGitCommand,
   extractIssueNumber,
   extractPRNumber,
   fetchOrigin,
-  findMainWorktreePathWithSettings,
-  findWorktreeForBranch,
-  getMergeTargetBranch,
-  hasUncommittedChanges,
-  isBranchMergedIntoMain,
   isFileTrackedByGit,
   pushBranchToRemote
-} from "./chunk-AR5QKYNE.js";
-import {
-  SettingsManager
-} from "./chunk-RI2YL6TK.js";
+} from "./chunk-4FGEGQW4.js";
 import {
   MetadataManager
-} from "./chunk-KBEIQP4G.js";
+} from "./chunk-KB64WNBZ.js";
 import {
   GitHubService
-} from "./chunk-OFDN5NKS.js";
+} from "./chunk-KXDRI47U.js";
+import {
+  getLogger
+} from "./chunk-6MLEBAYZ.js";
 import {
   calculateForegroundColor,
   generateColorFromBranchName,
@@ -49,12 +46,6 @@ import {
   rgbToHex,
   selectDistinctColor
 } from "./chunk-433MOLAU.js";
-import {
-  generateRandomSessionId
-} from "./chunk-FO5GGFOV.js";
-import {
-  getLogger
-} from "./chunk-6MLEBAYZ.js";
 import {
   detectDarkMode,
   findEnvFileForDatabaseUrl,
@@ -244,10 +235,10 @@ var LoomManager = class {
    * NEW: Checks for existing worktrees and reuses them if found
    */
   async createIloom(input) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m, _n, _o, _p, _q, _r;
     getLogger().info("Fetching issue data...");
     const issueData = await this.fetchIssueData(input);
-    if (input.type === "issue" || input.type === "pr" || input.type === "branch") {
+    if (input.type === "issue" || input.type === "epic" || input.type === "pr" || input.type === "branch") {
       getLogger().info("Checking for existing worktree...");
       const existing = await this.findExistingIloom(input, issueData);
       if (existing) {
@@ -332,7 +323,7 @@ var LoomManager = class {
     let draftPrNumber = void 0;
     let draftPrUrl = void 0;
     const mergeBehavior = settingsData.mergeBehavior ?? { mode: "local" };
-    if (mergeBehavior.mode === "github-draft-pr" && (input.type === "issue" || input.type === "branch")) {
+    if (mergeBehavior.mode === "github-draft-pr" && (input.type === "issue" || input.type === "epic" || input.type === "branch")) {
       const prManager = new PRManager(settingsData);
       getLogger().info("Fetching from origin...");
       await executeGitCommand(["fetch", "origin"], { cwd: worktreePath });
@@ -367,6 +358,8 @@ var LoomManager = class {
         getLogger().debug("Placeholder commit created");
         getLogger().info("Pushing branch to remote for draft PR...");
         await pushBranchToRemote(branchName, worktreePath, { dryRun: false });
+        await executeGitCommand(["reset", "--soft", "HEAD~1"], { cwd: worktreePath });
+        getLogger().debug("Placeholder commit removed from local branch (still on remote)");
       }
       const existingPR = await prManager.checkForExistingPR(branchName, worktreePath);
       if (existingPR) {
@@ -376,7 +369,7 @@ var LoomManager = class {
       } else {
         const prTitle = (issueData == null ? void 0 : issueData.title) ?? `Work on ${branchName}`;
         let prBody;
-        if (input.type === "issue") {
+        if (input.type === "issue" || input.type === "epic") {
           const issueBody = (issueData == null ? void 0 : issueData.body) ? `
 
 ## ${issueData.title}
@@ -419,7 +412,7 @@ ${issueData.body}` : "";
         error
       );
     }
-    if (input.type === "issue") {
+    if (input.type === "issue" || input.type === "epic") {
       try {
         getLogger().info("Moving issue to In Progress...");
         if (this.issueTracker.moveIssueToInProgress) {
@@ -440,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-73NXL2CL.js");
-      const { ClaudeContextManager } = await import("./ClaudeContextManager-HR5JQKAI.js");
+      const { LoomLauncher } = await import("./LoomLauncher-TDLZSYG2.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-66GR4BGM.js");
       const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
       const launcher = new LoomLauncher(claudeContext, this.settings);
       await launcher.launchLoom({
@@ -453,7 +446,7 @@ ${issueData.body}` : "";
         branchName,
         port,
         capabilities,
-        workflowType: input.type === "branch" ? "regular" : input.type,
+        workflowType: input.type === "branch" ? "regular" : input.type === "epic" ? "issue" : input.type,
         identifier: input.identifier,
         ...(issueData == null ? void 0 : issueData.title) && { title: issueData.title },
         oneShot,
@@ -467,7 +460,7 @@ ${issueData.body}` : "";
     const description = (issueData == null ? void 0 : issueData.title) ?? branchName;
     let issue_numbers = [];
     let extractedIssueNum = null;
-    if (input.type === "issue") {
+    if (input.type === "issue" || input.type === "epic") {
       issue_numbers = [String(input.identifier)];
     } else if (input.type === "pr") {
       extractedIssueNum = extractIssueNumber(branchName);
@@ -481,7 +474,7 @@ ${issueData.body}` : "";
     }
     const sessionId = generateRandomSessionId();
     let issueUrls = {};
-    if (input.type === "issue" && (issueData == null ? void 0 : issueData.url)) {
+    if ((input.type === "issue" || input.type === "epic") && (issueData == null ? void 0 : issueData.url)) {
       issueUrls = { [String(input.identifier)]: issueData.url };
     } else if (input.type === "pr" && extractedIssueNum && (issueData == null ? void 0 : issueData.url)) {
       const issueUrl = issueData.url.replace(`/pull/${input.identifier}`, `/issues/${extractedIssueNum}`);
@@ -493,6 +486,7 @@ ${issueData.body}` : "";
       branchName,
       worktreePath,
       issueType: input.type,
+      ...(input.type === "issue" || input.type === "epic") && { issueKey: this.issueTracker.normalizeIdentifier(input.identifier) },
       issue_numbers,
       pr_numbers,
       issueTracker: this.issueTracker.providerName,
@@ -504,6 +498,9 @@ ${issueData.body}` : "";
       capabilities,
       ...draftPrNumber && { draftPrNumber },
       ...((_o = input.options) == null ? void 0 : _o.oneShot) && { oneShot: input.options.oneShot },
+      ...((_p = input.options) == null ? void 0 : _p.childIssueNumbers) && input.options.childIssueNumbers.length > 0 && { childIssueNumbers: input.options.childIssueNumbers },
+      ...((_q = input.options) == null ? void 0 : _q.childIssues) && input.options.childIssues.length > 0 && { childIssues: input.options.childIssues },
+      ...((_r = input.options) == null ? void 0 : _r.dependencyMap) && Object.keys(input.options.dependencyMap).length > 0 && { dependencyMap: input.options.dependencyMap },
       ...input.parentLoom && { parentLoom: input.parentLoom }
     };
     await this.metadataManager.writeMetadata(worktreePath, metadataInput);
@@ -592,7 +589,7 @@ ${issueData.body}` : "";
   async checkAndWarnChildLooms(branchName) {
     let targetBranch = branchName;
     if (!targetBranch) {
-      const { getCurrentBranch } = await import("./git-2QDQ2X2S.js");
+      const { getCurrentBranch } = await import("./git-GTLKAZRJ.js");
       targetBranch = await getCurrentBranch();
     }
     if (!targetBranch) {
@@ -621,7 +618,7 @@ ${issueData.body}` : "";
    * Fetch issue/PR data based on input type
    */
   async fetchIssueData(input) {
-    if (input.type === "issue") {
+    if (input.type === "issue" || input.type === "epic") {
       return await this.issueTracker.fetchIssue(input.identifier);
     } else if (input.type === "pr") {
       if (this.issueTracker.supportsPullRequests && this.issueTracker.fetchPR) {
@@ -645,7 +642,7 @@ ${issueData.body}` : "";
     if (input.type === "pr" && issueData && "branch" in issueData) {
       return issueData.branch;
     }
-    if (input.type === "issue" && issueData) {
+    if ((input.type === "issue" || input.type === "epic") && issueData) {
       const branchName = await this.branchNaming.generateBranchName({
         issueNumber: input.identifier,
         title: issueData.title
@@ -918,7 +915,7 @@ ${issueData.body}` : "";
   async setupPortForWeb(worktreePath, input, basePort) {
     const envFilePath = path2.join(worktreePath, ".env.local");
     const options = { basePort };
-    if (input.type === "issue") {
+    if (input.type === "issue" || input.type === "epic") {
       options.issueNumber = input.identifier;
     } else if (input.type === "pr") {
       options.prNumber = input.identifier;
@@ -963,7 +960,7 @@ ${issueData.body}` : "";
     var _a, _b;
     const settingsData = await this.settings.loadSettings();
     const basePort = ((_b = (_a = settingsData.capabilities) == null ? void 0 : _a.web) == null ? void 0 : _b.basePort) ?? 3e3;
-    if (input.type === "issue") {
+    if (input.type === "issue" || input.type === "epic") {
       if (typeof input.identifier === "number") {
         return this.environment.calculatePort({ basePort, issueNumber: input.identifier });
       } else if (typeof input.identifier === "string") {
@@ -1017,8 +1014,8 @@ ${issueData.body}` : "";
       let identifier = wt.branch;
       if (loomMetadata == null ? void 0 : loomMetadata.issueType) {
         type = loomMetadata.issueType;
-        if (type === "issue" && ((_a = loomMetadata.issue_numbers) == null ? void 0 : _a[0])) {
-          const issueId = loomMetadata.issue_numbers[0];
+        if (type === "issue" && (loomMetadata.issueKey || ((_a = loomMetadata.issue_numbers) == null ? void 0 : _a[0]))) {
+          const issueId = loomMetadata.issueKey ?? loomMetadata.issue_numbers[0] ?? "";
           const numericId = parseInt(issueId, 10);
           identifier = isNaN(numericId) ? issueId : numericId;
         } else if (type === "pr" && ((_b = loomMetadata.pr_numbers) == null ? void 0 : _b[0])) {
@@ -1080,7 +1077,7 @@ ${issueData.body}` : "";
    * Ports: handle_existing_worktree() from bash script lines 168-215
    */
   async reuseIloom(worktree, input, issueData) {
-    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l;
+    var _a, _b, _c, _d, _e, _f, _g, _h, _i, _j, _k, _l, _m;
     const worktreePath = worktree.path;
     const branchName = worktree.branch;
     this.loadMainEnvFile();
@@ -1140,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-73NXL2CL.js");
-      const { ClaudeContextManager } = await import("./ClaudeContextManager-HR5JQKAI.js");
+      const { LoomLauncher } = await import("./LoomLauncher-TDLZSYG2.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-66GR4BGM.js");
       const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
       const launcher = new LoomLauncher(claudeContext, this.settings);
       await launcher.launchLoom({
@@ -1153,7 +1150,7 @@ ${issueData.body}` : "";
         branchName,
         port,
         capabilities,
-        workflowType: input.type === "branch" ? "regular" : input.type,
+        workflowType: input.type === "branch" ? "regular" : input.type === "epic" ? "issue" : input.type,
         identifier: input.identifier,
         ...(issueData == null ? void 0 : issueData.title) && { title: issueData.title },
         oneShot,
@@ -1191,6 +1188,7 @@ ${issueData.body}` : "";
         branchName,
         worktreePath,
         issueType: input.type,
+        ...input.type === "issue" && { issueKey: this.issueTracker.normalizeIdentifier(input.identifier) },
         issue_numbers,
         pr_numbers,
         issueTracker: this.issueTracker.providerName,
@@ -1201,6 +1199,7 @@ ${issueData.body}` : "";
         prUrls,
         capabilities,
         ...((_l = input.options) == null ? void 0 : _l.oneShot) && { oneShot: input.options.oneShot },
+        ...((_m = input.options) == null ? void 0 : _m.childIssueNumbers) && input.options.childIssueNumbers.length > 0 && { childIssueNumbers: input.options.childIssueNumbers },
         ...input.parentLoom && { parentLoom: input.parentLoom }
       };
       await this.metadataManager.writeMetadata(worktreePath, metadataInput);
@@ -1875,762 +1874,10 @@ var DatabaseManager = class {
   }
 };
 
-// src/lib/ResourceCleanup.ts
-import path5 from "path";
-
-// src/utils/recap-archiver.ts
-import path4 from "path";
-import os2 from "os";
-import fs6 from "fs-extra";
-var RECAPS_DIR = path4.join(os2.homedir(), ".config", "iloom-ai", "recaps");
-var ARCHIVED_DIR = path4.join(RECAPS_DIR, "archived");
-function slugifyPath(loomPath) {
-  let slug = loomPath.replace(/[/\\]+$/, "");
-  slug = slug.replace(/[/\\]/g, "___");
-  slug = slug.replace(/[^a-zA-Z0-9_-]/g, "-");
-  return `${slug}.json`;
-}
-async function archiveRecap(worktreePath) {
-  const filename = slugifyPath(worktreePath);
-  const sourcePath = path4.join(RECAPS_DIR, filename);
-  if (!await fs6.pathExists(sourcePath)) {
-    getLogger().debug(`No recap file to archive for worktree: ${worktreePath}`);
-    return;
-  }
-  const content = await fs6.readFile(sourcePath, "utf8");
-  const data = JSON.parse(content);
-  const archivedData = {
-    ...data,
-    archivedAt: (/* @__PURE__ */ new Date()).toISOString()
-  };
-  await fs6.ensureDir(ARCHIVED_DIR, { mode: 493 });
-  const destPath = path4.join(ARCHIVED_DIR, filename);
-  await fs6.writeFile(destPath, JSON.stringify(archivedData, null, 2), { mode: 420 });
-  await fs6.unlink(sourcePath);
-  getLogger().debug(`Recap archived for worktree: ${worktreePath}`);
-}
-
-// src/lib/ResourceCleanup.ts
-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 (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 = path5.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) {
-        operations.push({
-          type: "metadata",
-          success: true,
-          message: `[DRY RUN] Would delete metadata for worktree: ${worktree.path}`
-        });
-      } 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 = path5.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-SOSQILHO.js.map
+//# sourceMappingURL=chunk-ZNMPGMHY.js.map