@iloom/cli 0.2.0 → 0.3.1

package/dist/chunk-HBYZH6GD.js

@@ -0,0 +1,1989 @@
+#!/usr/bin/env node
+import {
+  formatEnvLine,
+  loadEnvIntoProcess,
+  parseEnvFile,
+  validateEnvVariable
+} from "./chunk-IP7SMKIF.js";
+import {
+  calculatePortForBranch
+} from "./chunk-VU3QMIP2.js";
+import {
+  installDependencies,
+  runScript
+} from "./chunk-ZT3YZB4K.js";
+import {
+  hasScript,
+  readPackageJson
+} from "./chunk-2ZPFJQ3B.js";
+import {
+  SettingsManager
+} from "./chunk-O5OH5MRX.js";
+import {
+  branchExists,
+  ensureRepositoryHasCommits,
+  executeGitCommand,
+  extractIssueNumber,
+  findMainWorktreePathWithSettings,
+  hasUncommittedChanges
+} from "./chunk-4BGK7T6X.js";
+import {
+  calculateForegroundColor,
+  generateColorFromBranchName,
+  hexToRgb,
+  lightenColor,
+  rgbToHex
+} from "./chunk-ZZZWQGTS.js";
+import {
+  createLogger,
+  logger
+} from "./chunk-GEHQXLEI.js";
+
+// src/lib/LoomManager.ts
+import path2 from "path";
+import fs2 from "fs-extra";
+
+// src/lib/VSCodeIntegration.ts
+import fs from "fs-extra";
+import path from "path";
+import { parse, modify, applyEdits } from "jsonc-parser";
+var VSCodeIntegration = class {
+  /**
+   * Set VSCode title bar color for a workspace
+   *
+   * @param workspacePath - Path to workspace directory
+   * @param hexColor - Hex color string (e.g., "#dcebf8")
+   */
+  async setTitleBarColor(workspacePath, hexColor) {
+    const vscodeDir = path.join(workspacePath, ".vscode");
+    const settingsPath = path.join(vscodeDir, "settings.json");
+    try {
+      await fs.ensureDir(vscodeDir);
+      const settings = await this.readSettings(settingsPath);
+      const updatedSettings = this.mergeColorSettings(settings, hexColor);
+      await this.writeSettings(settingsPath, updatedSettings);
+      logger.debug(`Set VSCode title bar color to ${hexColor} for ${workspacePath}`);
+    } catch (error) {
+      throw new Error(
+        `Failed to set VSCode title bar color: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Read VSCode settings from file
+   * Supports JSONC (JSON with Comments)
+   *
+   * @param settingsPath - Path to settings.json file
+   * @returns Parsed settings object
+   */
+  async readSettings(settingsPath) {
+    try {
+      if (!await fs.pathExists(settingsPath)) {
+        return {};
+      }
+      const content = await fs.readFile(settingsPath, "utf8");
+      const errors = [];
+      const settings = parse(content, errors, { allowTrailingComma: true });
+      if (errors.length > 0) {
+        const firstError = errors[0];
+        throw new Error(`Invalid JSON: ${firstError ? firstError.error : "Unknown parse error"}`);
+      }
+      return settings ?? {};
+    } catch (error) {
+      throw new Error(
+        `Failed to parse settings.json: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Write VSCode settings to file atomically
+   * Preserves comments if present (using JSONC parser)
+   *
+   * @param settingsPath - Path to settings.json file
+   * @param settings - Settings object to write
+   */
+  async writeSettings(settingsPath, settings) {
+    try {
+      let content;
+      if (await fs.pathExists(settingsPath)) {
+        const existingContent = await fs.readFile(settingsPath, "utf8");
+        if (existingContent.includes("//") || existingContent.includes("/*")) {
+          content = await this.modifyWithCommentsPreserved(existingContent, settings);
+        } else {
+          content = JSON.stringify(settings, null, 2) + "\n";
+        }
+      } else {
+        content = JSON.stringify(settings, null, 2) + "\n";
+      }
+      const tempPath = `${settingsPath}.tmp`;
+      await fs.writeFile(tempPath, content, "utf8");
+      await fs.rename(tempPath, settingsPath);
+    } catch (error) {
+      throw new Error(
+        `Failed to write settings.json: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  /**
+   * Modify JSONC content while preserving comments
+   *
+   * @param existingContent - Original JSONC content
+   * @param newSettings - New settings to apply
+   * @returns Modified JSONC content with comments preserved
+   */
+  async modifyWithCommentsPreserved(existingContent, newSettings) {
+    let modifiedContent = existingContent;
+    for (const [key, value] of Object.entries(newSettings)) {
+      const edits = modify(modifiedContent, [key], value, {});
+      modifiedContent = applyEdits(modifiedContent, edits);
+    }
+    return modifiedContent;
+  }
+  /**
+   * Merge color settings into existing settings object
+   *
+   * @param existing - Existing settings object
+   * @param hexColor - Hex color to apply (subtle palette color)
+   * @returns Updated settings object with color merged
+   */
+  mergeColorSettings(existing, hexColor) {
+    const updated = { ...existing };
+    updated["workbench.colorCustomizations"] ??= {};
+    const colors = updated["workbench.colorCustomizations"];
+    const baseRgb = hexToRgb(hexColor);
+    const foreground = calculateForegroundColor(baseRgb);
+    const foregroundTransparent = foreground.replace("#", "#") + "99";
+    const lighterRgb = lightenColor(baseRgb, 0.05);
+    const lighterHex = rgbToHex(lighterRgb.r, lighterRgb.g, lighterRgb.b);
+    colors["titleBar.activeBackground"] = hexColor;
+    colors["titleBar.inactiveBackground"] = hexColor + "99";
+    colors["titleBar.activeForeground"] = foreground;
+    colors["titleBar.inactiveForeground"] = foregroundTransparent;
+    colors["statusBar.background"] = hexColor;
+    colors["statusBar.foreground"] = foreground;
+    colors["statusBarItem.hoverBackground"] = lighterHex;
+    colors["statusBarItem.remoteBackground"] = hexColor;
+    colors["statusBarItem.remoteForeground"] = foreground;
+    colors["sash.hoverBorder"] = hexColor;
+    colors["commandCenter.border"] = foregroundTransparent;
+    return updated;
+  }
+};
+
+// src/lib/LoomManager.ts
+var LoomManager = class {
+  constructor(gitWorktree, issueTracker, branchNaming, environment, _claude, capabilityDetector, cliIsolation, settings, database) {
+    this.gitWorktree = gitWorktree;
+    this.issueTracker = issueTracker;
+    this.branchNaming = branchNaming;
+    this.environment = environment;
+    this.capabilityDetector = capabilityDetector;
+    this.cliIsolation = cliIsolation;
+    this.settings = settings;
+    this.database = database;
+  }
+  /**
+   * Get database branch name for a loom by reading its .env file
+   * Returns null if database is not configured or branch cannot be determined
+   *
+   * @param loomPath - Path to the loom worktree
+   */
+  async getDatabaseBranchForLoom(loomPath) {
+    var _a, _b;
+    if (!this.database) {
+      return null;
+    }
+    try {
+      const envFilePath = path2.join(loomPath, ".env");
+      const settings = await this.settings.loadSettings();
+      const databaseUrlVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.databaseUrlEnvVarName) ?? "DATABASE_URL";
+      const connectionString = await this.environment.getEnvVariable(envFilePath, databaseUrlVarName);
+      if (!connectionString) {
+        return null;
+      }
+      return await this.database.getBranchNameFromConnectionString(connectionString, loomPath);
+    } catch (error) {
+      logger.debug(`Could not get database branch for loom at ${loomPath}: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return null;
+    }
+  }
+  /**
+   * Create a new loom (isolated workspace)
+   * Orchestrates worktree creation, environment setup, and Claude context generation
+   * 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;
+    logger.info("Fetching issue data...");
+    const issueData = await this.fetchIssueData(input);
+    if (input.type === "issue" || input.type === "pr" || input.type === "branch") {
+      logger.info("Checking for existing worktree...");
+      const existing = await this.findExistingIloom(input, issueData);
+      if (existing) {
+        logger.success(`Found existing worktree, reusing: ${existing.path}`);
+        return await this.reuseIloom(existing, input, issueData);
+      }
+      logger.info("No existing worktree found, creating new one...");
+    }
+    logger.info("Preparing branch name...");
+    const branchName = await this.prepareBranchName(input, issueData);
+    logger.info("Creating git worktree...");
+    const worktreePath = await this.createWorktreeOnly(input, branchName);
+    this.loadMainEnvFile();
+    const { capabilities, binEntries } = await this.capabilityDetector.detectCapabilities(worktreePath);
+    await this.copyEnvironmentFiles(worktreePath);
+    await this.copyIloomSettings(worktreePath, (_a = input.parentLoom) == null ? void 0 : _a.branchName);
+    const settingsData = await this.settings.loadSettings();
+    const basePort = ((_c = (_b = settingsData.capabilities) == null ? void 0 : _b.web) == null ? void 0 : _c.basePort) ?? 3e3;
+    let port = basePort;
+    if (capabilities.includes("web")) {
+      port = await this.setupPortForWeb(worktreePath, input, basePort);
+    }
+    try {
+      await installDependencies(worktreePath, true, true);
+    } catch (error) {
+      logger.warn(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+    }
+    let databaseBranch = void 0;
+    if (this.database && !((_d = input.options) == null ? void 0 : _d.skipDatabase)) {
+      try {
+        const connectionString = await this.database.createBranchIfConfigured(
+          branchName,
+          path2.join(worktreePath, ".env"),
+          void 0,
+          // cwd
+          (_e = input.parentLoom) == null ? void 0 : _e.databaseBranch
+          // fromBranch - use parent's database branch for child looms
+        );
+        if (connectionString) {
+          await this.environment.setEnvVar(
+            path2.join(worktreePath, ".env"),
+            this.database.getConfiguredVariableName(),
+            connectionString
+          );
+          logger.success("Database branch configured");
+          databaseBranch = branchName;
+        }
+      } catch (error) {
+        logger.error(
+          `Failed to setup database branch: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+        throw error;
+      }
+    }
+    let cliSymlinks = void 0;
+    if (capabilities.includes("cli")) {
+      try {
+        cliSymlinks = await this.cliIsolation.setupCLIIsolation(
+          worktreePath,
+          input.identifier,
+          binEntries
+        );
+      } catch (error) {
+        logger.warn(
+          `Failed to setup CLI isolation: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    }
+    if (!((_f = input.options) == null ? void 0 : _f.skipColorSync)) {
+      try {
+        await this.applyColorSynchronization(worktreePath, branchName);
+      } catch (error) {
+        logger.warn(
+          `Failed to apply color synchronization: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    }
+    if (input.type === "issue") {
+      try {
+        logger.info("Moving issue to In Progress...");
+        if (this.issueTracker.moveIssueToInProgress) {
+          await this.issueTracker.moveIssueToInProgress(input.identifier);
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to move issue to In Progress: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    }
+    const enableClaude = ((_g = input.options) == null ? void 0 : _g.enableClaude) !== false;
+    const enableCode = ((_h = input.options) == null ? void 0 : _h.enableCode) !== false;
+    const enableDevServer = ((_i = input.options) == null ? void 0 : _i.enableDevServer) !== false;
+    const enableTerminal = ((_j = input.options) == null ? void 0 : _j.enableTerminal) ?? false;
+    const oneShot = ((_k = input.options) == null ? void 0 : _k.oneShot) ?? "default";
+    const setArguments = (_l = input.options) == null ? void 0 : _l.setArguments;
+    const executablePath = (_m = input.options) == null ? void 0 : _m.executablePath;
+    if (enableClaude || enableCode || enableDevServer || enableTerminal) {
+      const { LoomLauncher } = await import("./LoomLauncher-JF7JZMTZ.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-3VXA6UPR.js");
+      const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
+      const launcher = new LoomLauncher(claudeContext, this.settings);
+      await launcher.launchLoom({
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal,
+        worktreePath,
+        branchName,
+        port,
+        capabilities,
+        workflowType: input.type === "branch" ? "regular" : input.type,
+        identifier: input.identifier,
+        ...(issueData == null ? void 0 : issueData.title) && { title: issueData.title },
+        oneShot,
+        ...setArguments && { setArguments },
+        ...executablePath && { executablePath },
+        sourceEnvOnStart: settingsData.sourceEnvOnStart ?? false
+      });
+    }
+    const loom = {
+      id: this.generateLoomId(input),
+      path: worktreePath,
+      branch: branchName,
+      type: input.type,
+      identifier: input.identifier,
+      port,
+      createdAt: /* @__PURE__ */ new Date(),
+      lastAccessed: /* @__PURE__ */ new Date(),
+      ...databaseBranch !== void 0 && { databaseBranch },
+      ...capabilities.length > 0 && { capabilities },
+      ...Object.keys(binEntries).length > 0 && { binEntries },
+      ...cliSymlinks && cliSymlinks.length > 0 && { cliSymlinks },
+      ...issueData !== null && {
+        issueData: {
+          title: issueData.title,
+          body: issueData.body,
+          url: issueData.url,
+          state: issueData.state
+        }
+      }
+    };
+    logger.success(`Created loom: ${loom.id} at ${loom.path}`);
+    return loom;
+  }
+  /**
+   * Finish a loom (merge work and cleanup)
+   * Not yet implemented - see Issue #7
+   */
+  async finishIloom(_identifier) {
+    throw new Error("Not implemented - see Issue #7");
+  }
+  /**
+   * List all active looms
+   */
+  async listLooms() {
+    const worktrees = await this.gitWorktree.listWorktrees();
+    return await this.mapWorktreesToLooms(worktrees);
+  }
+  /**
+   * Find a specific loom by identifier
+   * Case-insensitive matching for Linear IDs (MARK-1 vs mark-1)
+   */
+  async findIloom(identifier) {
+    const looms = await this.listLooms();
+    const lowerIdentifier = identifier.toLowerCase();
+    return looms.find(
+      (h) => h.id.toLowerCase() === lowerIdentifier || h.identifier.toString().toLowerCase() === lowerIdentifier || h.branch.toLowerCase() === lowerIdentifier
+    ) ?? null;
+  }
+  /**
+   * Find child looms for a given parent loom
+   * Child looms are worktrees created with the parent loom as their base
+   *
+   * @param parentBranchName - The parent loom's branch name
+   * @returns Array of child loom worktrees
+   */
+  async findChildLooms(parentBranchName) {
+    try {
+      const worktrees = await this.gitWorktree.listWorktrees();
+      if (!worktrees) {
+        return [];
+      }
+      const sanitizedBranchName = parentBranchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "-");
+      const pattern = `${sanitizedBranchName}-looms/`;
+      return worktrees.filter((wt) => wt.path.includes(pattern));
+    } catch (error) {
+      logger.debug(`Failed to find child looms: ${error instanceof Error ? error.message : "Unknown error"}`);
+      return [];
+    }
+  }
+  /**
+   * Check for child looms and warn user if any exist
+   * This is useful before finishing or cleaning up a parent loom
+   *
+   * @param branchName - Optional branch name to check. If not provided, uses current branch.
+   * @returns true if child looms were found, false otherwise
+   */
+  async checkAndWarnChildLooms(branchName) {
+    let targetBranch = branchName;
+    if (!targetBranch) {
+      const { getCurrentBranch } = await import("./git-34Z6QVDS.js");
+      targetBranch = await getCurrentBranch();
+    }
+    if (!targetBranch) {
+      return false;
+    }
+    const childLooms = await this.findChildLooms(targetBranch);
+    if (childLooms.length > 0) {
+      logger.warn(`Found ${childLooms.length} child loom(s) that should be finished first:`);
+      for (const child of childLooms) {
+        logger.warn(`  - ${child.path}`);
+      }
+      logger.warn("");
+      logger.warn("To finish child looms:");
+      for (const child of childLooms) {
+        const prMatch = child.branch.match(/_pr_(\d+)/);
+        const issueId = extractIssueNumber(child.branch);
+        const childIdentifier = prMatch ? prMatch[1] : issueId ?? child.branch;
+        logger.warn(`  il finish ${childIdentifier}`);
+      }
+      logger.warn("");
+      return true;
+    }
+    return false;
+  }
+  /**
+   * Fetch issue/PR data based on input type
+   */
+  async fetchIssueData(input) {
+    if (input.type === "issue") {
+      return await this.issueTracker.fetchIssue(input.identifier);
+    } else if (input.type === "pr") {
+      if (!this.issueTracker.supportsPullRequests || !this.issueTracker.fetchPR) {
+        throw new Error("Issue tracker does not support pull requests");
+      }
+      return await this.issueTracker.fetchPR(input.identifier);
+    }
+    return null;
+  }
+  /**
+   * Prepare branch name based on input type and issue/PR data
+   */
+  async prepareBranchName(input, issueData) {
+    if (input.type === "branch") {
+      return input.identifier;
+    }
+    if (input.type === "pr" && issueData && "branch" in issueData) {
+      return issueData.branch;
+    }
+    if (input.type === "issue" && issueData) {
+      const branchName = await this.branchNaming.generateBranchName({
+        issueNumber: input.identifier,
+        title: issueData.title
+      });
+      return branchName;
+    }
+    if (input.type === "pr") {
+      return `pr-${input.identifier}`;
+    }
+    throw new Error(`Unable to determine branch name for input type: ${input.type}`);
+  }
+  /**
+   * Create worktree for the loom (without dependency installation)
+   */
+  async createWorktreeOnly(input, branchName) {
+    var _a;
+    logger.info("Ensuring repository has initial commit...");
+    await ensureRepositoryHasCommits(this.gitWorktree.workingDirectory);
+    const settingsData = await this.settings.loadSettings();
+    let worktreePrefix = settingsData.worktreePrefix;
+    if (input.parentLoom) {
+      const sanitizedBranchName = input.parentLoom.branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9-_]/g, "-");
+      worktreePrefix = `${sanitizedBranchName}-looms/`;
+      logger.info(`Creating child loom with prefix: ${worktreePrefix}`);
+    }
+    const pathOptions = input.type === "pr" ? { isPR: true, prNumber: input.identifier } : {};
+    if (worktreePrefix !== void 0) {
+      pathOptions.prefix = worktreePrefix;
+    }
+    const worktreePath = this.gitWorktree.generateWorktreePath(
+      branchName,
+      void 0,
+      pathOptions
+    );
+    if (input.type === "pr") {
+      logger.info("Fetching all remote branches...");
+      try {
+        await executeGitCommand(["fetch", "origin"], { cwd: this.gitWorktree.workingDirectory });
+        logger.success("Successfully fetched from remote");
+      } catch (error) {
+        throw new Error(
+          `Failed to fetch from remote: ${error instanceof Error ? error.message : "Unknown error"}. Make sure you have access to the repository.`
+        );
+      }
+    }
+    const branchExistedLocally = await branchExists(branchName);
+    if (input.type !== "pr" && branchExistedLocally) {
+      throw new Error(
+        `Cannot create worktree: branch '${branchName}' already exists. Use 'git branch -D ${branchName}' to delete it first if needed.`
+      );
+    }
+    const baseBranch = ((_a = input.parentLoom) == null ? void 0 : _a.branchName) ?? input.baseBranch;
+    await this.gitWorktree.createWorktree({
+      path: worktreePath,
+      branch: branchName,
+      createBranch: input.type !== "pr",
+      // PRs use existing branches
+      ...baseBranch && { baseBranch }
+    });
+    if (input.type === "pr" && !branchExistedLocally) {
+      logger.info("Resetting new PR branch to match remote exactly...");
+      try {
+        await executeGitCommand(["reset", "--hard", `origin/${branchName}`], { cwd: worktreePath });
+        await executeGitCommand(["branch", "--set-upstream-to", `origin/${branchName}`], { cwd: worktreePath });
+        logger.success("Successfully reset to match remote");
+      } catch (error) {
+        logger.warn(`Failed to reset to match remote: ${error instanceof Error ? error.message : "Unknown error"}`);
+      }
+    }
+    return worktreePath;
+  }
+  /**
+   * Copy user application environment files (.env) from main repo to worktree
+   * Always called regardless of project capabilities
+   */
+  async copyEnvironmentFiles(worktreePath) {
+    const envFilePath = path2.join(worktreePath, ".env");
+    try {
+      const mainEnvPath = path2.join(process.cwd(), ".env");
+      if (await fs2.pathExists(envFilePath)) {
+        logger.warn(".env file already exists in worktree, skipping copy");
+      } else {
+        await this.environment.copyIfExists(mainEnvPath, envFilePath);
+      }
+    } catch (error) {
+      logger.warn(`Warning: Failed to copy main .env file: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Copy iloom configuration (settings.local.json) from main repo to worktree
+   * Always called regardless of project capabilities
+   * @param worktreePath Path to the worktree
+   * @param parentBranchName Optional parent branch name for child looms (sets mainBranch)
+   */
+  async copyIloomSettings(worktreePath, parentBranchName) {
+    const mainSettingsLocalPath = path2.join(process.cwd(), ".iloom", "settings.local.json");
+    try {
+      const worktreeIloomDir = path2.join(worktreePath, ".iloom");
+      await fs2.ensureDir(worktreeIloomDir);
+      const worktreeSettingsLocalPath = path2.join(worktreeIloomDir, "settings.local.json");
+      if (await fs2.pathExists(worktreeSettingsLocalPath)) {
+        logger.warn("settings.local.json already exists in worktree, skipping copy");
+      } else {
+        await this.environment.copyIfExists(mainSettingsLocalPath, worktreeSettingsLocalPath);
+      }
+      if (parentBranchName) {
+        let existingSettings = {};
+        try {
+          const content = await fs2.readFile(worktreeSettingsLocalPath, "utf8");
+          existingSettings = JSON.parse(content);
+        } catch {
+        }
+        const updatedSettings = {
+          ...existingSettings,
+          mainBranch: parentBranchName
+        };
+        await fs2.writeFile(worktreeSettingsLocalPath, JSON.stringify(updatedSettings, null, 2));
+        logger.info(`Set mainBranch to ${parentBranchName} for child loom`);
+      }
+    } catch (error) {
+      logger.warn(`Warning: Failed to copy settings.local.json: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+  }
+  /**
+   * Setup PORT environment variable for web projects
+   * Only called when project has web capabilities
+   */
+  async setupPortForWeb(worktreePath, input, basePort) {
+    const envFilePath = path2.join(worktreePath, ".env");
+    const options = { basePort };
+    if (input.type === "issue") {
+      options.issueNumber = input.identifier;
+    } else if (input.type === "pr") {
+      options.prNumber = input.identifier;
+    } else if (input.type === "branch") {
+      options.branchName = input.identifier;
+    }
+    const port = this.environment.calculatePort(options);
+    await this.environment.setEnvVar(envFilePath, "PORT", String(port));
+    return port;
+  }
+  /**
+   * Load environment variables from main .env file into process.env
+   * Uses dotenv-flow to handle various .env file patterns
+   */
+  loadMainEnvFile() {
+    const result = loadEnvIntoProcess({ path: process.cwd() });
+    if (result.error) {
+      logger.warn(`Warning: Could not load .env files: ${result.error.message}`);
+    } else {
+      logger.info("Loaded environment variables using dotenv-flow");
+      if (result.parsed && Object.keys(result.parsed).length > 0) {
+        logger.debug(`Loaded ${Object.keys(result.parsed).length} environment variables`);
+      }
+    }
+  }
+  /**
+   * Generate a unique loom ID
+   */
+  generateLoomId(input) {
+    const prefix = input.type;
+    return `${prefix}-${input.identifier}`;
+  }
+  /**
+   * Calculate port for the loom
+   * Base port: configurable via settings.capabilities.web.basePort (default 3000) + issue/PR number (or deterministic hash for branches)
+   */
+  async calculatePort(input) {
+    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" && typeof input.identifier === "number") {
+      return this.environment.calculatePort({ basePort, issueNumber: input.identifier });
+    }
+    if (input.type === "pr" && typeof input.identifier === "number") {
+      return this.environment.calculatePort({ basePort, prNumber: input.identifier });
+    }
+    if (input.type === "branch" && typeof input.identifier === "string") {
+      return this.environment.calculatePort({ basePort, branchName: input.identifier });
+    }
+    throw new Error(`Unknown input type: ${input.type}`);
+  }
+  /**
+   * Apply color synchronization to both VSCode and terminal
+   * Colors are cosmetic - errors are logged but don't block workflow
+   */
+  async applyColorSynchronization(worktreePath, branchName) {
+    const colorData = generateColorFromBranchName(branchName);
+    const vscode = new VSCodeIntegration();
+    await vscode.setTitleBarColor(worktreePath, colorData.hex);
+    logger.info(`Applied VSCode title bar color: ${colorData.hex} for branch: ${branchName}`);
+  }
+  /**
+   * Map worktrees to loom objects
+   * This is a simplified conversion - in production we'd store loom metadata
+   */
+  async mapWorktreesToLooms(worktrees) {
+    return await Promise.all(worktrees.map(async (wt) => {
+      let type = "branch";
+      let identifier = wt.branch;
+      if (wt.branch.startsWith("issue-")) {
+        type = "issue";
+        identifier = parseInt(wt.branch.replace("issue-", ""), 10);
+      } else if (wt.branch.startsWith("pr-")) {
+        type = "pr";
+        identifier = parseInt(wt.branch.replace("pr-", ""), 10);
+      }
+      return {
+        id: `${type}-${identifier}`,
+        path: wt.path,
+        branch: wt.branch,
+        type,
+        identifier,
+        port: await this.calculatePort({ type, identifier, originalInput: "" }),
+        createdAt: /* @__PURE__ */ new Date(),
+        lastAccessed: /* @__PURE__ */ new Date()
+      };
+    }));
+  }
+  /**
+   * NEW: Find existing loom for the given input
+   * Checks for worktrees matching the issue/PR identifier
+   */
+  async findExistingIloom(input, issueData) {
+    if (input.type === "issue") {
+      return await this.gitWorktree.findWorktreeForIssue(input.identifier);
+    } else if (input.type === "pr" && issueData && "branch" in issueData) {
+      return await this.gitWorktree.findWorktreeForPR(
+        input.identifier,
+        issueData.branch
+      );
+    } else if (input.type === "branch") {
+      return await this.gitWorktree.findWorktreeForBranch(input.identifier);
+    }
+    return null;
+  }
+  /**
+   * NEW: Reuse an existing loom
+   * Includes environment setup and database branching for existing worktrees
+   * 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;
+    const worktreePath = worktree.path;
+    const branchName = worktree.branch;
+    this.loadMainEnvFile();
+    const { capabilities, binEntries } = await this.capabilityDetector.detectCapabilities(worktreePath);
+    await this.copyEnvironmentFiles(worktreePath);
+    await this.copyIloomSettings(worktreePath);
+    const settingsData = await this.settings.loadSettings();
+    const basePort = ((_b = (_a = settingsData.capabilities) == null ? void 0 : _a.web) == null ? void 0 : _b.basePort) ?? 3e3;
+    let port = basePort;
+    if (capabilities.includes("web")) {
+      port = await this.setupPortForWeb(worktreePath, input, basePort);
+    }
+    logger.info("Database branch assumed to be already configured for existing worktree");
+    const databaseBranch = void 0;
+    if (input.type === "issue") {
+      try {
+        logger.info("Moving issue to In Progress...");
+        if (this.issueTracker.moveIssueToInProgress) {
+          await this.issueTracker.moveIssueToInProgress(input.identifier);
+        }
+      } catch (error) {
+        logger.warn(
+          `Failed to move issue to In Progress: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    }
+    const enableClaude = ((_c = input.options) == null ? void 0 : _c.enableClaude) !== false;
+    const enableCode = ((_d = input.options) == null ? void 0 : _d.enableCode) !== false;
+    const enableDevServer = ((_e = input.options) == null ? void 0 : _e.enableDevServer) !== false;
+    const enableTerminal = ((_f = input.options) == null ? void 0 : _f.enableTerminal) ?? false;
+    const oneShot = ((_g = input.options) == null ? void 0 : _g.oneShot) ?? "default";
+    const setArguments = (_h = input.options) == null ? void 0 : _h.setArguments;
+    const executablePath = (_i = input.options) == null ? void 0 : _i.executablePath;
+    if (enableClaude || enableCode || enableDevServer || enableTerminal) {
+      logger.info("Launching workspace components...");
+      const { LoomLauncher } = await import("./LoomLauncher-JF7JZMTZ.js");
+      const { ClaudeContextManager } = await import("./ClaudeContextManager-3VXA6UPR.js");
+      const claudeContext = new ClaudeContextManager(void 0, void 0, this.settings);
+      const launcher = new LoomLauncher(claudeContext, this.settings);
+      await launcher.launchLoom({
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal,
+        worktreePath,
+        branchName,
+        port,
+        capabilities,
+        workflowType: input.type === "branch" ? "regular" : input.type,
+        identifier: input.identifier,
+        ...(issueData == null ? void 0 : issueData.title) && { title: issueData.title },
+        oneShot,
+        ...setArguments && { setArguments },
+        ...executablePath && { executablePath },
+        sourceEnvOnStart: settingsData.sourceEnvOnStart ?? false
+      });
+    }
+    const loom = {
+      id: this.generateLoomId(input),
+      path: worktreePath,
+      branch: branchName,
+      type: input.type,
+      identifier: input.identifier,
+      port,
+      createdAt: /* @__PURE__ */ new Date(),
+      // We don't have actual creation date, use now
+      lastAccessed: /* @__PURE__ */ new Date(),
+      ...databaseBranch !== void 0 && { databaseBranch },
+      ...capabilities.length > 0 && { capabilities },
+      ...Object.keys(binEntries).length > 0 && { binEntries },
+      ...issueData !== null && {
+        issueData: {
+          title: issueData.title,
+          body: issueData.body,
+          url: issueData.url,
+          state: issueData.state
+        }
+      }
+    };
+    logger.success(`Reused existing loom: ${loom.id} at ${loom.path}`);
+    return loom;
+  }
+};
+
+// src/lib/EnvironmentManager.ts
+import fs3 from "fs-extra";
+var logger2 = createLogger({ prefix: "\u{1F4DD}" });
+var EnvironmentManager = class {
+  constructor() {
+    this.backupSuffix = ".backup";
+  }
+  /**
+   * Set or update an environment variable in a .env file
+   * Ports functionality from bash/utils/env-utils.sh:setEnvVar()
+   * @returns The backup path if a backup was created
+   */
+  async setEnvVar(filePath, key, value, backup = false) {
+    const validation = validateEnvVariable(key, value);
+    if (!validation.valid) {
+      throw new Error(validation.error ?? "Invalid variable name");
+    }
+    const fileExists = await fs3.pathExists(filePath);
+    if (!fileExists) {
+      logger2.info(`Creating ${filePath} with ${key}...`);
+      const content = formatEnvLine(key, value);
+      await fs3.writeFile(filePath, content, "utf8");
+      logger2.success(`${filePath} created with ${key}`);
+      return;
+    }
+    const existingContent = await fs3.readFile(filePath, "utf8");
+    const envMap = parseEnvFile(existingContent);
+    let backupPath;
+    if (backup) {
+      backupPath = await this.createBackup(filePath);
+    }
+    envMap.set(key, value);
+    const lines = existingContent.split("\n");
+    const newLines = [];
+    let variableUpdated = false;
+    for (const line of lines) {
+      const trimmedLine = line.trim();
+      if (!trimmedLine || trimmedLine.startsWith("#")) {
+        newLines.push(line);
+        continue;
+      }
+      const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
+      const equalsIndex = cleanLine.indexOf("=");
+      if (equalsIndex !== -1) {
+        const lineKey = cleanLine.substring(0, equalsIndex).trim();
+        if (lineKey === key) {
+          newLines.push(formatEnvLine(key, value));
+          variableUpdated = true;
+          continue;
+        }
+      }
+      newLines.push(line);
+    }
+    if (!variableUpdated) {
+      logger2.info(`Adding ${key} to ${filePath}...`);
+      newLines.push(formatEnvLine(key, value));
+      logger2.success(`${key} added successfully`);
+    } else {
+      logger2.info(`Updating ${key} in ${filePath}...`);
+      logger2.success(`${key} updated successfully`);
+    }
+    const newContent = newLines.join("\n");
+    await fs3.writeFile(filePath, newContent, "utf8");
+    return backupPath;
+  }
+  /**
+   * Read and parse a .env file
+   */
+  async readEnvFile(filePath) {
+    try {
+      const content = await fs3.readFile(filePath, "utf8");
+      return parseEnvFile(content);
+    } catch (error) {
+      logger2.debug(
+        `Could not read env file ${filePath}: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return /* @__PURE__ */ new Map();
+    }
+  }
+  /**
+   * Get a specific environment variable from a .env file
+   * Returns null if file doesn't exist or variable is not found
+   */
+  async getEnvVariable(filePath, variableName) {
+    const envVars = await this.readEnvFile(filePath);
+    return envVars.get(variableName) ?? null;
+  }
+  /**
+   * Generic file copy helper that only copies if source exists
+   * Does not throw if source file doesn't exist - just logs and returns
+   * @private
+   */
+  async copyIfExists(source, destination) {
+    const sourceExists = await fs3.pathExists(source);
+    if (!sourceExists) {
+      logger2.debug(`Source file ${source} does not exist, skipping copy`);
+      return;
+    }
+    await fs3.copy(source, destination, { overwrite: false });
+    logger2.success(`Copied ${source} to ${destination}`);
+  }
+  /**
+   * Calculate unique port for workspace
+   * Implements:
+   * - Issue/PR: 3000 + issue/PR number
+   * - Branch: 3000 + deterministic hash offset (1-999)
+   */
+  calculatePort(options) {
+    const basePort = options.basePort ?? 3e3;
+    if (options.issueNumber !== void 0) {
+      const numericIssue = typeof options.issueNumber === "number" ? options.issueNumber : parseInt(String(options.issueNumber), 10);
+      if (!isNaN(numericIssue) && String(numericIssue) === String(options.issueNumber)) {
+        const port = basePort + numericIssue;
+        if (port > 65535) {
+          throw new Error(
+            `Calculated port ${port} exceeds maximum (65535). Use a lower base port or issue number.`
+          );
+        }
+        return port;
+      }
+      return calculatePortForBranch(String(options.issueNumber), basePort);
+    }
+    if (options.prNumber !== void 0) {
+      const port = basePort + options.prNumber;
+      if (port > 65535) {
+        throw new Error(
+          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or PR number.`
+        );
+      }
+      return port;
+    }
+    if (options.branchName !== void 0) {
+      return calculatePortForBranch(options.branchName, basePort);
+    }
+    return basePort;
+  }
+  /**
+   * Set port environment variable for workspace
+   */
+  async setPortForWorkspace(envFilePath, issueNumber, prNumber, branchName) {
+    const options = {};
+    if (issueNumber !== void 0) {
+      options.issueNumber = issueNumber;
+    }
+    if (prNumber !== void 0) {
+      options.prNumber = prNumber;
+    }
+    if (branchName !== void 0) {
+      options.branchName = branchName;
+    }
+    const port = this.calculatePort(options);
+    await this.setEnvVar(envFilePath, "PORT", String(port));
+    return port;
+  }
+  /**
+   * Validate environment configuration
+   */
+  async validateEnvFile(filePath) {
+    try {
+      const content = await fs3.readFile(filePath, "utf8");
+      const envMap = parseEnvFile(content);
+      const errors = [];
+      for (const [key, value] of envMap.entries()) {
+        const validation = validateEnvVariable(key, value);
+        if (!validation.valid) {
+          errors.push(`${key}: ${validation.error}`);
+        }
+      }
+      return {
+        valid: errors.length === 0,
+        errors
+      };
+    } catch (error) {
+      return {
+        valid: false,
+        errors: [
+          `Failed to read or parse file: ${error instanceof Error ? error.message : String(error)}`
+        ]
+      };
+    }
+  }
+  /**
+   * Create backup of existing file
+   */
+  async createBackup(filePath) {
+    const timestamp = (/* @__PURE__ */ new Date()).toISOString().replace(/[:.]/g, "-");
+    const backupPath = `${filePath}${this.backupSuffix}-${timestamp}`;
+    await fs3.copy(filePath, backupPath);
+    logger2.debug(`Created backup at ${backupPath}`);
+    return backupPath;
+  }
+};
+
+// src/lib/CLIIsolationManager.ts
+import fs4 from "fs-extra";
+import path3 from "path";
+import os from "os";
+var CLIIsolationManager = class {
+  constructor() {
+    this.iloomBinDir = path3.join(os.homedir(), ".iloom", "bin");
+  }
+  /**
+   * Setup CLI isolation for a worktree
+   * - Build the project
+   * - Create versioned symlinks
+   * - Check PATH configuration
+   * @param worktreePath Path to the worktree
+   * @param identifier Issue/PR number or branch identifier
+   * @param binEntries Bin entries from package.json
+   * @returns Array of created symlink names
+   */
+  async setupCLIIsolation(worktreePath, identifier, binEntries) {
+    await this.buildProject(worktreePath);
+    await this.verifyBinTargets(worktreePath, binEntries);
+    await fs4.ensureDir(this.iloomBinDir);
+    const symlinkNames = await this.createVersionedSymlinks(
+      worktreePath,
+      identifier,
+      binEntries
+    );
+    await this.ensureIloomBinInPath();
+    return symlinkNames;
+  }
+  /**
+   * Build the project using package.json build script
+   * @param worktreePath Path to the worktree
+   */
+  async buildProject(worktreePath) {
+    const pkgJson = await readPackageJson(worktreePath);
+    if (!hasScript(pkgJson, "build")) {
+      logger.warn("No build script found in package.json - skipping build");
+      return;
+    }
+    logger.info("Building CLI tool...");
+    await runScript("build", worktreePath, [], { quiet: true });
+    logger.success("Build completed");
+  }
+  /**
+   * Verify bin targets exist and are executable
+   * @param worktreePath Path to the worktree
+   * @param binEntries Bin entries from package.json
+   */
+  async verifyBinTargets(worktreePath, binEntries) {
+    for (const binPath of Object.values(binEntries)) {
+      const targetPath = path3.resolve(worktreePath, binPath);
+      const exists = await fs4.pathExists(targetPath);
+      if (!exists) {
+        throw new Error(`Bin target does not exist: ${targetPath}`);
+      }
+      try {
+        await fs4.access(targetPath, fs4.constants.X_OK);
+      } catch {
+      }
+    }
+  }
+  /**
+   * Create versioned symlinks in ~/.iloom/bin
+   * @param worktreePath Path to the worktree
+   * @param identifier Issue/PR number or branch identifier
+   * @param binEntries Bin entries from package.json
+   * @returns Array of created symlink names
+   */
+  async createVersionedSymlinks(worktreePath, identifier, binEntries) {
+    const symlinkNames = [];
+    for (const [binName, binPath] of Object.entries(binEntries)) {
+      const versionedName = `${binName}-${identifier}`;
+      const targetPath = path3.resolve(worktreePath, binPath);
+      const symlinkPath = path3.join(this.iloomBinDir, versionedName);
+      await fs4.symlink(targetPath, symlinkPath);
+      logger.success(`CLI available: ${versionedName}`);
+      symlinkNames.push(versionedName);
+    }
+    return symlinkNames;
+  }
+  /**
+   * Check if ~/.iloom/bin is in PATH and provide setup instructions
+   */
+  async ensureIloomBinInPath() {
+    const currentPath = process.env.PATH ?? "";
+    if (currentPath.includes(".iloom/bin")) {
+      return;
+    }
+    const shell = this.detectShell();
+    const rcFile = this.getShellRcFile(shell);
+    logger.warn("\n\u26A0\uFE0F  One-time PATH setup required:");
+    logger.warn(`   Add to ${rcFile}:`);
+    logger.warn(`   export PATH="$HOME/.iloom/bin:$PATH"`);
+    logger.warn(`   Then run: source ${rcFile}
+`);
+  }
+  /**
+   * Detect current shell
+   * @returns Shell name (zsh, bash, fish, etc.)
+   */
+  detectShell() {
+    const shell = process.env.SHELL ?? "";
+    return shell.split("/").pop() ?? "bash";
+  }
+  /**
+   * Get RC file path for shell
+   * @param shell Shell name
+   * @returns RC file path
+   */
+  getShellRcFile(shell) {
+    const rcFiles = {
+      zsh: "~/.zshrc",
+      bash: "~/.bashrc",
+      fish: "~/.config/fish/config.fish"
+    };
+    return rcFiles[shell] ?? "~/.bashrc";
+  }
+  /**
+   * Cleanup versioned CLI executables for a specific identifier
+   * Removes all symlinks matching the pattern: {binName}-{identifier}
+   *
+   * @param identifier - Issue/PR number or branch identifier
+   * @returns Array of removed symlink names
+   */
+  async cleanupVersionedExecutables(identifier) {
+    const removed = [];
+    try {
+      const files = await fs4.readdir(this.iloomBinDir);
+      for (const file of files) {
+        if (this.matchesIdentifier(file, identifier)) {
+          const symlinkPath = path3.join(this.iloomBinDir, file);
+          try {
+            await fs4.unlink(symlinkPath);
+            removed.push(file);
+          } catch (error) {
+            const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+            if (isEnoent) {
+              removed.push(file);
+              continue;
+            }
+            logger.warn(
+              `Failed to remove symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
+            );
+          }
+        }
+      }
+    } catch (error) {
+      const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+      if (isEnoent) {
+        logger.warn("No CLI executables directory found - nothing to cleanup");
+        return [];
+      }
+      throw error;
+    }
+    if (removed.length > 0) {
+      logger.success(`Removed CLI executables: ${removed.join(", ")}`);
+    }
+    return removed;
+  }
+  /**
+   * Find orphaned symlinks in ~/.iloom/bin
+   * Returns symlinks that point to non-existent targets
+   *
+   * @returns Array of orphaned symlink information
+   */
+  async findOrphanedSymlinks() {
+    const orphaned = [];
+    try {
+      const files = await fs4.readdir(this.iloomBinDir);
+      for (const file of files) {
+        const symlinkPath = path3.join(this.iloomBinDir, file);
+        try {
+          const stats = await fs4.lstat(symlinkPath);
+          if (stats.isSymbolicLink()) {
+            const target = await fs4.readlink(symlinkPath);
+            try {
+              await fs4.access(target);
+            } catch {
+              orphaned.push({
+                name: file,
+                path: symlinkPath,
+                brokenTarget: target
+              });
+            }
+          }
+        } catch (error) {
+          logger.warn(
+            `Failed to check symlink ${file}: ${error instanceof Error ? error.message : "Unknown error"}`
+          );
+        }
+      }
+    } catch (error) {
+      const isEnoent = error && typeof error === "object" && "code" in error && error.code === "ENOENT";
+      if (isEnoent) {
+        return [];
+      }
+      throw error;
+    }
+    return orphaned;
+  }
+  /**
+   * Cleanup all orphaned symlinks
+   * Removes symlinks that point to non-existent targets
+   *
+   * @returns Number of symlinks removed
+   */
+  async cleanupOrphanedSymlinks() {
+    const orphaned = await this.findOrphanedSymlinks();
+    let removedCount = 0;
+    for (const symlink of orphaned) {
+      try {
+        await fs4.unlink(symlink.path);
+        removedCount++;
+        logger.success(`Removed orphaned symlink: ${symlink.name}`);
+      } catch (error) {
+        logger.warn(
+          `Failed to remove orphaned symlink ${symlink.name}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+    return removedCount;
+  }
+  /**
+   * Check if a filename matches the versioned pattern for an identifier
+   * Pattern: {binName}-{identifier}
+   *
+   * @param fileName - Name of the file to check
+   * @param identifier - Issue/PR number or branch identifier
+   * @returns True if the filename matches the pattern
+   */
+  matchesIdentifier(fileName, identifier) {
+    const suffix = `-${identifier}`;
+    return fileName.endsWith(suffix);
+  }
+};
+
+// src/lib/DatabaseManager.ts
+var logger3 = createLogger({ prefix: "\u{1F5C2}\uFE0F" });
+var DatabaseManager = class {
+  constructor(provider, environment, databaseUrlEnvVarName = "DATABASE_URL") {
+    this.provider = provider;
+    this.environment = environment;
+    this.databaseUrlEnvVarName = databaseUrlEnvVarName;
+    if (databaseUrlEnvVarName !== "DATABASE_URL") {
+      logger3.debug(`\u{1F527} DatabaseManager configured with custom variable: ${databaseUrlEnvVarName}`);
+    } else {
+      logger3.debug("\u{1F527} DatabaseManager using default variable: DATABASE_URL");
+    }
+  }
+  /**
+   * Get the configured database URL environment variable name
+   */
+  getConfiguredVariableName() {
+    return this.databaseUrlEnvVarName;
+  }
+  /**
+   * Check if database branching should be used
+   * Requires BOTH conditions:
+   *   1. Database provider is properly configured (checked via provider.isConfigured())
+   *   2. .env file contains the configured database URL variable
+   */
+  async shouldUseDatabaseBranching(envFilePath) {
+    if (!this.provider.isConfigured()) {
+      logger3.debug("Skipping database branching: Database provider not configured");
+      return false;
+    }
+    const hasDatabaseUrl = await this.hasDatabaseUrlInEnv(envFilePath);
+    if (!hasDatabaseUrl) {
+      logger3.debug(
+        "Skipping database branching: configured database URL variable not found in .env file"
+      );
+      return false;
+    }
+    return true;
+  }
+  /**
+   * Create database branch only if configured
+   * Returns connection string if branch was created, null if skipped
+   *
+   * @param branchName - Name of the branch to create
+   * @param envFilePath - Path to .env file for configuration checks
+   * @param cwd - Optional working directory to run commands from
+   * @param fromBranch - Optional parent branch to create from (for child looms)
+   */
+  async createBranchIfConfigured(branchName, envFilePath, cwd, fromBranch) {
+    if (!await this.shouldUseDatabaseBranching(envFilePath)) {
+      return null;
+    }
+    if (!await this.provider.isCliAvailable()) {
+      logger3.warn("Skipping database branch creation: Neon CLI not available");
+      logger3.warn("Install with: npm install -g neonctl");
+      return null;
+    }
+    try {
+      const isAuth = await this.provider.isAuthenticated(cwd);
+      if (!isAuth) {
+        logger3.warn("Skipping database branch creation: Not authenticated with Neon CLI");
+        logger3.warn("Run: neon auth");
+        return null;
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger3.error(`Database authentication check failed: ${errorMessage}`);
+      throw error;
+    }
+    try {
+      const connectionString = await this.provider.createBranch(branchName, fromBranch, cwd);
+      logger3.success(`Database branch ready: ${this.provider.sanitizeBranchName(branchName)}`);
+      return connectionString;
+    } catch (error) {
+      logger3.error(
+        `Failed to create database branch: ${error instanceof Error ? error.message : String(error)}`
+      );
+      throw error;
+    }
+  }
+  /**
+   * Delete database branch only if configured
+   * Returns result object indicating what happened
+   *
+   * @param branchName - Name of the branch to delete
+   * @param shouldCleanup - Boolean indicating if database cleanup should be performed (pre-fetched config)
+   * @param isPreview - Whether this is a preview database branch
+   * @param cwd - Optional working directory to run commands from (prevents issues with deleted directories)
+   */
+  async deleteBranchIfConfigured(branchName, shouldCleanup, isPreview = false, cwd) {
+    if (shouldCleanup === false) {
+      return {
+        success: true,
+        deleted: false,
+        notFound: true,
+        // Treat "not configured" as "nothing to delete"
+        branchName
+      };
+    }
+    if (!this.provider.isConfigured()) {
+      logger3.debug("Skipping database branch deletion: Database provider not configured");
+      return {
+        success: true,
+        deleted: false,
+        notFound: true,
+        branchName
+      };
+    }
+    if (!await this.provider.isCliAvailable()) {
+      logger3.info("Skipping database branch deletion: CLI tool not available");
+      return {
+        success: false,
+        deleted: false,
+        notFound: true,
+        error: "CLI tool not available",
+        branchName
+      };
+    }
+    try {
+      const isAuth = await this.provider.isAuthenticated(cwd);
+      if (!isAuth) {
+        logger3.warn("Skipping database branch deletion: Not authenticated with DB Provider");
+        return {
+          success: false,
+          deleted: false,
+          notFound: false,
+          error: "Not authenticated with DB Provider",
+          branchName
+        };
+      }
+    } catch (error) {
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      logger3.error(`Database authentication check failed: ${errorMessage}`);
+      return {
+        success: false,
+        deleted: false,
+        notFound: false,
+        error: `Authentication check failed: ${errorMessage}`,
+        branchName
+      };
+    }
+    try {
+      const result = await this.provider.deleteBranch(branchName, isPreview, cwd);
+      return result;
+    } catch (error) {
+      logger3.warn(
+        `Unexpected error in database deletion: ${error instanceof Error ? error.message : String(error)}`
+      );
+      return {
+        success: false,
+        deleted: false,
+        notFound: false,
+        error: error instanceof Error ? error.message : String(error),
+        branchName
+      };
+    }
+  }
+  /**
+   * Get database branch name from connection string (reverse lookup)
+   * Returns branch name if provider supports reverse lookup, null otherwise
+   *
+   * @param connectionString - Database connection string
+   * @param cwd - Optional working directory to run commands from
+   */
+  async getBranchNameFromConnectionString(connectionString, cwd) {
+    if (!this.provider.isConfigured()) {
+      logger3.debug("Provider not configured, skipping reverse lookup");
+      return null;
+    }
+    if ("getBranchNameFromConnectionString" in this.provider && typeof this.provider.getBranchNameFromConnectionString === "function") {
+      return this.provider.getBranchNameFromConnectionString(connectionString, cwd);
+    }
+    logger3.debug("Provider does not support reverse lookup");
+    return null;
+  }
+  /**
+   * Check if .env has the configured database URL variable
+   * CRITICAL: If user explicitly configured a custom variable name (not default),
+   * throw an error if it's missing from .env
+   */
+  async hasDatabaseUrlInEnv(envFilePath) {
+    try {
+      const envMap = await this.environment.readEnvFile(envFilePath);
+      if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
+        logger3.debug(`Looking for custom database URL variable: ${this.databaseUrlEnvVarName}`);
+      } else {
+        logger3.debug("Looking for default database URL variable: DATABASE_URL");
+      }
+      if (envMap.has(this.databaseUrlEnvVarName)) {
+        if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
+          logger3.debug(`\u2705 Found custom database URL variable: ${this.databaseUrlEnvVarName}`);
+        } else {
+          logger3.debug(`\u2705 Found default database URL variable: DATABASE_URL`);
+        }
+        return true;
+      }
+      if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
+        logger3.debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in .env file`);
+        throw new Error(
+          `Configured database URL environment variable '${this.databaseUrlEnvVarName}' not found in .env file. Please add it to your .env file or update your iloom configuration.`
+        );
+      }
+      const hasDefaultVar = envMap.has("DATABASE_URL");
+      if (hasDefaultVar) {
+        logger3.debug("\u2705 Found fallback DATABASE_URL variable");
+      } else {
+        logger3.debug("\u274C No DATABASE_URL variable found in .env file");
+      }
+      return hasDefaultVar;
+    } catch (error) {
+      if (error instanceof Error && error.message.includes("not found in .env")) {
+        throw error;
+      }
+      return false;
+    }
+  }
+};
+
+// 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();
+  }
+  /**
+   * 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;
+    const operations = [];
+    const errors = [];
+    const displayIdentifier = parsed.branchName ?? ((_a = parsed.number) == null ? void 0 : _a.toString()) ?? parsed.originalInput;
+    logger.info(`Starting cleanup for: ${displayIdentifier}`);
+    const number = parsed.number;
+    if (number !== void 0) {
+      const port = this.processManager.calculatePort(number);
+      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}`);
+      }
+      logger.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
+      };
+    }
+    if (!options.force) {
+      const safety = await this.validateWorktreeSafety(worktree, parsed.originalInput);
+      if (!safety.isSafe) {
+        const blockerMessage = safety.blockers.join("\n\n");
+        throw new Error(`Cannot cleanup:
+
+${blockerMessage}`);
+      }
+      if (safety.warnings.length > 0) {
+        safety.warnings.forEach((warning) => {
+          logger.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) {
+        logger.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) {
+        logger.warn(
+          `Failed to find main worktree path: ${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 (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 };
+          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);
+          logger.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) {
+                logger.info(`Database branch deleted: ${worktree.branch}`);
+                operations.push({
+                  type: "database",
+                  success: true,
+                  message: `Database branch deleted`,
+                  deleted: true
+                });
+              } else if (deletionResult.notFound) {
+                logger.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) {
+                logger.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));
+                logger.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"));
+                logger.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)));
+              logger.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
+          });
+        }
+      }
+    }
+    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) {
+    logger.debug(`Checking for dev server on port ${port}`);
+    const processInfo = await this.processManager.detectDevServer(port);
+    if (!processInfo) {
+      logger.debug(`No process found on port ${port}`);
+      return false;
+    }
+    if (!processInfo.isDevServer) {
+      logger.warn(
+        `Process on port ${port} (${processInfo.name}) doesn't appear to be a dev server, skipping`
+      );
+      return false;
+    }
+    logger.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}`);
+    }
+    if (options.dryRun) {
+      logger.info(`[DRY RUN] Would delete branch: ${branchName}`);
+      return true;
+    }
+    try {
+      let workingDir = cwd ?? await findMainWorktreePathWithSettings(void 0, this.settingsManager);
+      const deleteFlag = options.force ? "-D" : "-d";
+      await executeGitCommand(["branch", deleteFlag, branchName], {
+        cwd: workingDir
+      });
+      logger.info(`Branch deleted: ${branchName}`);
+      return true;
+    } catch (error) {
+      if (options.force) {
+        throw error;
+      }
+      const errorMessage = error instanceof Error ? error.message : String(error);
+      if (errorMessage.includes("not fully merged")) {
+        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) {
+      logger.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) {
+        logger.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) {
+        logger.info(`Database branch deleted: ${branchName}`);
+        return true;
+      } else if (result.notFound) {
+        logger.debug(`No database branch found for: ${branchName}`);
+        return false;
+      } else if (result.userDeclined) {
+        logger.info("Preview database deletion declined by user");
+        return false;
+      } else if (!result.success) {
+        logger.warn(`Database cleanup failed: ${result.error ?? "Unknown error"}`);
+        return false;
+      } else {
+        logger.debug("Database deletion returned unexpected result");
+        return false;
+      }
+    } catch (error) {
+      logger.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
+   */
+  async validateWorktreeSafety(worktree, identifier) {
+    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);
+    }
+    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
+};
+//# sourceMappingURL=chunk-HBYZH6GD.js.map