@iloom/cli 0.1.14

package/dist/start-LWVRBJ6S.js

@@ -0,0 +1,982 @@
+#!/usr/bin/env node
+import {
+  extractSettingsOverrides
+} from "./chunk-GYCR2LOU.js";
+import {
+  IssueEnhancementService
+} from "./chunk-PR7FKQBG.js";
+import {
+  AgentManager
+} from "./chunk-OC4H6HJD.js";
+import "./chunk-YETJNRQM.js";
+import {
+  CLIIsolationManager,
+  DatabaseManager,
+  EnvironmentManager
+} from "./chunk-HPJJSYNS.js";
+import "./chunk-37DYYFVK.js";
+import {
+  installDependencies
+} from "./chunk-BLCTGFZN.js";
+import {
+  NeonProvider
+} from "./chunk-YYSKGAZT.js";
+import {
+  ProjectCapabilityDetector
+} from "./chunk-CWR2SANQ.js";
+import "./chunk-2ZPFJQ3B.js";
+import {
+  calculateForegroundColor,
+  generateColorFromBranchName,
+  hexToRgb,
+  lightenColor,
+  rgbToHex
+} from "./chunk-ZZZWQGTS.js";
+import {
+  GitHubService
+} from "./chunk-T7QPXANZ.js";
+import "./chunk-KQDEK2ZW.js";
+import {
+  loadEnvIntoProcess
+} from "./chunk-SJUQ2NDR.js";
+import {
+  ClaudeContextManager
+} from "./chunk-Y7SAGNUT.js";
+import "./chunk-WKEWRSDB.js";
+import "./chunk-PXZBAC2M.js";
+import "./chunk-F3XBU2R7.js";
+import {
+  GitWorktreeManager
+} from "./chunk-QEPVTTHD.js";
+import {
+  SettingsManager
+} from "./chunk-JBH2ZYYZ.js";
+import {
+  branchExists,
+  ensureRepositoryHasCommits,
+  executeGitCommand,
+  findMainWorktreePathWithSettings
+} from "./chunk-JQ7VOSTC.js";
+import "./chunk-JNKJ7NJV.js";
+import {
+  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, github, environment, _claude, capabilityDetector, cliIsolation, settings, database) {
+    this.gitWorktree = gitWorktree;
+    this.github = github;
+    this.environment = environment;
+    this.capabilityDetector = capabilityDetector;
+    this.cliIsolation = cliIsolation;
+    this.settings = settings;
+    this.database = database;
+  }
+  /**
+   * 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;
+    logger.info("Fetching GitHub data...");
+    const githubData = await this.fetchGitHubData(input);
+    if (input.type === "issue" || input.type === "pr") {
+      logger.info("Checking for existing worktree...");
+      const existing = await this.findExistingIloom(input, githubData);
+      if (existing) {
+        logger.success(`Found existing worktree, reusing: ${existing.path}`);
+        return await this.reuseIloom(existing, input, githubData);
+      }
+      logger.info("No existing worktree found, creating new one...");
+    }
+    logger.info("Preparing branch name...");
+    const branchName = await this.prepareBranchName(input, githubData);
+    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);
+    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);
+    }
+    try {
+      await installDependencies(worktreePath, true);
+    } catch (error) {
+      logger.warn(`Failed to install dependencies: ${error instanceof Error ? error.message : "Unknown error"}`, error);
+    }
+    let databaseBranch = void 0;
+    if (this.database && !((_c = input.options) == null ? void 0 : _c.skipDatabase)) {
+      try {
+        const connectionString = await this.database.createBranchIfConfigured(
+          branchName,
+          path2.join(worktreePath, ".env")
+        );
+        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 (!((_d = input.options) == null ? void 0 : _d.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...");
+        await this.github.moveIssueToInProgress(input.identifier);
+      } catch (error) {
+        logger.warn(
+          `Failed to move issue to In Progress: ${error instanceof Error ? error.message : "Unknown error"}`,
+          error
+        );
+      }
+    }
+    const enableClaude = ((_e = input.options) == null ? void 0 : _e.enableClaude) !== false;
+    const enableCode = ((_f = input.options) == null ? void 0 : _f.enableCode) !== false;
+    const enableDevServer = ((_g = input.options) == null ? void 0 : _g.enableDevServer) !== false;
+    const enableTerminal = ((_h = input.options) == null ? void 0 : _h.enableTerminal) ?? false;
+    const oneShot = ((_i = input.options) == null ? void 0 : _i.oneShot) ?? "default";
+    const setArguments = (_j = input.options) == null ? void 0 : _j.setArguments;
+    const executablePath = (_k = input.options) == null ? void 0 : _k.executablePath;
+    if (enableClaude || enableCode || enableDevServer || enableTerminal) {
+      const { LoomLauncher } = await import("./LoomLauncher-MODG2SEM.js");
+      const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-XOSXQ67R.js");
+      const claudeContext = new ClaudeContextManager2(void 0, void 0, this.settings);
+      const launcher = new LoomLauncher(claudeContext);
+      await launcher.launchLoom({
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal,
+        worktreePath,
+        branchName,
+        port,
+        capabilities,
+        workflowType: input.type === "branch" ? "regular" : input.type,
+        identifier: input.identifier,
+        ...(githubData == null ? void 0 : githubData.title) && { title: githubData.title },
+        oneShot,
+        ...setArguments && { setArguments },
+        ...executablePath && { executablePath }
+      });
+    }
+    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 },
+      ...githubData !== null && {
+        githubData: {
+          title: githubData.title,
+          body: githubData.body,
+          url: githubData.url,
+          state: githubData.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
+   */
+  async findIloom(identifier) {
+    const looms = await this.listLooms();
+    return looms.find(
+      (h) => h.id === identifier || h.identifier.toString() === identifier || h.branch === identifier
+    ) ?? null;
+  }
+  /**
+   * Fetch GitHub data based on input type
+   */
+  async fetchGitHubData(input) {
+    if (input.type === "issue") {
+      return await this.github.fetchIssue(input.identifier);
+    } else if (input.type === "pr") {
+      return await this.github.fetchPR(input.identifier);
+    }
+    return null;
+  }
+  /**
+   * Prepare branch name based on input type and GitHub data
+   */
+  async prepareBranchName(input, githubData) {
+    if (input.type === "branch") {
+      return input.identifier;
+    }
+    if (input.type === "pr" && githubData && "branch" in githubData) {
+      return githubData.branch;
+    }
+    if (input.type === "issue" && githubData) {
+      const branchName = await this.github.generateBranchName({
+        issueNumber: input.identifier,
+        title: githubData.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) {
+    logger.info("Ensuring repository has initial commit...");
+    await ensureRepositoryHasCommits(this.gitWorktree.workingDirectory);
+    const settingsData = await this.settings.loadSettings();
+    const worktreePrefix = settingsData.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.`
+      );
+    }
+    await this.gitWorktree.createWorktree({
+      path: worktreePath,
+      branch: branchName,
+      createBranch: input.type !== "pr",
+      // PRs use existing branches
+      ...input.baseBranch && { baseBranch: input.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
+   */
+  async copyIloomSettings(worktreePath) {
+    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);
+      }
+    } 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, githubData) {
+    if (input.type === "issue") {
+      return await this.gitWorktree.findWorktreeForIssue(input.identifier);
+    } else if (input.type === "pr" && githubData && "branch" in githubData) {
+      return await this.gitWorktree.findWorktreeForPR(
+        input.identifier,
+        githubData.branch
+      );
+    }
+    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, githubData) {
+    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...");
+        await this.github.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-MODG2SEM.js");
+      const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-XOSXQ67R.js");
+      const claudeContext = new ClaudeContextManager2(void 0, void 0, this.settings);
+      const launcher = new LoomLauncher(claudeContext);
+      await launcher.launchLoom({
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal,
+        worktreePath,
+        branchName,
+        port,
+        capabilities,
+        workflowType: input.type === "branch" ? "regular" : input.type,
+        identifier: input.identifier,
+        ...(githubData == null ? void 0 : githubData.title) && { title: githubData.title },
+        oneShot,
+        ...setArguments && { setArguments },
+        ...executablePath && { executablePath }
+      });
+    }
+    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 },
+      ...githubData !== null && {
+        githubData: {
+          title: githubData.title,
+          body: githubData.body,
+          url: githubData.url,
+          state: githubData.state
+        }
+      }
+    };
+    logger.success(`Reused existing loom: ${loom.id} at ${loom.path}`);
+    return loom;
+  }
+};
+
+// src/commands/start.ts
+var StartCommand = class {
+  constructor(gitHubService, loomManager, agentManager, settingsManager) {
+    this.loomManager = null;
+    this.gitHubService = gitHubService ?? new GitHubService();
+    this.agentManager = agentManager ?? new AgentManager();
+    this.settingsManager = settingsManager ?? new SettingsManager();
+    this.enhancementService = new IssueEnhancementService(
+      this.gitHubService,
+      this.agentManager,
+      this.settingsManager
+    );
+    this.providedLoomManager = loomManager;
+    const envResult = loadEnvIntoProcess();
+    if (envResult.error) {
+      logger.debug(`Environment loading warning: ${envResult.error.message}`);
+    }
+    if (envResult.parsed) {
+      logger.debug(`Loaded ${Object.keys(envResult.parsed).length} environment variables`);
+    }
+  }
+  /**
+   * Initialize LoomManager with the main worktree path
+   * Uses lazy initialization to ensure we have the correct path
+   */
+  async initializeLoomManager() {
+    var _a, _b, _c;
+    if (this.loomManager) {
+      return this.loomManager;
+    }
+    if (this.providedLoomManager) {
+      this.loomManager = this.providedLoomManager;
+      return this.loomManager;
+    }
+    const mainWorktreePath = await findMainWorktreePathWithSettings();
+    const environmentManager = new EnvironmentManager();
+    logger.debug("Environment variables for Neon:", {
+      NEON_PROJECT_ID: process.env.NEON_PROJECT_ID,
+      NEON_PARENT_BRANCH: process.env.NEON_PARENT_BRANCH,
+      hasNeonProjectId: !!process.env.NEON_PROJECT_ID,
+      hasNeonParentBranch: !!process.env.NEON_PARENT_BRANCH,
+      neonProjectIdLength: ((_a = process.env.NEON_PROJECT_ID) == null ? void 0 : _a.length) ?? 0
+    });
+    const neonProvider = new NeonProvider({
+      projectId: process.env.NEON_PROJECT_ID ?? "",
+      parentBranch: process.env.NEON_PARENT_BRANCH ?? ""
+    });
+    const settings = await this.settingsManager.loadSettings();
+    const databaseUrlEnvVarName = ((_c = (_b = settings.capabilities) == null ? void 0 : _b.database) == null ? void 0 : _c.databaseUrlEnvVarName) ?? "DATABASE_URL";
+    const databaseManager = new DatabaseManager(neonProvider, environmentManager, databaseUrlEnvVarName);
+    this.loomManager = new LoomManager(
+      new GitWorktreeManager(mainWorktreePath),
+      this.gitHubService,
+      environmentManager,
+      // Reuse same instance
+      new ClaudeContextManager(),
+      new ProjectCapabilityDetector(),
+      new CLIIsolationManager(),
+      this.settingsManager,
+      // Use same instance with CLI overrides
+      databaseManager
+      // Add database manager
+    );
+    return this.loomManager;
+  }
+  /**
+   * Main entry point for the start command
+   */
+  async execute(input) {
+    var _a, _b, _c;
+    try {
+      const loomManager = await this.initializeLoomManager();
+      const parsed = await this.parseInput(input.identifier);
+      await this.validateInput(parsed);
+      if (parsed.type === "description") {
+        const issueNumber = await this.enhanceAndCreateIssue(parsed.originalInput);
+        parsed.type = "issue";
+        parsed.number = issueNumber;
+      }
+      if (input.options.oneShot === "bypassPermissions") {
+        const { promptConfirmation } = await import("./prompt-ANTQWHUF.js");
+        const confirmed = await promptConfirmation(
+          "\u26A0\uFE0F  WARNING: bypassPermissions mode will allow Claude to execute all tool calls without confirmation. This can be dangerous. Do you want to proceed?"
+        );
+        if (!confirmed) {
+          logger.info("Operation cancelled by user");
+          process.exit(0);
+        }
+      }
+      const cliOverrides = extractSettingsOverrides();
+      const settings = await this.settingsManager.loadSettings(void 0, cliOverrides);
+      const workflowType = parsed.type === "branch" ? "regular" : parsed.type;
+      const workflowConfig = (_a = settings.workflows) == null ? void 0 : _a[workflowType];
+      const { extractRawSetArguments, getExecutablePath } = await import("./cli-overrides-XFZWY7CM.js");
+      const setArguments = extractRawSetArguments();
+      const executablePath = getExecutablePath();
+      logger.info(`\u2705 Validated input: ${this.formatParsedInput(parsed)}`);
+      const identifier = parsed.type === "branch" ? parsed.branchName ?? "" : parsed.number ?? 0;
+      const enableClaude = input.options.claude ?? (workflowConfig == null ? void 0 : workflowConfig.startAiAgent) ?? true;
+      const enableCode = input.options.code ?? (workflowConfig == null ? void 0 : workflowConfig.startIde) ?? true;
+      const enableDevServer = input.options.devServer ?? (workflowConfig == null ? void 0 : workflowConfig.startDevServer) ?? true;
+      const enableTerminal = input.options.terminal ?? (workflowConfig == null ? void 0 : workflowConfig.startTerminal) ?? false;
+      logger.debug("Final workflow config values:", {
+        enableClaude,
+        enableCode,
+        enableDevServer,
+        enableTerminal
+      });
+      const loom = await loomManager.createIloom({
+        type: parsed.type,
+        identifier,
+        originalInput: parsed.originalInput,
+        options: {
+          enableClaude,
+          enableCode,
+          enableDevServer,
+          enableTerminal,
+          ...input.options.oneShot && { oneShot: input.options.oneShot },
+          ...setArguments.length > 0 && { setArguments },
+          ...executablePath && { executablePath }
+        }
+      });
+      logger.success(`\u2705 Created loom: ${loom.id} at ${loom.path}`);
+      logger.info(`   Branch: ${loom.branch}`);
+      if ((_b = loom.capabilities) == null ? void 0 : _b.includes("web")) {
+        logger.info(`   Port: ${loom.port}`);
+      }
+      if ((_c = loom.githubData) == null ? void 0 : _c.title) {
+        logger.info(`   Title: ${loom.githubData.title}`);
+      }
+    } catch (error) {
+      if (error instanceof Error) {
+        logger.error(`\u274C ${error.message}`);
+      } else {
+        logger.error("\u274C An unknown error occurred");
+      }
+      throw error;
+    }
+  }
+  /**
+   * Parse input to determine type and extract relevant data
+   */
+  async parseInput(identifier) {
+    const trimmedIdentifier = identifier.trim();
+    if (!trimmedIdentifier) {
+      throw new Error("Missing required argument: identifier");
+    }
+    const spaceCount = (trimmedIdentifier.match(/ /g) ?? []).length;
+    if (trimmedIdentifier.length > 25 && spaceCount > 2) {
+      return {
+        type: "description",
+        originalInput: trimmedIdentifier
+      };
+    }
+    const prPattern = /^(?:pr|PR)[/-](\d+)$/;
+    const prMatch = trimmedIdentifier.match(prPattern);
+    if (prMatch == null ? void 0 : prMatch[1]) {
+      return {
+        type: "pr",
+        number: parseInt(prMatch[1], 10),
+        originalInput: trimmedIdentifier
+      };
+    }
+    const numericPattern = /^#?(\d+)$/;
+    const numericMatch = trimmedIdentifier.match(numericPattern);
+    if (numericMatch == null ? void 0 : numericMatch[1]) {
+      const number = parseInt(numericMatch[1], 10);
+      const detection = await this.gitHubService.detectInputType(
+        trimmedIdentifier
+      );
+      if (detection.type === "pr") {
+        return {
+          type: "pr",
+          number: detection.number ?? number,
+          originalInput: trimmedIdentifier
+        };
+      } else if (detection.type === "issue") {
+        return {
+          type: "issue",
+          number: detection.number ?? number,
+          originalInput: trimmedIdentifier
+        };
+      } else {
+        throw new Error(`Could not find issue or PR #${number}`);
+      }
+    }
+    return {
+      type: "branch",
+      branchName: trimmedIdentifier,
+      originalInput: trimmedIdentifier
+    };
+  }
+  /**
+   * Validate the parsed input based on its type
+   */
+  async validateInput(parsed) {
+    switch (parsed.type) {
+      case "pr": {
+        if (!parsed.number) {
+          throw new Error("Invalid PR number");
+        }
+        const pr = await this.gitHubService.fetchPR(parsed.number);
+        await this.gitHubService.validatePRState(pr);
+        logger.debug(`Validated PR #${parsed.number}`);
+        break;
+      }
+      case "issue": {
+        if (!parsed.number) {
+          throw new Error("Invalid issue number");
+        }
+        const issue = await this.gitHubService.fetchIssue(parsed.number);
+        await this.gitHubService.validateIssueState(issue);
+        logger.debug(`Validated issue #${parsed.number}`);
+        break;
+      }
+      case "branch": {
+        if (!parsed.branchName) {
+          throw new Error("Invalid branch name");
+        }
+        if (!this.isValidBranchName(parsed.branchName)) {
+          throw new Error(
+            "Invalid branch name. Use only letters, numbers, hyphens, underscores, and slashes"
+          );
+        }
+        const exists = await branchExists(parsed.branchName);
+        if (exists) {
+          throw new Error(`Branch '${parsed.branchName}' already exists`);
+        }
+        logger.debug(`Validated branch name: ${parsed.branchName}`);
+        break;
+      }
+      case "description": {
+        logger.debug("Detected description input", {
+          length: parsed.originalInput.length
+        });
+        break;
+      }
+      default: {
+        const unknownType = parsed;
+        throw new Error(`Unknown input type: ${unknownType.type}`);
+      }
+    }
+  }
+  /**
+   * Validate branch name format
+   */
+  isValidBranchName(branch) {
+    return /^[a-zA-Z0-9/_-]+$/.test(branch);
+  }
+  /**
+   * Format parsed input for display
+   */
+  formatParsedInput(parsed) {
+    switch (parsed.type) {
+      case "pr":
+        return `PR #${parsed.number}`;
+      case "issue":
+        return `Issue #${parsed.number}`;
+      case "branch":
+        return `Branch '${parsed.branchName}'`;
+      case "description":
+        return `Description: ${parsed.originalInput.slice(0, 50)}...`;
+      default:
+        return "Unknown input";
+    }
+  }
+  /**
+   * Enhance description using Claude AI and create GitHub issue
+   * Returns the new issue number
+   */
+  async enhanceAndCreateIssue(description) {
+    const enhancedDescription = await this.enhancementService.enhanceDescription(description);
+    const result = await this.enhancementService.createEnhancedIssue(description, enhancedDescription);
+    await this.enhancementService.waitForReviewAndOpen(result.number, true);
+    return result.number;
+  }
+};
+export {
+  StartCommand
+};
+//# sourceMappingURL=start-LWVRBJ6S.js.map