@iloom/cli 0.1.19 → 0.3.0

package/dist/start-CT2ZEFP2.js

@@ -1,983 +0,0 @@
-#!/usr/bin/env node
-import {
-  CLIIsolationManager,
-  DatabaseManager,
-  EnvironmentManager
-} from "./chunk-H5LDRGVK.js";
-import {
-  loadEnvIntoProcess
-} from "./chunk-ZMNQBJUI.js";
-import {
-  installDependencies
-} from "./chunk-BLCTGFZN.js";
-import {
-  ClaudeContextManager
-} from "./chunk-DEPYQRRB.js";
-import {
-  extractSettingsOverrides
-} from "./chunk-GYCR2LOU.js";
-import {
-  createNeonProviderFromSettings
-} from "./chunk-LAPY6NAE.js";
-import {
-  ProjectCapabilityDetector
-} from "./chunk-CWR2SANQ.js";
-import "./chunk-2ZPFJQ3B.js";
-import {
-  IssueEnhancementService
-} from "./chunk-PR7FKQBG.js";
-import {
-  AgentManager
-} from "./chunk-OC4H6HJD.js";
-import "./chunk-YETJNRQM.js";
-import {
-  getConfiguredRepoFromSettings,
-  hasMultipleRemotes
-} from "./chunk-FXV24OYZ.js";
-import {
-  calculateForegroundColor,
-  generateColorFromBranchName,
-  hexToRgb,
-  lightenColor,
-  rgbToHex
-} from "./chunk-ZZZWQGTS.js";
-import {
-  GitHubService
-} from "./chunk-ZWXJBSUW.js";
-import "./chunk-JXQXSC45.js";
-import "./chunk-ELFT36PV.js";
-import "./chunk-PXZBAC2M.js";
-import "./chunk-PVAVNJKS.js";
-import {
-  GitWorktreeManager
-} from "./chunk-IO4WFTL2.js";
-import {
-  SettingsManager
-} from "./chunk-VYQLLHZ7.js";
-import {
-  branchExists,
-  ensureRepositoryHasCommits,
-  executeGitCommand,
-  findMainWorktreePathWithSettings
-} from "./chunk-KOCQAD2E.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-UMMLPIZO.js");
-      const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-JKR4WGNU.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-UMMLPIZO.js");
-      const { ClaudeContextManager: ClaudeContextManager2 } = await import("./ClaudeContextManager-JKR4WGNU.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;
-    if (this.loomManager) {
-      return this.loomManager;
-    }
-    if (this.providedLoomManager) {
-      this.loomManager = this.providedLoomManager;
-      return this.loomManager;
-    }
-    const mainWorktreePath = await findMainWorktreePathWithSettings();
-    const settings = await this.settingsManager.loadSettings();
-    const environmentManager = new EnvironmentManager();
-    const neonProvider = createNeonProviderFromSettings(settings);
-    const databaseUrlEnvVarName = ((_b = (_a = settings.capabilities) == null ? void 0 : _a.database) == null ? void 0 : _b.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 initialSettings = await this.settingsManager.loadSettings();
-      let repo;
-      const multipleRemotes = await hasMultipleRemotes();
-      if (multipleRemotes) {
-        repo = await getConfiguredRepoFromSettings(initialSettings);
-        logger.info(`Using GitHub repository: ${repo}`);
-      }
-      const loomManager = await this.initializeLoomManager();
-      const parsed = await this.parseInput(input.identifier, repo);
-      await this.validateInput(parsed, repo);
-      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, repo) {
-    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,
-        repo
-      );
-      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, repo) {
-    switch (parsed.type) {
-      case "pr": {
-        if (!parsed.number) {
-          throw new Error("Invalid PR number");
-        }
-        const pr = await this.gitHubService.fetchPR(parsed.number, repo);
-        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, repo);
-        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-CT2ZEFP2.js.map