@iloom/cli 0.1.14

package/dist/index.js

@@ -0,0 +1,3058 @@
+var __defProp = Object.defineProperty;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __esm = (fn, res) => function __init() {
+  return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+
+// src/utils/logger.ts
+var logger_exports = {};
+__export(logger_exports, {
+  createLogger: () => createLogger,
+  default: () => logger_default,
+  logger: () => logger
+});
+import chalk, { Chalk } from "chalk";
+function formatMessage(message, ...args) {
+  const formattedArgs = args.map(
+    (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
+  );
+  return formattedArgs.length > 0 ? `${message} ${formattedArgs.join(" ")}` : message;
+}
+function formatWithEmoji(message, emoji, colorFn) {
+  if (message.trim()) {
+    return colorFn(`${emoji} ${message}`);
+  } else {
+    return "";
+  }
+}
+function createLogger(options = {}) {
+  const { prefix = "", timestamp = false, silent = false, forceColor, debug = globalDebugEnabled } = options;
+  let localDebugEnabled = debug;
+  const customStdoutChalk = forceColor !== void 0 ? new Chalk({ level: forceColor ? 3 : 0 }) : stdoutChalk;
+  const customStderrChalk = forceColor !== void 0 ? new Chalk({ level: forceColor ? 3 : 0 }) : stderrChalk;
+  const prefixStr = prefix ? `[${prefix}] ` : "";
+  const getTimestamp = () => timestamp ? `[${(/* @__PURE__ */ new Date()).toISOString()}] ` : "";
+  if (silent) {
+    return {
+      info: () => {
+      },
+      success: () => {
+      },
+      warn: () => {
+      },
+      error: () => {
+      },
+      debug: () => {
+      },
+      setDebug: () => {
+      },
+      isDebugEnabled: () => {
+        return false;
+      }
+    };
+  }
+  return {
+    info: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", customStdoutChalk.blue);
+      console.log(output);
+    },
+    success: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u2705", customStdoutChalk.green);
+      console.log(output);
+    },
+    warn: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", customStderrChalk.yellow);
+      console.error(output);
+    },
+    error: (message, ...args) => {
+      const formatted = formatMessage(message, ...args);
+      const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+      const output = formatWithEmoji(fullMessage, "\u274C", customStderrChalk.red);
+      console.error(output);
+    },
+    debug: (message, ...args) => {
+      if (localDebugEnabled) {
+        const formatted = formatMessage(message, ...args);
+        const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
+        const output = formatWithEmoji(fullMessage, "\u{1F50D}", customStdoutChalk.gray);
+        console.log(output);
+      }
+    },
+    setDebug: (enabled) => {
+      localDebugEnabled = enabled;
+    },
+    isDebugEnabled: () => {
+      return globalDebugEnabled;
+    }
+  };
+}
+var stdoutChalk, stderrChalk, globalDebugEnabled, logger, logger_default;
+var init_logger = __esm({
+  "src/utils/logger.ts"() {
+    "use strict";
+    stdoutChalk = new Chalk({ level: chalk.level });
+    stderrChalk = new Chalk({ level: chalk.level });
+    globalDebugEnabled = false;
+    logger = {
+      info: (message, ...args) => {
+        const formatted = formatMessage(message, ...args);
+        const output = formatWithEmoji(formatted, "\u{1F5C2}\uFE0F ", stdoutChalk.blue);
+        console.log(output);
+      },
+      success: (message, ...args) => {
+        const formatted = formatMessage(message, ...args);
+        const output = formatWithEmoji(formatted, "\u2705", stdoutChalk.green);
+        console.log(output);
+      },
+      warn: (message, ...args) => {
+        const formatted = formatMessage(message, ...args);
+        const output = formatWithEmoji(formatted, "\u26A0\uFE0F ", stderrChalk.yellow);
+        console.error(output);
+      },
+      error: (message, ...args) => {
+        const formatted = formatMessage(message, ...args);
+        const output = formatWithEmoji(formatted, "\u274C", stderrChalk.red);
+        console.error(output);
+      },
+      debug: (message, ...args) => {
+        if (globalDebugEnabled) {
+          const formatted = formatMessage(message, ...args);
+          const output = formatWithEmoji(formatted, "\u{1F50D}", stdoutChalk.gray);
+          console.log(output);
+        }
+      },
+      setDebug: (enabled) => {
+        globalDebugEnabled = enabled;
+      },
+      isDebugEnabled: () => {
+        return globalDebugEnabled;
+      }
+    };
+    logger_default = logger;
+  }
+});
+
+// src/lib/SettingsManager.ts
+var SettingsManager_exports = {};
+__export(SettingsManager_exports, {
+  AgentSettingsSchema: () => AgentSettingsSchema,
+  CapabilitiesSettingsSchema: () => CapabilitiesSettingsSchema,
+  IloomSettingsSchema: () => IloomSettingsSchema,
+  SettingsManager: () => SettingsManager,
+  WorkflowPermissionSchema: () => WorkflowPermissionSchema,
+  WorkflowsSettingsSchema: () => WorkflowsSettingsSchema
+});
+import { readFile } from "fs/promises";
+import path from "path";
+import { z } from "zod";
+import deepmerge from "deepmerge";
+var AgentSettingsSchema, WorkflowPermissionSchema, WorkflowsSettingsSchema, CapabilitiesSettingsSchema, IloomSettingsSchema, SettingsManager;
+var init_SettingsManager = __esm({
+  "src/lib/SettingsManager.ts"() {
+    "use strict";
+    init_logger();
+    AgentSettingsSchema = z.object({
+      model: z.enum(["sonnet", "opus", "haiku"]).optional().describe("Claude model shorthand: sonnet, opus, or haiku")
+      // Future: could add other per-agent overrides
+    });
+    WorkflowPermissionSchema = z.object({
+      permissionMode: z.enum(["plan", "acceptEdits", "bypassPermissions", "default"]).optional().describe("Permission mode for Claude CLI in this workflow type"),
+      noVerify: z.boolean().optional().describe("Skip pre-commit hooks (--no-verify) when committing during finish workflow"),
+      startIde: z.boolean().default(true).describe("Launch IDE (code) when starting this workflow type"),
+      startDevServer: z.boolean().default(true).describe("Launch development server when starting this workflow type"),
+      startAiAgent: z.boolean().default(true).describe("Launch Claude AI agent when starting this workflow type"),
+      startTerminal: z.boolean().default(false).describe("Launch terminal window without dev server when starting this workflow type")
+    });
+    WorkflowsSettingsSchema = z.object({
+      issue: WorkflowPermissionSchema.optional(),
+      pr: WorkflowPermissionSchema.optional(),
+      regular: WorkflowPermissionSchema.optional()
+    }).optional();
+    CapabilitiesSettingsSchema = z.object({
+      web: z.object({
+        basePort: z.number().min(1, "Base port must be >= 1").max(65535, "Base port must be <= 65535").optional().describe("Base port for web workspace port calculations (default: 3000)")
+      }).optional(),
+      database: z.object({
+        databaseUrlEnvVarName: z.string().min(1, "Database URL variable name cannot be empty").regex(/^[A-Z_][A-Z0-9_]*$/, "Must be valid env var name (uppercase, underscores)").optional().default("DATABASE_URL").describe("Name of environment variable for database connection URL")
+      }).optional()
+    }).optional();
+    IloomSettingsSchema = z.object({
+      mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
+      worktreePrefix: z.string().optional().refine(
+        (val) => {
+          if (val === void 0) return true;
+          if (val === "") return true;
+          const allowedChars = /^[a-zA-Z0-9\-_/]+$/;
+          if (!allowedChars.test(val)) return false;
+          if (/^[-_/]+$/.test(val)) return false;
+          const segments = val.split("/");
+          for (const segment of segments) {
+            if (segment && /^[-_]+$/.test(segment)) {
+              return false;
+            }
+          }
+          return true;
+        },
+        {
+          message: "worktreePrefix contains invalid characters. Only alphanumeric characters, hyphens (-), underscores (_), and forward slashes (/) are allowed. Use forward slashes for nested directories."
+        }
+      ).describe(
+        "Prefix for worktree directories. Empty string disables prefix. Defaults to <repo-name>-looms if not set."
+      ),
+      protectedBranches: z.array(z.string().min(1, "Protected branch name cannot be empty")).optional().describe('List of branches that cannot be deleted (defaults to [mainBranch, "main", "master", "develop"])'),
+      workflows: WorkflowsSettingsSchema.describe("Per-workflow-type permission configurations"),
+      agents: z.record(z.string(), AgentSettingsSchema).optional().nullable().describe("Per-agent configuration overrides"),
+      capabilities: CapabilitiesSettingsSchema.describe("Project capability configurations")
+    });
+    SettingsManager = class {
+      /**
+       * Load settings from <PROJECT_ROOT>/.iloom/settings.json and settings.local.json
+       * Merges settings.local.json over settings.json with priority
+       * CLI overrides have highest priority if provided
+       * Returns empty object if both files don't exist (not an error)
+       */
+      async loadSettings(projectRoot, cliOverrides) {
+        const root = this.getProjectRoot(projectRoot);
+        const baseSettings = await this.loadSettingsFile(root, "settings.json");
+        const baseSettingsPath = path.join(root, ".iloom", "settings.json");
+        logger.debug(`\u{1F4C4} Base settings from ${baseSettingsPath}:`, JSON.stringify(baseSettings, null, 2));
+        const localSettings = await this.loadSettingsFile(root, "settings.local.json");
+        const localSettingsPath = path.join(root, ".iloom", "settings.local.json");
+        logger.debug(`\u{1F4C4} Local settings from ${localSettingsPath}:`, JSON.stringify(localSettings, null, 2));
+        let merged = this.mergeSettings(baseSettings, localSettings);
+        logger.debug("\u{1F504} After merging base + local settings:", JSON.stringify(merged, null, 2));
+        if (cliOverrides && Object.keys(cliOverrides).length > 0) {
+          logger.debug("\u2699\uFE0F CLI overrides to apply:", JSON.stringify(cliOverrides, null, 2));
+          merged = this.mergeSettings(merged, cliOverrides);
+          logger.debug("\u{1F504} After applying CLI overrides:", JSON.stringify(merged, null, 2));
+        }
+        try {
+          const finalSettings = IloomSettingsSchema.parse(merged);
+          this.logFinalConfiguration(finalSettings);
+          return finalSettings;
+        } catch (error) {
+          if (error instanceof z.ZodError) {
+            const errorMsg = this.formatAllZodErrors(error, "<merged settings>");
+            if (cliOverrides && Object.keys(cliOverrides).length > 0) {
+              throw new Error(`${errorMsg.message}
+
+Note: CLI overrides were applied. Check your --set arguments.`);
+            }
+            throw errorMsg;
+          }
+          throw error;
+        }
+      }
+      /**
+       * Log the final merged configuration for debugging
+       */
+      logFinalConfiguration(settings) {
+        logger.debug("\u{1F4CB} Final merged configuration:", JSON.stringify(settings, null, 2));
+      }
+      /**
+       * Load and parse a single settings file
+       * Returns empty object if file doesn't exist (not an error)
+       */
+      async loadSettingsFile(projectRoot, filename) {
+        const settingsPath = path.join(projectRoot, ".iloom", filename);
+        try {
+          const content = await readFile(settingsPath, "utf-8");
+          let parsed;
+          try {
+            parsed = JSON.parse(content);
+          } catch (error) {
+            throw new Error(
+              `Failed to parse settings file at ${settingsPath}: ${error instanceof Error ? error.message : "Invalid JSON"}`
+            );
+          }
+          try {
+            const validated = IloomSettingsSchema.strict().parse(parsed);
+            return validated;
+          } catch (error) {
+            if (error instanceof z.ZodError) {
+              const errorMsg = this.formatAllZodErrors(error, filename);
+              throw errorMsg;
+            }
+            throw error;
+          }
+        } catch (error) {
+          if (error.code === "ENOENT") {
+            logger.debug(`No settings file found at ${settingsPath}, using defaults`);
+            return {};
+          }
+          throw error;
+        }
+      }
+      /**
+       * Deep merge two settings objects with priority to override
+       * Uses deepmerge library with array replacement strategy
+       */
+      mergeSettings(base, override) {
+        return deepmerge(base, override, {
+          // Replace arrays instead of concatenating them
+          arrayMerge: (_destinationArray, sourceArray) => sourceArray
+        });
+      }
+      /**
+       * Format all Zod validation errors into a single error message
+       */
+      formatAllZodErrors(error, settingsPath) {
+        const errorMessages = error.issues.map((issue) => {
+          const path5 = issue.path.length > 0 ? issue.path.join(".") : "root";
+          return `  - ${path5}: ${issue.message}`;
+        });
+        return new Error(
+          `Settings validation failed at ${settingsPath}:
+${errorMessages.join("\n")}`
+        );
+      }
+      /**
+       * Validate settings structure and model names using Zod schema
+       * This method is kept for testing purposes but uses Zod internally
+       * @internal - Only used in tests via bracket notation
+       */
+      // @ts-expect-error - Used in tests via bracket notation, TypeScript can't detect this usage
+      validateSettings(settings) {
+        try {
+          IloomSettingsSchema.parse(settings);
+        } catch (error) {
+          if (error instanceof z.ZodError) {
+            throw this.formatAllZodErrors(error, "<validation>");
+          }
+          throw error;
+        }
+      }
+      /**
+       * Get project root (defaults to process.cwd())
+       */
+      getProjectRoot(projectRoot) {
+        return projectRoot ?? process.cwd();
+      }
+      /**
+       * Get effective protected branches list with mainBranch always included
+       *
+       * This method provides a single source of truth for protected branches logic:
+       * 1. Use configured protectedBranches if provided
+       * 2. Otherwise use defaults: [mainBranch, 'main', 'master', 'develop']
+       * 3. ALWAYS ensure mainBranch is included even if user configured custom list
+       *
+       * @param projectRoot - Optional project root directory (defaults to process.cwd())
+       * @returns Array of protected branch names with mainBranch guaranteed to be included
+       */
+      async getProtectedBranches(projectRoot) {
+        const settings = await this.loadSettings(projectRoot);
+        const mainBranch = settings.mainBranch ?? "main";
+        let protectedBranches;
+        if (settings.protectedBranches) {
+          protectedBranches = settings.protectedBranches.includes(mainBranch) ? settings.protectedBranches : [mainBranch, ...settings.protectedBranches];
+        } else {
+          protectedBranches = [mainBranch, "main", "master", "develop"];
+        }
+        return protectedBranches;
+      }
+    };
+  }
+});
+
+// src/utils/terminal.ts
+var terminal_exports = {};
+__export(terminal_exports, {
+  detectITerm2: () => detectITerm2,
+  detectPlatform: () => detectPlatform,
+  openDualTerminalWindow: () => openDualTerminalWindow,
+  openMultipleTerminalWindows: () => openMultipleTerminalWindows,
+  openTerminalWindow: () => openTerminalWindow
+});
+import { execa as execa2 } from "execa";
+import { existsSync } from "fs";
+function detectPlatform() {
+  const platform = process.platform;
+  if (platform === "darwin") return "darwin";
+  if (platform === "linux") return "linux";
+  if (platform === "win32") return "win32";
+  return "unsupported";
+}
+async function detectITerm2() {
+  const platform = detectPlatform();
+  if (platform !== "darwin") return false;
+  return existsSync("/Applications/iTerm.app");
+}
+async function openTerminalWindow(options) {
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    throw new Error(
+      `Terminal window launching not yet supported on ${platform}. Currently only macOS is supported.`
+    );
+  }
+  const applescript = buildAppleScript(options);
+  try {
+    await execa2("osascript", ["-e", applescript]);
+    await execa2("osascript", ["-e", 'tell application "Terminal" to activate']);
+  } catch (error) {
+    throw new Error(
+      `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+function buildAppleScript(options) {
+  const {
+    workspacePath,
+    command,
+    backgroundColor,
+    port,
+    includeEnvSetup,
+    includePortExport
+  } = options;
+  const commands = [];
+  if (workspacePath) {
+    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+  }
+  if (includeEnvSetup) {
+    commands.push("source .env");
+  }
+  if (includePortExport && port !== void 0) {
+    commands.push(`export PORT=${port}`);
+  }
+  if (command) {
+    commands.push(command);
+  }
+  const fullCommand = commands.join(" && ");
+  const historyFreeCommand = ` ${fullCommand}`;
+  let script = `tell application "Terminal"
+`;
+  script += `  set newTab to do script "${escapeForAppleScript(historyFreeCommand)}"
+`;
+  if (backgroundColor) {
+    const { r, g, b } = backgroundColor;
+    script += `  set background color of newTab to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+  }
+  script += `end tell`;
+  return script;
+}
+function escapePathForAppleScript(path5) {
+  return path5.replace(/'/g, "'\\''");
+}
+function escapeForAppleScript(command) {
+  return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+function buildCommandSequence(options) {
+  const {
+    workspacePath,
+    command,
+    port,
+    includeEnvSetup,
+    includePortExport
+  } = options;
+  const commands = [];
+  if (workspacePath) {
+    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+  }
+  if (includeEnvSetup) {
+    commands.push("source .env");
+  }
+  if (includePortExport && port !== void 0) {
+    commands.push(`export PORT=${port}`);
+  }
+  if (command) {
+    commands.push(command);
+  }
+  const fullCommand = commands.join(" && ");
+  return ` ${fullCommand}`;
+}
+function buildITerm2MultiTabScript(optionsArray) {
+  if (optionsArray.length < 2) {
+    throw new Error("buildITerm2MultiTabScript requires at least 2 terminal options");
+  }
+  let script = 'tell application id "com.googlecode.iterm2"\n';
+  script += "  create window with default profile\n";
+  script += "  set newWindow to current window\n";
+  const options1 = optionsArray[0];
+  if (!options1) {
+    throw new Error("First terminal option is undefined");
+  }
+  const command1 = buildCommandSequence(options1);
+  script += "  set s1 to current session of newWindow\n\n";
+  if (options1.backgroundColor) {
+    const { r, g, b } = options1.backgroundColor;
+    script += `  set background color of s1 to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+  }
+  script += `  tell s1 to write text "${escapeForAppleScript(command1)}"
+
+`;
+  if (options1.title) {
+    script += `  set name of s1 to "${escapeForAppleScript(options1.title)}"
+
+`;
+  }
+  for (let i = 1; i < optionsArray.length; i++) {
+    const options = optionsArray[i];
+    if (!options) {
+      throw new Error(`Terminal option at index ${i} is undefined`);
+    }
+    const command = buildCommandSequence(options);
+    const sessionVar = `s${i + 1}`;
+    script += "  tell newWindow\n";
+    script += `    set newTab${i} to (create tab with default profile)
+`;
+    script += "  end tell\n";
+    script += `  set ${sessionVar} to current session of newTab${i}
+
+`;
+    if (options.backgroundColor) {
+      const { r, g, b } = options.backgroundColor;
+      script += `  set background color of ${sessionVar} to {${Math.round(r * 257)}, ${Math.round(g * 257)}, ${Math.round(b * 257)}}
+`;
+    }
+    script += `  tell ${sessionVar} to write text "${escapeForAppleScript(command)}"
+
+`;
+    if (options.title) {
+      script += `  set name of ${sessionVar} to "${escapeForAppleScript(options.title)}"
+
+`;
+    }
+  }
+  script += "  activate\n";
+  script += "end tell";
+  return script;
+}
+async function openMultipleTerminalWindows(optionsArray) {
+  if (optionsArray.length < 2) {
+    throw new Error("openMultipleTerminalWindows requires at least 2 terminal options. Use openTerminalWindow for single terminal.");
+  }
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    throw new Error(
+      `Terminal window launching not yet supported on ${platform}. Currently only macOS is supported.`
+    );
+  }
+  const hasITerm2 = await detectITerm2();
+  if (hasITerm2) {
+    const applescript = buildITerm2MultiTabScript(optionsArray);
+    try {
+      await execa2("osascript", ["-e", applescript]);
+    } catch (error) {
+      throw new Error(
+        `Failed to open iTerm2 window: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  } else {
+    for (let i = 0; i < optionsArray.length; i++) {
+      const options = optionsArray[i];
+      if (!options) {
+        throw new Error(`Terminal option at index ${i} is undefined`);
+      }
+      await openTerminalWindow(options);
+      if (i < optionsArray.length - 1) {
+        await new Promise((resolve) => setTimeout(resolve, 1e3));
+      }
+    }
+  }
+}
+async function openDualTerminalWindow(options1, options2) {
+  await openMultipleTerminalWindows([options1, options2]);
+}
+var init_terminal = __esm({
+  "src/utils/terminal.ts"() {
+    "use strict";
+  }
+});
+
+// src/utils/color.ts
+var color_exports = {};
+__export(color_exports, {
+  calculateForegroundColor: () => calculateForegroundColor,
+  generateColorFromBranchName: () => generateColorFromBranchName,
+  getColorPalette: () => getColorPalette,
+  hexToRgb: () => hexToRgb,
+  lightenColor: () => lightenColor,
+  rgbToHex: () => rgbToHex,
+  saturateColor: () => saturateColor
+});
+import { createHash } from "crypto";
+function getColorPalette() {
+  return [
+    // First 10 colors preserved for backward compatibility
+    { r: 220, g: 235, b: 248 },
+    // 0: Soft blue
+    { r: 248, g: 220, b: 235 },
+    // 1: Soft pink
+    { r: 220, g: 248, b: 235 },
+    // 2: Soft green
+    { r: 248, g: 240, b: 220 },
+    // 3: Soft cream
+    { r: 240, g: 220, b: 248 },
+    // 4: Soft lavender
+    { r: 220, g: 240, b: 248 },
+    // 5: Soft cyan
+    { r: 235, g: 235, b: 235 },
+    // 6: Soft grey
+    { r: 228, g: 238, b: 248 },
+    // 7: Soft ice blue
+    { r: 248, g: 228, b: 238 },
+    // 8: Soft rose
+    { r: 228, g: 248, b: 238 },
+    // 9: Soft mint
+    // 30 new colors (indices 10-39)
+    { r: 235, g: 245, b: 250 },
+    // 10: Pale sky blue
+    { r: 250, g: 235, b: 245 },
+    // 11: Pale orchid
+    { r: 235, g: 250, b: 245 },
+    // 12: Pale seafoam
+    { r: 250, g: 245, b: 235 },
+    // 13: Pale peach
+    { r: 245, g: 235, b: 250 },
+    // 14: Pale periwinkle
+    { r: 235, g: 245, b: 235 },
+    // 15: Pale sage
+    { r: 245, g: 250, b: 235 },
+    // 16: Pale lemon
+    { r: 245, g: 235, b: 235 },
+    // 17: Pale blush
+    { r: 235, g: 235, b: 250 },
+    // 18: Pale lavender blue
+    { r: 250, g: 235, b: 235 },
+    // 19: Pale coral
+    { r: 235, g: 250, b: 250 },
+    // 20: Pale aqua
+    { r: 240, g: 248, b: 255 },
+    // 21: Alice blue
+    { r: 255, g: 240, b: 248 },
+    // 22: Lavender blush
+    { r: 240, g: 255, b: 248 },
+    // 23: Honeydew tint
+    { r: 255, g: 248, b: 240 },
+    // 24: Antique white
+    { r: 248, g: 240, b: 255 },
+    // 25: Magnolia
+    { r: 240, g: 248, b: 240 },
+    // 26: Mint cream tint
+    { r: 248, g: 255, b: 240 },
+    // 27: Ivory tint
+    { r: 248, g: 240, b: 240 },
+    // 28: Misty rose tint
+    { r: 240, g: 240, b: 255 },
+    // 29: Ghost white tint
+    { r: 255, g: 245, b: 238 },
+    // 30: Seashell
+    { r: 245, g: 255, b: 250 },
+    // 31: Azure mist
+    { r: 250, g: 245, b: 255 },
+    // 32: Lilac mist
+    { r: 255, g: 250, b: 245 },
+    // 33: Snow peach
+    { r: 238, g: 245, b: 255 },
+    // 34: Powder blue
+    { r: 255, g: 238, b: 245 },
+    // 35: Pink lace
+    { r: 245, g: 255, b: 238 },
+    // 36: Pale lime
+    { r: 238, g: 255, b: 245 },
+    // 37: Pale turquoise
+    { r: 245, g: 238, b: 255 },
+    // 38: Pale violet
+    { r: 255, g: 245, b: 255 }
+    // 39: Pale magenta
+  ];
+}
+function rgbToHex(r, g, b) {
+  if (r < 0 || r > 255 || g < 0 || g > 255 || b < 0 || b > 255) {
+    throw new Error("RGB values must be between 0 and 255");
+  }
+  const rHex = r.toString(16).padStart(2, "0");
+  const gHex = g.toString(16).padStart(2, "0");
+  const bHex = b.toString(16).padStart(2, "0");
+  return `#${rHex}${gHex}${bHex}`;
+}
+function hexToRgb(hex) {
+  const cleanHex = hex.startsWith("#") ? hex.slice(1) : hex;
+  if (cleanHex.length !== 6 || !/^[0-9a-fA-F]{6}$/.test(cleanHex)) {
+    throw new Error("Invalid hex color format. Expected format: #RRGGBB or RRGGBB");
+  }
+  const r = parseInt(cleanHex.slice(0, 2), 16);
+  const g = parseInt(cleanHex.slice(2, 4), 16);
+  const b = parseInt(cleanHex.slice(4, 6), 16);
+  return { r, g, b };
+}
+function generateColorFromBranchName(branchName) {
+  const hash = createHash("sha256").update(branchName).digest("hex");
+  const hashPrefix = hash.slice(0, 8);
+  const palette = getColorPalette();
+  const hashAsInt = parseInt(hashPrefix, 16);
+  const index = hashAsInt % palette.length;
+  logger_default.debug(`[generateColorFromBranchName] Branch name: ${branchName}, Hash: ${hash}, Hash prefix: ${hashPrefix}, Hash as int: ${hashAsInt}, Index: ${index}`);
+  const rgb = palette[index];
+  if (!rgb) {
+    throw new Error(`Invalid color index: ${index}`);
+  }
+  const hex = rgbToHex(rgb.r, rgb.g, rgb.b);
+  return {
+    rgb,
+    hex,
+    index
+  };
+}
+function lightenColor(rgb, amount) {
+  const clamp = (value) => Math.min(255, Math.max(0, Math.round(value)));
+  return {
+    r: clamp(rgb.r + (255 - rgb.r) * amount),
+    g: clamp(rgb.g + (255 - rgb.g) * amount),
+    b: clamp(rgb.b + (255 - rgb.b) * amount)
+  };
+}
+function saturateColor(rgb, amount) {
+  const clamp = (value) => Math.min(255, Math.max(0, Math.round(value)));
+  const avg = (rgb.r + rgb.g + rgb.b) / 3;
+  return {
+    r: clamp(rgb.r + (rgb.r - avg) * amount),
+    g: clamp(rgb.g + (rgb.g - avg) * amount),
+    b: clamp(rgb.b + (rgb.b - avg) * amount)
+  };
+}
+function calculateForegroundColor(rgb) {
+  const toLinear = (channel) => {
+    const c = channel / 255;
+    return c <= 0.03928 ? c / 12.92 : Math.pow((c + 0.055) / 1.055, 2.4);
+  };
+  const r = toLinear(rgb.r);
+  const g = toLinear(rgb.g);
+  const b = toLinear(rgb.b);
+  const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
+  return luminance > 0.5 ? "#000000" : "#ffffff";
+}
+var init_color = __esm({
+  "src/utils/color.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/utils/claude.ts
+var claude_exports = {};
+__export(claude_exports, {
+  detectClaudeCli: () => detectClaudeCli,
+  generateBranchName: () => generateBranchName,
+  getClaudeVersion: () => getClaudeVersion,
+  launchClaude: () => launchClaude,
+  launchClaudeInNewTerminalWindow: () => launchClaudeInNewTerminalWindow
+});
+import { execa as execa3 } from "execa";
+import { existsSync as existsSync2 } from "fs";
+import { join } from "path";
+async function detectClaudeCli() {
+  try {
+    await execa3("command", ["-v", "claude"], {
+      shell: true,
+      timeout: 5e3
+    });
+    return true;
+  } catch (error) {
+    logger.debug("Claude CLI not available", { error });
+    return false;
+  }
+}
+async function getClaudeVersion() {
+  try {
+    const result = await execa3("claude", ["--version"], {
+      timeout: 5e3
+    });
+    return result.stdout.trim();
+  } catch (error) {
+    logger.warn("Failed to get Claude version", { error });
+    return null;
+  }
+}
+function parseJsonStreamOutput(output) {
+  try {
+    const lines = output.split("\n").filter((line) => line.trim());
+    let lastResult = "";
+    for (const line of lines) {
+      try {
+        const jsonObj = JSON.parse(line);
+        if (jsonObj && typeof jsonObj === "object" && jsonObj.type === "result" && "result" in jsonObj) {
+          lastResult = jsonObj.result;
+        }
+      } catch {
+        continue;
+      }
+    }
+    return lastResult || output;
+  } catch {
+    return output;
+  }
+}
+async function launchClaude(prompt, options = {}) {
+  const { model, permissionMode, addDir, headless = false, appendSystemPrompt, mcpConfig, allowedTools, disallowedTools, agents } = options;
+  const args = [];
+  if (headless) {
+    args.push("-p");
+    args.push("--output-format", "stream-json");
+    args.push("--verbose");
+  }
+  if (model) {
+    args.push("--model", model);
+  }
+  if (permissionMode && permissionMode !== "default") {
+    args.push("--permission-mode", permissionMode);
+  }
+  if (addDir) {
+    args.push("--add-dir", addDir);
+  }
+  args.push("--add-dir", "/tmp");
+  if (appendSystemPrompt) {
+    args.push("--append-system-prompt", appendSystemPrompt);
+  }
+  if (mcpConfig && mcpConfig.length > 0) {
+    for (const config of mcpConfig) {
+      args.push("--mcp-config", JSON.stringify(config));
+    }
+  }
+  if (allowedTools && allowedTools.length > 0) {
+    args.push("--allowed-tools", ...allowedTools);
+  }
+  if (disallowedTools && disallowedTools.length > 0) {
+    args.push("--disallowed-tools", ...disallowedTools);
+  }
+  if (agents) {
+    args.push("--agents", JSON.stringify(agents));
+  }
+  try {
+    if (headless) {
+      const isDebugMode = logger.isDebugEnabled();
+      const execaOptions = {
+        input: prompt,
+        timeout: 0,
+        // Disable timeout for long responses
+        ...addDir && { cwd: addDir },
+        // Run Claude in the worktree directory
+        verbose: isDebugMode,
+        ...isDebugMode && { stdio: ["pipe", "pipe", "pipe"] }
+        // Enable streaming in debug mode
+      };
+      const subprocess = execa3("claude", args, execaOptions);
+      const isJsonStreamFormat = args.includes("--output-format") && args.includes("stream-json");
+      let outputBuffer = "";
+      let isStreaming = false;
+      let isFirstProgress = true;
+      if (subprocess.stdout && typeof subprocess.stdout.on === "function") {
+        isStreaming = true;
+        subprocess.stdout.on("data", (chunk) => {
+          const text = chunk.toString();
+          outputBuffer += text;
+          if (isDebugMode) {
+            process.stdout.write(text);
+          } else {
+            if (isFirstProgress) {
+              process.stdout.write("\u{1F916} .");
+              isFirstProgress = false;
+            } else {
+              process.stdout.write(".");
+            }
+          }
+        });
+      }
+      const result = await subprocess;
+      if (isStreaming) {
+        const rawOutput = outputBuffer.trim();
+        if (!isDebugMode) {
+          process.stdout.write("\n");
+        }
+        return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
+      } else {
+        if (isDebugMode) {
+          process.stdout.write(result.stdout);
+          if (result.stdout && !result.stdout.endsWith("\n")) {
+            process.stdout.write("\n");
+          }
+        } else {
+          process.stdout.write("\u{1F916} .");
+          process.stdout.write("\n");
+        }
+        const rawOutput = result.stdout.trim();
+        return isJsonStreamFormat ? parseJsonStreamOutput(rawOutput) : rawOutput;
+      }
+    } else {
+      await execa3("claude", [...args, "--", prompt], {
+        ...addDir && { cwd: addDir },
+        stdio: "inherit",
+        // Let user interact directly in current terminal
+        timeout: 0,
+        // Disable timeout
+        verbose: logger.isDebugEnabled()
+      });
+      return;
+    }
+  } catch (error) {
+    const execaError = error;
+    const errorMessage = execaError.stderr ?? execaError.message ?? "Unknown Claude CLI error";
+    throw new Error(`Claude CLI error: ${errorMessage}`);
+  }
+}
+async function launchClaudeInNewTerminalWindow(_prompt, options) {
+  const { workspacePath, branchName, oneShot = "default", port, setArguments, executablePath } = options;
+  if (!workspacePath) {
+    throw new Error("workspacePath is required for terminal window launch");
+  }
+  const { openTerminalWindow: openTerminalWindow2 } = await Promise.resolve().then(() => (init_terminal(), terminal_exports));
+  const executable = executablePath ?? "iloom";
+  let launchCommand = `${executable} spin`;
+  if (oneShot !== "default") {
+    launchCommand += ` --one-shot=${oneShot}`;
+  }
+  if (setArguments && setArguments.length > 0) {
+    for (const setArg of setArguments) {
+      launchCommand += ` --set ${setArg}`;
+    }
+  }
+  let backgroundColor;
+  if (branchName) {
+    try {
+      const { generateColorFromBranchName: generateColorFromBranchName2 } = await Promise.resolve().then(() => (init_color(), color_exports));
+      const colorData = generateColorFromBranchName2(branchName);
+      backgroundColor = colorData.rgb;
+    } catch (error) {
+      logger.warn(
+        `Failed to generate terminal color: ${error instanceof Error ? error.message : "Unknown error"}`
+      );
+    }
+  }
+  const hasEnvFile = existsSync2(join(workspacePath, ".env"));
+  await openTerminalWindow2({
+    workspacePath,
+    command: launchCommand,
+    ...backgroundColor && { backgroundColor },
+    includeEnvSetup: hasEnvFile,
+    // source .env only if it exists
+    ...port !== void 0 && { port, includePortExport: true }
+  });
+}
+async function generateBranchName(issueTitle, issueNumber, model = "haiku") {
+  try {
+    const isAvailable = await detectClaudeCli();
+    if (!isAvailable) {
+      logger.warn("Claude CLI not available, using fallback branch name");
+      return `feat/issue-${issueNumber}`;
+    }
+    logger.debug("Generating branch name with Claude", { issueNumber, issueTitle });
+    const prompt = `<Task>
+Generate a git branch name for the following issue:
+<Issue>
+<IssueNumber>${issueNumber}</IssueNumber>
+<IssueTitle>${issueTitle}</IssueTitle>
+</Issue>
+
+<Requirements>
+<IssueNumber>Must use this exact issue number: ${issueNumber}</IssueNumber>
+<Format>Format must be: {prefix}/issue-${issueNumber}-{description}</Format>
+<Prefix>Prefix must be one of: feat, fix, docs, refactor, test, chore</Prefix>
+<MaxLength>Maximum 50 characters total</MaxLength>
+<Characters>Only lowercase letters, numbers, and hyphens allowed</Characters>
+<Output>Reply with ONLY the branch name, nothing else</Output>
+</Requirements>
+</Task>`;
+    logger.debug("Sending prompt to Claude", { prompt });
+    const result = await launchClaude(prompt, {
+      model,
+      headless: true
+    });
+    const branchName = result.trim();
+    logger.debug("Claude returned branch name", { branchName, issueNumber });
+    if (!branchName || !isValidBranchName(branchName, issueNumber)) {
+      logger.warn("Invalid branch name from Claude, using fallback", { branchName });
+      return `feat/issue-${issueNumber}`;
+    }
+    return branchName;
+  } catch (error) {
+    logger.warn("Failed to generate branch name with Claude", { error });
+    return `feat/issue-${issueNumber}`;
+  }
+}
+function isValidBranchName(name, issueNumber) {
+  const pattern = new RegExp(`^(feat|fix|docs|refactor|test|chore)/issue-${issueNumber}-[a-z0-9-]+$`);
+  return pattern.test(name) && name.length <= 50;
+}
+var init_claude = __esm({
+  "src/utils/claude.ts"() {
+    "use strict";
+    init_logger();
+  }
+});
+
+// src/lib/WorkspaceManager.ts
+var WorkspaceManager = class {
+  // TODO: Implement in Issue #6
+};
+
+// src/lib/GitWorktreeManager.ts
+import path3 from "path";
+import fs from "fs-extra";
+
+// src/utils/git.ts
+init_logger();
+import path2 from "path";
+import { execa } from "execa";
+async function executeGitCommand(args, options) {
+  try {
+    const result = await execa("git", args, {
+      cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
+      timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
+      encoding: "utf8",
+      stdio: (options == null ? void 0 : options.stdio) ?? "pipe",
+      verbose: logger.isDebugEnabled()
+    });
+    return result.stdout;
+  } catch (error) {
+    const execaError = error;
+    const stderr = execaError.stderr ?? execaError.message ?? "Unknown Git error";
+    throw new Error(`Git command failed: ${stderr}`);
+  }
+}
+function parseWorktreeList(output, defaultBranch) {
+  var _a, _b;
+  const worktrees = [];
+  const lines = output.trim().split("\n");
+  let i = 0;
+  while (i < lines.length) {
+    const pathLine = lines[i];
+    if (!(pathLine == null ? void 0 : pathLine.startsWith("worktree "))) {
+      i++;
+      continue;
+    }
+    const pathMatch = pathLine.match(/^worktree (.+)$/);
+    if (!pathMatch) {
+      i++;
+      continue;
+    }
+    let branch = "";
+    let commit = "";
+    let detached = false;
+    let bare = false;
+    let locked = false;
+    let lockReason;
+    i++;
+    while (i < lines.length && !((_a = lines[i]) == null ? void 0 : _a.startsWith("worktree "))) {
+      const line = (_b = lines[i]) == null ? void 0 : _b.trim();
+      if (!line) {
+        i++;
+        continue;
+      }
+      if (line === "bare") {
+        bare = true;
+        branch = defaultBranch ?? "main";
+      } else if (line === "detached") {
+        detached = true;
+        branch = "HEAD";
+      } else if (line.startsWith("locked")) {
+        locked = true;
+        const lockMatch = line.match(/^locked (.+)$/);
+        lockReason = lockMatch == null ? void 0 : lockMatch[1];
+        branch = branch || "unknown";
+      } else if (line.startsWith("HEAD ")) {
+        const commitMatch = line.match(/^HEAD ([a-f0-9]+)/);
+        if (commitMatch) {
+          commit = commitMatch[1] ?? "";
+        }
+      } else if (line.startsWith("branch ")) {
+        const branchMatch = line.match(/^branch refs\/heads\/(.+)$/);
+        branch = (branchMatch == null ? void 0 : branchMatch[1]) ?? line.replace("branch ", "");
+      }
+      i++;
+    }
+    const worktree = {
+      path: pathMatch[1] ?? "",
+      branch,
+      commit,
+      bare,
+      detached,
+      locked
+    };
+    if (lockReason !== void 0) {
+      worktree.lockReason = lockReason;
+    }
+    worktrees.push(worktree);
+  }
+  return worktrees;
+}
+function isPRBranch(branchName) {
+  const prPatterns = [
+    /^pr\/\d+/i,
+    // pr/123, pr/123-feature-name
+    /^pull\/\d+/i,
+    // pull/123
+    /^\d+[-_]/,
+    // 123-feature-name, 123_feature_name
+    /^feature\/pr[-_]?\d+/i,
+    // feature/pr123, feature/pr-123
+    /^hotfix\/pr[-_]?\d+/i
+    // hotfix/pr123
+  ];
+  return prPatterns.some((pattern) => pattern.test(branchName));
+}
+function extractPRNumber(branchName) {
+  const patterns = [
+    /^pr\/(\d+)/i,
+    // pr/123
+    /^pull\/(\d+)/i,
+    // pull/123
+    /^(\d+)[-_]/,
+    // 123-feature-name
+    /^feature\/pr[-_]?(\d+)/i,
+    // feature/pr123
+    /^hotfix\/pr[-_]?(\d+)/i,
+    // hotfix/pr123
+    /pr[-_]?(\d+)/i
+    // anywhere with pr123 or pr-123
+  ];
+  for (const pattern of patterns) {
+    const match = branchName.match(pattern);
+    if (match == null ? void 0 : match[1]) {
+      const num = parseInt(match[1], 10);
+      if (!isNaN(num)) return num;
+    }
+  }
+  return null;
+}
+function isWorktreePath(path5) {
+  const worktreePatterns = [
+    /\/worktrees?\//i,
+    // Contains /worktree/ or /worktrees/
+    /\/workspace[-_]?\d+/i,
+    // workspace123, workspace-123
+    /\/issue[-_]?\d+/i,
+    // issue123, issue-123
+    /\/pr[-_]?\d+/i,
+    // pr123, pr-123
+    /-worktree$/i,
+    // ends with -worktree
+    /\.worktree$/i
+    // ends with .worktree
+  ];
+  return worktreePatterns.some((pattern) => pattern.test(path5));
+}
+function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
+  let sanitized = branchName.replace(/\//g, "-");
+  if ((options == null ? void 0 : options.isPR) && (options == null ? void 0 : options.prNumber)) {
+    sanitized = `${sanitized}_pr_${options.prNumber}`;
+  }
+  const parentDir = path2.dirname(rootDir);
+  let prefix;
+  if ((options == null ? void 0 : options.prefix) === void 0) {
+    const mainFolderName = path2.basename(rootDir);
+    prefix = mainFolderName ? `${mainFolderName}-looms/` : "looms/";
+  } else if (options.prefix === "") {
+    prefix = "";
+  } else {
+    prefix = options.prefix;
+    const hasNestedPath = prefix.includes("/");
+    if (hasNestedPath) {
+      const endsWithSeparator = /[-_/]$/.test(prefix);
+      if (!endsWithSeparator) {
+        prefix = `${prefix}-`;
+      }
+    } else {
+      const endsWithSeparator = /[-_]$/.test(prefix);
+      if (!endsWithSeparator) {
+        prefix = `${prefix}-`;
+      }
+    }
+  }
+  if (prefix === "") {
+    return path2.join(parentDir, sanitized);
+  } else if (prefix.endsWith("/")) {
+    return path2.join(parentDir, prefix, sanitized);
+  } else if (prefix.includes("/")) {
+    const lastSlashIndex = prefix.lastIndexOf("/");
+    const dirPath = prefix.substring(0, lastSlashIndex);
+    const prefixWithSeparator = prefix.substring(lastSlashIndex + 1);
+    return path2.join(parentDir, dirPath, `${prefixWithSeparator}${sanitized}`);
+  } else {
+    return path2.join(parentDir, `${prefix}${sanitized}`);
+  }
+}
+async function isValidGitRepo(path5) {
+  try {
+    await executeGitCommand(["rev-parse", "--git-dir"], { cwd: path5 });
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function getCurrentBranch(path5 = process.cwd()) {
+  try {
+    const result = await executeGitCommand(["branch", "--show-current"], { cwd: path5 });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+async function branchExists(branchName, path5 = process.cwd(), includeRemote = true) {
+  try {
+    const localResult = await executeGitCommand(["branch", "--list", branchName], { cwd: path5 });
+    if (localResult.trim()) {
+      return true;
+    }
+    if (includeRemote) {
+      const remoteResult = await executeGitCommand(["branch", "-r", "--list", `*/${branchName}`], {
+        cwd: path5
+      });
+      if (remoteResult.trim()) {
+        return true;
+      }
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+async function getRepoRoot(path5 = process.cwd()) {
+  try {
+    const result = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd: path5 });
+    return result.trim();
+  } catch {
+    return null;
+  }
+}
+async function findMainWorktreePath(path5 = process.cwd(), options) {
+  try {
+    const output = await executeGitCommand(["worktree", "list", "--porcelain"], { cwd: path5 });
+    const worktrees = parseWorktreeList(output, options == null ? void 0 : options.mainBranch);
+    if (worktrees.length === 0) {
+      throw new Error("No worktrees found in repository");
+    }
+    if (options == null ? void 0 : options.mainBranch) {
+      const specified = worktrees.find((wt) => wt.branch === options.mainBranch);
+      if (!(specified == null ? void 0 : specified.path)) {
+        throw new Error(
+          `No worktree found with branch '${options.mainBranch}' (specified in settings). Available worktrees: ${worktrees.map((wt) => `${wt.path} (${wt.branch})`).join(", ")}`
+        );
+      }
+      return specified.path;
+    }
+    const mainBranch = worktrees.find((wt) => wt.branch === "main");
+    if (mainBranch == null ? void 0 : mainBranch.path) {
+      return mainBranch.path;
+    }
+    const firstWorktree = worktrees[0];
+    if (!(firstWorktree == null ? void 0 : firstWorktree.path)) {
+      throw new Error("Failed to determine primary worktree path");
+    }
+    return firstWorktree.path;
+  } catch (error) {
+    if (error instanceof Error && (error.message.includes("No worktree found with branch") || error.message.includes("No worktrees found") || error.message.includes("Failed to determine primary worktree"))) {
+      throw error;
+    }
+    throw new Error(`Failed to find main worktree: ${error instanceof Error ? error.message : String(error)}`);
+  }
+}
+async function findMainWorktreePathWithSettings(path5, settingsManager) {
+  if (!settingsManager) {
+    const { SettingsManager: SM } = await Promise.resolve().then(() => (init_SettingsManager(), SettingsManager_exports));
+    settingsManager = new SM();
+  }
+  const settings = await settingsManager.loadSettings(path5);
+  const findOptions = settings.mainBranch ? { mainBranch: settings.mainBranch } : void 0;
+  return findMainWorktreePath(path5, findOptions);
+}
+async function hasUncommittedChanges(path5 = process.cwd()) {
+  try {
+    const result = await executeGitCommand(["status", "--porcelain"], { cwd: path5 });
+    return result.trim().length > 0;
+  } catch {
+    return false;
+  }
+}
+async function getDefaultBranch(path5 = process.cwd()) {
+  try {
+    const remoteResult = await executeGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"], {
+      cwd: path5
+    });
+    const match = remoteResult.match(/refs\/remotes\/origin\/(.+)/);
+    if (match) return match[1] ?? "main";
+    const commonDefaults = ["main", "master", "develop"];
+    for (const branch of commonDefaults) {
+      if (await branchExists(branch, path5)) {
+        return branch;
+      }
+    }
+    return "main";
+  } catch {
+    return "main";
+  }
+}
+async function findAllBranchesForIssue(issueNumber, path5 = process.cwd(), settingsManager) {
+  if (!settingsManager) {
+    const { SettingsManager: SM } = await Promise.resolve().then(() => (init_SettingsManager(), SettingsManager_exports));
+    settingsManager = new SM();
+  }
+  const protectedBranches = await settingsManager.getProtectedBranches(path5);
+  const output = await executeGitCommand(["branch", "-a"], { cwd: path5 });
+  const branches = [];
+  const lines = output.split("\n").filter(Boolean);
+  for (const line of lines) {
+    if (line.includes("remotes/origin/HEAD")) {
+      continue;
+    }
+    let cleanBranch = line.replace(/^[*+ ]+/, "");
+    cleanBranch = cleanBranch.replace(/^origin\//, "");
+    cleanBranch = cleanBranch.replace(/^remotes\/origin\//, "");
+    cleanBranch = cleanBranch.trim();
+    if (protectedBranches.includes(cleanBranch)) {
+      continue;
+    }
+    const notPartOfNumber = new RegExp(`(?<!\\d)${issueNumber}(?!\\d)`);
+    if (!notPartOfNumber.test(cleanBranch)) {
+      continue;
+    }
+    const beforeNumber = cleanBranch.substring(0, cleanBranch.indexOf(String(issueNumber)));
+    if (beforeNumber) {
+      const lastWord = beforeNumber.match(/([a-zA-Z]+)[-_/\s]*$/);
+      if (lastWord == null ? void 0 : lastWord[1]) {
+        const word = lastWord[1].toLowerCase();
+        const knownPrefixes = [
+          "issue",
+          "issues",
+          "feat",
+          "feature",
+          "features",
+          "fix",
+          "fixes",
+          "bugfix",
+          "hotfix",
+          "pr",
+          "pull",
+          "test",
+          "tests",
+          "chore",
+          "docs",
+          "refactor",
+          "perf",
+          "style",
+          "ci",
+          "build",
+          "revert"
+        ];
+        if (!knownPrefixes.includes(word)) {
+          continue;
+        }
+      }
+    }
+    if (!branches.includes(cleanBranch)) {
+      branches.push(cleanBranch);
+    }
+  }
+  return branches;
+}
+async function isEmptyRepository(path5 = process.cwd()) {
+  try {
+    await executeGitCommand(["rev-parse", "--verify", "HEAD"], { cwd: path5 });
+    return false;
+  } catch {
+    return true;
+  }
+}
+async function ensureRepositoryHasCommits(path5 = process.cwd()) {
+  const isEmpty = await isEmptyRepository(path5);
+  if (isEmpty) {
+    await executeGitCommand(["commit", "--no-verify", "--allow-empty", "-m", "Initial commit"], { cwd: path5 });
+  }
+}
+async function pushBranchToRemote(branchName, worktreePath, options) {
+  if (options == null ? void 0 : options.dryRun) {
+    return;
+  }
+  try {
+    await executeGitCommand(["push", "origin", branchName], {
+      cwd: worktreePath,
+      timeout: 12e4
+      // 120 second timeout for push operations
+    });
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("failed to push") || errorMessage.includes("rejected")) {
+      throw new Error(
+        `Failed to push changes to origin/${branchName}
+
+   Possible causes:
+   \u2022 Remote branch was deleted
+   \u2022 Push was rejected (non-fast-forward)
+   \u2022 Network connectivity issues
+
+   To retry: il finish --pr <number>
+   To force push: git push origin ${branchName} --force`
+      );
+    }
+    if (errorMessage.includes("Could not resolve host") || errorMessage.includes("network")) {
+      throw new Error(
+        `Failed to push changes to origin/${branchName}: Network connectivity issues
+
+   Check your internet connection and try again.`
+      );
+    }
+    if (errorMessage.includes("No such remote")) {
+      throw new Error(
+        `Failed to push changes: Remote 'origin' not found
+
+   Configure remote: git remote add origin <url>`
+      );
+    }
+    throw new Error(`Failed to push to remote: ${errorMessage}`);
+  }
+}
+
+// src/lib/GitWorktreeManager.ts
+var GitWorktreeManager = class {
+  constructor(workingDirectory = process.cwd()) {
+    this._workingDirectory = workingDirectory;
+  }
+  /**
+   * Get the working directory for git operations (main worktree path)
+   */
+  get workingDirectory() {
+    return this._workingDirectory;
+  }
+  /**
+   * List all worktrees in the repository
+   * Defaults to porcelain format for reliable machine parsing
+   * Equivalent to: git worktree list --porcelain
+   */
+  async listWorktrees(options = {}) {
+    const args = ["worktree", "list"];
+    if (options.porcelain !== false) args.push("--porcelain");
+    if (options.verbose) args.push("-v");
+    const output = await executeGitCommand(args, { cwd: this._workingDirectory });
+    return parseWorktreeList(output);
+  }
+  /**
+   * Find worktree for a specific branch
+   * Ports: find_worktree_for_branch() from find-worktree-for-branch.sh
+   */
+  async findWorktreeForBranch(branchName) {
+    const worktrees = await this.listWorktrees();
+    return worktrees.find((wt) => wt.branch === branchName) ?? null;
+  }
+  /**
+   * Check if a worktree is the main repository worktree
+   * The main worktree is the first one listed by git worktree list (Git guarantee)
+   * This cannot be determined by path comparison because --show-toplevel returns
+   * the same value for all worktrees.
+   */
+  async isMainWorktree(worktree) {
+    const worktrees = await this.listWorktrees();
+    const mainWorktree = worktrees[0];
+    return mainWorktree !== void 0 && mainWorktree.path === worktree.path;
+  }
+  /**
+   * Check if a worktree is a PR worktree based on naming patterns
+   * Ports: is_pr_worktree() from worktree-utils.sh
+   */
+  isPRWorktree(worktree) {
+    return isPRBranch(worktree.branch);
+  }
+  /**
+   * Get PR number from worktree branch name
+   * Ports: get_pr_number_from_worktree() from worktree-utils.sh
+   */
+  getPRNumberFromWorktree(worktree) {
+    return extractPRNumber(worktree.branch);
+  }
+  /**
+   * Create a new worktree
+   * Ports worktree creation logic from new-branch-workflow.sh
+   * @returns The absolute path to the created worktree
+   */
+  async createWorktree(options) {
+    if (!options.branch) {
+      throw new Error("Branch name is required");
+    }
+    const absolutePath = path3.resolve(options.path);
+    if (await fs.pathExists(absolutePath)) {
+      if (!options.force) {
+        throw new Error(`Path already exists: ${absolutePath}`);
+      }
+      await fs.remove(absolutePath);
+    }
+    const args = ["worktree", "add"];
+    if (options.createBranch) {
+      args.push("-b", options.branch);
+    }
+    if (options.force) {
+      args.push("--force");
+    }
+    args.push(absolutePath);
+    if (!options.createBranch) {
+      args.push(options.branch);
+    } else if (options.baseBranch) {
+      args.push(options.baseBranch);
+    }
+    await executeGitCommand(args, { cwd: this._workingDirectory });
+    return absolutePath;
+  }
+  /**
+   * Remove a worktree and optionally clean up associated files
+   * Ports worktree removal logic from cleanup-worktree.sh
+   * @returns A message describing what was done (for dry-run mode)
+   */
+  async removeWorktree(worktreePath, options = {}) {
+    const worktrees = await this.listWorktrees({ porcelain: true });
+    const worktree = worktrees.find((wt) => wt.path === worktreePath);
+    if (!worktree) {
+      const { logger: logger4 } = await Promise.resolve().then(() => (init_logger(), logger_exports));
+      logger4.debug(`Looking for worktree path: ${worktreePath}`);
+      logger4.debug(`Found ${worktrees.length} worktrees:`);
+      worktrees.forEach((wt, i) => {
+        logger4.debug(`  ${i}: path="${wt.path}", branch="${wt.branch}"`);
+      });
+      throw new Error(`Worktree not found: ${worktreePath}`);
+    }
+    if (!options.force && !options.dryRun) {
+      const hasChanges = await hasUncommittedChanges(worktreePath);
+      if (hasChanges) {
+        throw new Error(`Worktree has uncommitted changes: ${worktreePath}. Use --force to override.`);
+      }
+    }
+    if (options.dryRun) {
+      const actions = ["Remove worktree registration"];
+      if (options.removeDirectory) actions.push("Remove directory from disk");
+      if (options.removeBranch) actions.push(`Remove branch: ${worktree.branch}`);
+      return `Would perform: ${actions.join(", ")}`;
+    }
+    const args = ["worktree", "remove"];
+    if (options.force) args.push("--force");
+    args.push(worktreePath);
+    await executeGitCommand(args, { cwd: this._workingDirectory });
+    if (options.removeDirectory && await fs.pathExists(worktreePath)) {
+      await fs.remove(worktreePath);
+    }
+    if (options.removeBranch && !worktree.bare) {
+      try {
+        await executeGitCommand(["branch", "-D", worktree.branch], {
+          cwd: this._workingDirectory
+        });
+      } catch (error) {
+        throw new Error(
+          `Worktree removed but failed to delete branch ${worktree.branch}: ${error instanceof Error ? error.message : "Unknown error"}`
+        );
+      }
+    }
+  }
+  /**
+   * Validate worktree state and integrity
+   */
+  async validateWorktree(worktreePath) {
+    const issues = [];
+    let existsOnDisk = false;
+    let isValidRepo = false;
+    let hasValidBranch = false;
+    try {
+      existsOnDisk = await fs.pathExists(worktreePath);
+      if (!existsOnDisk) {
+        issues.push("Worktree directory does not exist on disk");
+      }
+      if (existsOnDisk) {
+        isValidRepo = await isValidGitRepo(worktreePath);
+        if (!isValidRepo) {
+          issues.push("Directory is not a valid Git repository");
+        }
+      }
+      if (isValidRepo) {
+        const currentBranch = await getCurrentBranch(worktreePath);
+        hasValidBranch = currentBranch !== null;
+        if (!hasValidBranch) {
+          issues.push("Could not determine current branch");
+        }
+      }
+      const worktrees = await this.listWorktrees();
+      const isRegistered = worktrees.some((wt) => wt.path === worktreePath);
+      if (!isRegistered) {
+        issues.push("Worktree is not registered with Git");
+      }
+    } catch (error) {
+      issues.push(`Validation error: ${error instanceof Error ? error.message : "Unknown error"}`);
+    }
+    return {
+      isValid: issues.length === 0,
+      issues,
+      existsOnDisk,
+      isValidRepo,
+      hasValidBranch
+    };
+  }
+  /**
+   * Get detailed status information for a worktree
+   */
+  async getWorktreeStatus(worktreePath) {
+    const statusOutput = await executeGitCommand(["status", "--porcelain=v1"], {
+      cwd: worktreePath
+    });
+    let modified = 0;
+    let staged = 0;
+    let deleted = 0;
+    let untracked = 0;
+    const lines = statusOutput.trim().split("\n").filter(Boolean);
+    for (const line of lines) {
+      const status = line.substring(0, 2);
+      if (status[0] === "M" || status[1] === "M") modified++;
+      if (status[0] === "A" || status[0] === "D" || status[0] === "R") staged++;
+      if (status[0] === "D" || status[1] === "D") deleted++;
+      if (status === "??") untracked++;
+    }
+    const currentBranch = await getCurrentBranch(worktreePath) ?? "unknown";
+    const detached = currentBranch === "unknown";
+    let ahead = 0;
+    let behind = 0;
+    try {
+      const aheadBehindOutput = await executeGitCommand(
+        ["rev-list", "--left-right", "--count", `origin/${currentBranch}...HEAD`],
+        { cwd: worktreePath }
+      );
+      const parts = aheadBehindOutput.trim().split("	");
+      const behindStr = parts[0];
+      const aheadStr = parts[1];
+      behind = behindStr ? parseInt(behindStr, 10) || 0 : 0;
+      ahead = aheadStr ? parseInt(aheadStr, 10) || 0 : 0;
+    } catch {
+    }
+    return {
+      modified,
+      staged,
+      deleted,
+      untracked,
+      hasChanges: modified + staged + deleted + untracked > 0,
+      branch: currentBranch,
+      detached,
+      ahead,
+      behind
+    };
+  }
+  /**
+   * Generate a suggested worktree path for a branch
+   */
+  generateWorktreePath(branchName, customRoot, options) {
+    const root = customRoot ?? this._workingDirectory;
+    return generateWorktreePath(branchName, root, options);
+  }
+  /**
+   * Sanitize a branch name for use as a directory name
+   * Replaces slashes with dashes and removes invalid filesystem characters
+   * Ports logic from bash script line 593: ${BRANCH_NAME//\\//-}
+   */
+  sanitizeBranchName(branchName) {
+    return branchName.replace(/\//g, "-").replace(/[^a-zA-Z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-|-$/g, "").toLowerCase();
+  }
+  /**
+   * Check if repository is in a valid state for worktree operations
+   */
+  async isRepoReady() {
+    try {
+      const repoRoot = await getRepoRoot(this._workingDirectory);
+      return repoRoot !== null;
+    } catch {
+      return false;
+    }
+  }
+  /**
+   * Get repository information
+   */
+  async getRepoInfo() {
+    const root = await getRepoRoot(this._workingDirectory);
+    const defaultBranch = await getDefaultBranch(this._workingDirectory);
+    const currentBranch = await getCurrentBranch(this._workingDirectory);
+    return {
+      root,
+      defaultBranch,
+      currentBranch
+    };
+  }
+  /**
+   * Prune stale worktree entries (worktrees that no longer exist on disk)
+   */
+  async pruneWorktrees() {
+    await executeGitCommand(["worktree", "prune", "-v"], { cwd: this._workingDirectory });
+  }
+  /**
+   * Lock a worktree to prevent it from being pruned or moved
+   */
+  async lockWorktree(worktreePath, reason) {
+    const args = ["worktree", "lock", worktreePath];
+    if (reason) args.push("--reason", reason);
+    await executeGitCommand(args, { cwd: this._workingDirectory });
+  }
+  /**
+   * Unlock a previously locked worktree
+   */
+  async unlockWorktree(worktreePath) {
+    await executeGitCommand(["worktree", "unlock", worktreePath], { cwd: this._workingDirectory });
+  }
+  /**
+   * Find worktrees matching an identifier (branch name, path, or PR number)
+   */
+  async findWorktreesByIdentifier(identifier) {
+    const worktrees = await this.listWorktrees({ porcelain: true });
+    return worktrees.filter(
+      (wt) => {
+        var _a;
+        return wt.branch.includes(identifier) || wt.path.includes(identifier) || ((_a = this.getPRNumberFromWorktree(wt)) == null ? void 0 : _a.toString()) === identifier;
+      }
+    );
+  }
+  /**
+   * Find worktree for a specific issue number using exact pattern matching
+   * Matches: issue-{N} at start OR after /, -, _ (but NOT issue-{N}X where X is a digit)
+   * Supports patterns like: issue-44, feat/issue-44-feature, feat-issue-44, bugfix_issue-44, etc.
+   * Avoids false matches like: tissue-44, myissue-44
+   * Ports: find_existing_worktree() from bash script lines 131-165
+   */
+  async findWorktreeForIssue(issueNumber) {
+    const worktrees = await this.listWorktrees({ porcelain: true });
+    const pattern = new RegExp(`(?:^|[/_-])issue-${issueNumber}(?:-|$)`);
+    return worktrees.find((wt) => pattern.test(wt.branch)) ?? null;
+  }
+  /**
+   * Find worktree for a specific PR by branch name
+   * Ports: find_existing_worktree() for PR type from bash script lines 149-160
+   */
+  async findWorktreeForPR(prNumber, branchName) {
+    const worktrees = await this.listWorktrees({ porcelain: true });
+    const byBranch = worktrees.find((wt) => wt.branch === branchName);
+    if (byBranch) return byBranch;
+    const pathPattern = new RegExp(`_pr_${prNumber}$`);
+    return worktrees.find((wt) => pathPattern.test(wt.path)) ?? null;
+  }
+  /**
+   * Remove multiple worktrees
+   * Returns a summary of successes and failures
+   * Automatically filters out the main worktree
+   */
+  async removeWorktrees(worktrees, options = {}) {
+    const successes = [];
+    const failures = [];
+    const skipped = [];
+    for (const worktree of worktrees) {
+      if (await this.isMainWorktree(worktree)) {
+        skipped.push({ worktree, reason: "Cannot remove main worktree" });
+        continue;
+      }
+      try {
+        await this.removeWorktree(worktree.path, {
+          ...options,
+          removeDirectory: true
+        });
+        successes.push({ worktree });
+      } catch (error) {
+        failures.push({
+          worktree,
+          error: error instanceof Error ? error.message : "Unknown error"
+        });
+      }
+    }
+    return { successes, failures, skipped };
+  }
+  /**
+   * Format worktree information for display
+   */
+  formatWorktree(worktree) {
+    const prNumber = this.getPRNumberFromWorktree(worktree);
+    const prLabel = prNumber ? ` (PR #${prNumber})` : "";
+    const bareLabel = worktree.bare ? " [main]" : "";
+    return {
+      title: `${worktree.branch}${prLabel}${bareLabel}`,
+      path: worktree.path,
+      commit: worktree.commit.substring(0, 7)
+    };
+  }
+};
+
+// src/types/github.ts
+var GitHubError = class extends Error {
+  constructor(code, message, details) {
+    super(message);
+    this.code = code;
+    this.details = details;
+    this.name = "GitHubError";
+  }
+};
+
+// src/utils/github.ts
+init_logger();
+import { execa as execa4 } from "execa";
+async function executeGhCommand(args, options) {
+  const result = await execa4("gh", args, {
+    cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
+    timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
+    encoding: "utf8"
+  });
+  const isJson = args.includes("--json") || args.includes("--jq") || args.includes("--format") && args[args.indexOf("--format") + 1] === "json";
+  const data = isJson ? JSON.parse(result.stdout) : result.stdout;
+  return data;
+}
+async function checkGhAuth() {
+  var _a, _b;
+  try {
+    const output = await executeGhCommand(["auth", "status"]);
+    const scopeMatch = output.match(/Token scopes: (.+)/);
+    const userMatch = output.match(/Logged in to github\.com as ([^\s]+)/);
+    const username = userMatch == null ? void 0 : userMatch[1];
+    return {
+      hasAuth: true,
+      scopes: ((_a = scopeMatch == null ? void 0 : scopeMatch[1]) == null ? void 0 : _a.split(", ").map((scope) => scope.replace(/^'|'$/g, ""))) ?? [],
+      ...username && { username }
+    };
+  } catch (error) {
+    if (error instanceof Error && "stderr" in error && ((_b = error.stderr) == null ? void 0 : _b.includes("You are not logged into any GitHub hosts"))) {
+      return { hasAuth: false, scopes: [] };
+    }
+    throw error;
+  }
+}
+async function hasProjectScope() {
+  const auth = await checkGhAuth();
+  return auth.scopes.includes("project");
+}
+async function fetchGhIssue(issueNumber, repo) {
+  logger.debug("Fetching GitHub issue", { issueNumber, repo });
+  const args = [
+    "issue",
+    "view",
+    String(issueNumber),
+    "--json",
+    "number,title,body,state,labels,assignees,url,createdAt,updatedAt"
+  ];
+  if (repo) {
+    args.push("--repo", repo);
+  }
+  return executeGhCommand(args);
+}
+async function fetchGhPR(prNumber) {
+  logger.debug("Fetching GitHub PR", { prNumber });
+  return executeGhCommand([
+    "pr",
+    "view",
+    String(prNumber),
+    "--json",
+    "number,title,body,state,headRefName,baseRefName,url,isDraft,mergeable,createdAt,updatedAt"
+  ]);
+}
+async function fetchProjectList(owner) {
+  const result = await executeGhCommand([
+    "project",
+    "list",
+    "--owner",
+    owner,
+    "--limit",
+    "100",
+    "--format",
+    "json"
+  ]);
+  return (result == null ? void 0 : result.projects) ?? [];
+}
+async function fetchProjectItems(projectNumber, owner) {
+  const result = await executeGhCommand([
+    "project",
+    "item-list",
+    String(projectNumber),
+    "--owner",
+    owner,
+    "--limit",
+    "10000",
+    "--format",
+    "json"
+  ]);
+  return (result == null ? void 0 : result.items) ?? [];
+}
+async function fetchProjectFields(projectNumber, owner) {
+  const result = await executeGhCommand([
+    "project",
+    "field-list",
+    String(projectNumber),
+    "--owner",
+    owner,
+    "--format",
+    "json"
+  ]);
+  return result ?? { fields: [] };
+}
+async function updateProjectItemField(itemId, projectId, fieldId, optionId) {
+  await executeGhCommand([
+    "project",
+    "item-edit",
+    "--id",
+    itemId,
+    "--project-id",
+    projectId,
+    "--field-id",
+    fieldId,
+    "--single-select-option-id",
+    optionId,
+    "--format",
+    "json"
+  ]);
+}
+var SimpleBranchNameStrategy = class {
+  async generate(issueNumber, title) {
+    const slug = title.toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").substring(0, 20);
+    return `feat/issue-${issueNumber}-${slug}`;
+  }
+};
+var ClaudeBranchNameStrategy = class {
+  constructor(claudeModel = "haiku") {
+    this.claudeModel = claudeModel;
+  }
+  async generate(issueNumber, title) {
+    const { generateBranchName: generateBranchName2 } = await Promise.resolve().then(() => (init_claude(), claude_exports));
+    return generateBranchName2(title, issueNumber, this.claudeModel);
+  }
+};
+async function createIssue(title, body, options) {
+  const { repo, labels } = options ?? {};
+  logger.debug("Creating GitHub issue", { title, repo, labels });
+  const args = [
+    "issue",
+    "create",
+    "--title",
+    title,
+    "--body",
+    body
+  ];
+  if (repo) {
+    args.splice(2, 0, "--repo", repo);
+  }
+  if (labels && labels.length > 0) {
+    args.push("--label", labels.join(","));
+  }
+  const execaOptions = {
+    timeout: 3e4,
+    encoding: "utf8"
+  };
+  if (!repo) {
+    execaOptions.cwd = process.cwd();
+  }
+  const result = await execa4("gh", args, execaOptions);
+  const urlMatch = result.stdout.trim().match(/https:\/\/github\.com\/[^/]+\/[^/]+\/issues\/(\d+)/);
+  if (!(urlMatch == null ? void 0 : urlMatch[1])) {
+    throw new Error(`Failed to parse issue URL from gh output: ${result.stdout}`);
+  }
+  const issueNumber = parseInt(urlMatch[1], 10);
+  const issueUrl = urlMatch[0];
+  return {
+    number: issueNumber,
+    url: issueUrl
+  };
+}
+
+// src/lib/GitHubService.ts
+init_logger();
+
+// src/utils/prompt.ts
+init_logger();
+import * as readline from "readline";
+async function promptConfirmation(message, defaultValue = false) {
+  const rl = readline.createInterface({
+    input: process.stdin,
+    output: process.stdout
+  });
+  const suffix = defaultValue ? "[Y/n]" : "[y/N]";
+  const fullMessage = `${message} ${suffix}: `;
+  return new Promise((resolve) => {
+    rl.question(fullMessage, (answer) => {
+      rl.close();
+      const normalized = answer.trim().toLowerCase();
+      if (normalized === "") {
+        resolve(defaultValue);
+        return;
+      }
+      if (normalized === "y" || normalized === "yes") {
+        resolve(true);
+        return;
+      }
+      if (normalized === "n" || normalized === "no") {
+        resolve(false);
+        return;
+      }
+      logger.warn("Invalid input, using default value", {
+        input: answer,
+        defaultValue
+      });
+      resolve(defaultValue);
+    });
+  });
+}
+
+// src/lib/GitHubService.ts
+var GitHubService = class {
+  constructor(options) {
+    if (options == null ? void 0 : options.branchNameStrategy) {
+      this.defaultBranchNameStrategy = options.branchNameStrategy;
+    } else if ((options == null ? void 0 : options.useClaude) !== false) {
+      this.defaultBranchNameStrategy = new ClaudeBranchNameStrategy(
+        options == null ? void 0 : options.claudeModel
+      );
+    } else {
+      this.defaultBranchNameStrategy = new SimpleBranchNameStrategy();
+    }
+    this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
+  }
+  // Input detection
+  async detectInputType(input) {
+    const numberMatch = input.match(/^#?(\d+)$/);
+    if (!(numberMatch == null ? void 0 : numberMatch[1])) {
+      return { type: "unknown", number: null, rawInput: input };
+    }
+    const number = parseInt(numberMatch[1], 10);
+    logger.debug("Checking if input is a PR", { number });
+    const pr = await this.isValidPR(number);
+    if (pr) {
+      return { type: "pr", number, rawInput: input };
+    }
+    logger.debug("Checking if input is an issue", { number });
+    const issue = await this.isValidIssue(number);
+    if (issue) {
+      return { type: "issue", number, rawInput: input };
+    }
+    return { type: "unknown", number: null, rawInput: input };
+  }
+  // Issue fetching with validation
+  async fetchIssue(issueNumber) {
+    var _a;
+    try {
+      return await this.fetchIssueInternal(issueNumber);
+    } catch (error) {
+      if (error instanceof Error && "stderr" in error && ((_a = error.stderr) == null ? void 0 : _a.includes("Could not resolve"))) {
+        throw new GitHubError(
+          "NOT_FOUND" /* NOT_FOUND */,
+          `Issue #${issueNumber} not found`,
+          error
+        );
+      }
+      throw error;
+    }
+  }
+  // Silent issue validation (for detection phase)
+  async isValidIssue(issueNumber) {
+    var _a;
+    try {
+      return await this.fetchIssueInternal(issueNumber);
+    } catch (error) {
+      if (error instanceof Error && "stderr" in error && ((_a = error.stderr) == null ? void 0 : _a.includes("Could not resolve"))) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  // Internal issue fetching logic (shared by fetchIssue and isValidIssue)
+  async fetchIssueInternal(issueNumber) {
+    const ghIssue = await fetchGhIssue(issueNumber);
+    return this.mapGitHubIssueToIssue(ghIssue);
+  }
+  async validateIssueState(issue) {
+    if (issue.state === "closed") {
+      const response = await this.promptUserConfirmation(
+        `Issue #${issue.number} is closed. Continue anyway?`
+      );
+      if (!response) {
+        throw new GitHubError(
+          "INVALID_STATE" /* INVALID_STATE */,
+          "User cancelled due to closed issue"
+        );
+      }
+    }
+  }
+  // PR fetching with validation
+  async fetchPR(prNumber) {
+    var _a;
+    try {
+      return await this.fetchPRInternal(prNumber);
+    } catch (error) {
+      if (error instanceof Error && "stderr" in error && ((_a = error.stderr) == null ? void 0 : _a.includes("Could not resolve"))) {
+        throw new GitHubError(
+          "NOT_FOUND" /* NOT_FOUND */,
+          `PR #${prNumber} not found`,
+          error
+        );
+      }
+      throw error;
+    }
+  }
+  // Silent PR validation (for detection phase)
+  async isValidPR(prNumber) {
+    var _a;
+    try {
+      return await this.fetchPRInternal(prNumber);
+    } catch (error) {
+      if (error instanceof Error && "stderr" in error && ((_a = error.stderr) == null ? void 0 : _a.includes("Could not resolve"))) {
+        return false;
+      }
+      throw error;
+    }
+  }
+  // Internal PR fetching logic (shared by fetchPR and isValidPR)
+  async fetchPRInternal(prNumber) {
+    const ghPR = await fetchGhPR(prNumber);
+    return this.mapGitHubPRToPullRequest(ghPR);
+  }
+  async validatePRState(pr) {
+    if (pr.state === "closed" || pr.state === "merged") {
+      const response = await this.promptUserConfirmation(
+        `PR #${pr.number} is ${pr.state}. Continue anyway?`
+      );
+      if (!response) {
+        throw new GitHubError(
+          "INVALID_STATE" /* INVALID_STATE */,
+          `User cancelled due to ${pr.state} PR`
+        );
+      }
+    }
+  }
+  // Branch name generation using strategy pattern
+  async generateBranchName(options) {
+    const { issueNumber, title, strategy } = options;
+    const nameStrategy = strategy ?? this.defaultBranchNameStrategy;
+    logger.debug("Generating branch name", {
+      issueNumber,
+      title,
+      strategy: nameStrategy.constructor.name
+    });
+    return nameStrategy.generate(issueNumber, title);
+  }
+  // Issue creation
+  async createIssue(title, body, repository, labels) {
+    return createIssue(title, body, { repo: repository, labels });
+  }
+  async getIssueUrl(issueNumber, repo) {
+    logger.debug("Fetching issue URL", { issueNumber, repo });
+    const issue = await fetchGhIssue(issueNumber, repo);
+    return issue.url;
+  }
+  // GitHub Projects integration
+  async moveIssueToInProgress(issueNumber) {
+    logger.info("Moving issue to In Progress in GitHub Projects", {
+      issueNumber
+    });
+    if (!await hasProjectScope()) {
+      logger.warn("Missing project scope in GitHub CLI auth");
+      throw new GitHubError(
+        "MISSING_SCOPE" /* MISSING_SCOPE */,
+        "GitHub CLI lacks project scope. Run: gh auth refresh -s project"
+      );
+    }
+    let owner;
+    try {
+      const repoInfo = await executeGhCommand(["repo", "view", "--json", "owner,name"]);
+      owner = repoInfo.owner.login;
+    } catch (error) {
+      logger.warn("Could not determine repository info", { error });
+      return;
+    }
+    let projects;
+    try {
+      projects = await fetchProjectList(owner);
+    } catch (error) {
+      logger.warn("Could not fetch projects", { owner, error });
+      return;
+    }
+    if (!projects.length) {
+      logger.warn("No projects found", { owner });
+      return;
+    }
+    for (const project of projects) {
+      await this.updateIssueStatusInProject(project, issueNumber, owner);
+    }
+  }
+  async updateIssueStatusInProject(project, issueNumber, owner) {
+    var _a;
+    let items;
+    try {
+      items = await fetchProjectItems(project.number, owner);
+    } catch (error) {
+      logger.debug("Could not fetch project items", { project: project.number, error });
+      return;
+    }
+    const item = items.find(
+      (i) => i.content.type === "Issue" && i.content.number === issueNumber
+    );
+    if (!item) {
+      logger.debug("Issue not found in project", {
+        issueNumber,
+        projectNumber: project.number
+      });
+      return;
+    }
+    let fieldsData;
+    try {
+      fieldsData = await fetchProjectFields(project.number, owner);
+    } catch (error) {
+      logger.debug("Could not fetch project fields", { project: project.number, error });
+      return;
+    }
+    const statusField = fieldsData.fields.find((f) => f.name === "Status");
+    if (!statusField) {
+      logger.debug("No Status field found in project", { projectNumber: project.number });
+      return;
+    }
+    const inProgressOption = (_a = statusField.options) == null ? void 0 : _a.find(
+      (o) => o.name === "In Progress" || o.name === "In progress"
+    );
+    if (!inProgressOption) {
+      logger.debug("No In Progress option found in Status field", { projectNumber: project.number });
+      return;
+    }
+    try {
+      await updateProjectItemField(
+        item.id,
+        project.id,
+        statusField.id,
+        inProgressOption.id
+      );
+      logger.info("Updated issue status in project", {
+        issueNumber,
+        projectNumber: project.number
+      });
+    } catch (error) {
+      logger.debug("Could not update project item", { item: item.id, error });
+    }
+  }
+  // Utility methods
+  extractContext(entity) {
+    if ("branch" in entity) {
+      return `Pull Request #${entity.number}: ${entity.title}
+Branch: ${entity.branch}
+State: ${entity.state}`;
+    } else {
+      return `GitHub Issue #${entity.number}: ${entity.title}
+State: ${entity.state}`;
+    }
+  }
+  mapGitHubIssueToIssue(ghIssue) {
+    return {
+      number: ghIssue.number,
+      title: ghIssue.title,
+      body: ghIssue.body,
+      state: ghIssue.state.toLowerCase(),
+      labels: ghIssue.labels.map((l) => l.name),
+      assignees: ghIssue.assignees.map((a) => a.login),
+      url: ghIssue.url
+    };
+  }
+  mapGitHubPRToPullRequest(ghPR) {
+    return {
+      number: ghPR.number,
+      title: ghPR.title,
+      body: ghPR.body,
+      state: ghPR.state.toLowerCase(),
+      branch: ghPR.headRefName,
+      baseBranch: ghPR.baseRefName,
+      url: ghPR.url,
+      isDraft: ghPR.isDraft
+    };
+  }
+  async promptUserConfirmation(message) {
+    return this.prompter(message);
+  }
+  // Allow setting strategy at runtime for specific operations
+  setDefaultBranchNameStrategy(strategy) {
+    this.defaultBranchNameStrategy = strategy;
+  }
+  // Get current strategy for testing
+  getBranchNameStrategy() {
+    return this.defaultBranchNameStrategy;
+  }
+};
+
+// src/lib/EnvironmentManager.ts
+init_logger();
+import fs2 from "fs-extra";
+
+// src/utils/env.ts
+init_logger();
+import dotenvFlow from "dotenv-flow";
+function parseEnvFile(content) {
+  const envMap = /* @__PURE__ */ new Map();
+  const lines = content.split("\n");
+  for (const line of lines) {
+    const trimmedLine = line.trim();
+    if (!trimmedLine || trimmedLine.startsWith("#")) {
+      continue;
+    }
+    const cleanLine = trimmedLine.startsWith("export ") ? trimmedLine.substring(7) : trimmedLine;
+    const equalsIndex = cleanLine.indexOf("=");
+    if (equalsIndex === -1) {
+      continue;
+    }
+    const key = cleanLine.substring(0, equalsIndex).trim();
+    let value = cleanLine.substring(equalsIndex + 1);
+    if (value.startsWith('"') && value.endsWith('"') || value.startsWith("'") && value.endsWith("'")) {
+      value = value.substring(1, value.length - 1);
+      value = value.replace(/\\"/g, '"').replace(/\\'/g, "'");
+      value = value.replace(/\\n/g, "\n");
+    }
+    if (key) {
+      envMap.set(key, value);
+    }
+  }
+  return envMap;
+}
+function formatEnvLine(key, value) {
+  const escapedValue = value.replace(/"/g, '\\"').replace(/\n/g, "\\n").replace(/\r/g, "\\r");
+  return `${key}="${escapedValue}"`;
+}
+function validateEnvVariable(key, _value) {
+  if (!key || key.length === 0) {
+    return {
+      valid: false,
+      error: "Environment variable key cannot be empty"
+    };
+  }
+  if (!isValidEnvKey(key)) {
+    return {
+      valid: false,
+      error: `Invalid environment variable name: ${key}. Must start with a letter or underscore and contain only letters, numbers, and underscores.`
+    };
+  }
+  return { valid: true };
+}
+function isValidEnvKey(key) {
+  if (!key || key.length === 0) {
+    return false;
+  }
+  const validKeyRegex = /^[A-Za-z_][A-Za-z0-9_]*$/;
+  return validKeyRegex.test(key);
+}
+
+// src/utils/port.ts
+import { createHash as createHash2 } from "crypto";
+function generatePortOffsetFromBranchName(branchName) {
+  if (!branchName || branchName.trim().length === 0) {
+    throw new Error("Branch name cannot be empty");
+  }
+  const hash = createHash2("sha256").update(branchName).digest("hex");
+  const hashPrefix = hash.slice(0, 8);
+  const hashAsInt = parseInt(hashPrefix, 16);
+  const portOffset = hashAsInt % 999 + 1;
+  return portOffset;
+}
+function calculatePortForBranch(branchName, basePort = 3e3) {
+  const offset = generatePortOffsetFromBranchName(branchName);
+  const port = basePort + offset;
+  if (port > 65535) {
+    throw new Error(
+      `Calculated port ${port} exceeds maximum (65535). Use a lower base port (current: ${basePort}).`
+    );
+  }
+  return port;
+}
+
+// src/lib/EnvironmentManager.ts
+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 fs2.pathExists(filePath);
+    if (!fileExists) {
+      logger2.info(`Creating ${filePath} with ${key}...`);
+      const content = formatEnvLine(key, value);
+      await fs2.writeFile(filePath, content, "utf8");
+      logger2.success(`${filePath} created with ${key}`);
+      return;
+    }
+    const existingContent = await fs2.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 fs2.writeFile(filePath, newContent, "utf8");
+    return backupPath;
+  }
+  /**
+   * Read and parse a .env file
+   */
+  async readEnvFile(filePath) {
+    try {
+      const content = await fs2.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();
+    }
+  }
+  /**
+   * 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 fs2.pathExists(source);
+    if (!sourceExists) {
+      logger2.debug(`Source file ${source} does not exist, skipping copy`);
+      return;
+    }
+    await fs2.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 port = basePort + options.issueNumber;
+      if (port > 65535) {
+        throw new Error(
+          `Calculated port ${port} exceeds maximum (65535). Use a lower base port or issue number.`
+        );
+      }
+      return port;
+    }
+    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 fs2.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 fs2.copy(filePath, backupPath);
+    logger2.debug(`Created backup at ${backupPath}`);
+    return backupPath;
+  }
+};
+
+// src/lib/DatabaseManager.ts
+init_logger();
+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
+   */
+  async createBranchIfConfigured(branchName, envFilePath, cwd) {
+    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, void 0, 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
+      };
+    }
+  }
+  /**
+   * 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/ClaudeService.ts
+init_claude();
+
+// src/lib/PromptTemplateManager.ts
+init_logger();
+import { readFile as readFile2 } from "fs/promises";
+import { accessSync } from "fs";
+import path4 from "path";
+import { fileURLToPath } from "url";
+var PromptTemplateManager = class {
+  constructor(templateDir) {
+    if (templateDir) {
+      this.templateDir = templateDir;
+    } else {
+      const currentFileUrl = import.meta.url;
+      const currentFilePath = fileURLToPath(currentFileUrl);
+      const distDir = path4.dirname(currentFilePath);
+      let templateDir2 = path4.join(distDir, "prompts");
+      let currentDir = distDir;
+      while (currentDir !== path4.dirname(currentDir)) {
+        const candidatePath = path4.join(currentDir, "prompts");
+        try {
+          accessSync(candidatePath);
+          templateDir2 = candidatePath;
+          break;
+        } catch {
+          currentDir = path4.dirname(currentDir);
+        }
+      }
+      this.templateDir = templateDir2;
+      logger.debug("PromptTemplateManager initialized", {
+        currentFilePath,
+        distDir,
+        templateDir: this.templateDir
+      });
+    }
+  }
+  /**
+   * Load a template file by name
+   */
+  async loadTemplate(templateName) {
+    const templatePath = path4.join(this.templateDir, `${templateName}-prompt.txt`);
+    logger.debug("Loading template", {
+      templateName,
+      templateDir: this.templateDir,
+      templatePath
+    });
+    try {
+      return await readFile2(templatePath, "utf-8");
+    } catch (error) {
+      logger.error("Failed to load template", { templateName, templatePath, error });
+      throw new Error(`Template not found: ${templatePath}`);
+    }
+  }
+  /**
+   * Substitute variables in a template string
+   */
+  substituteVariables(template, variables) {
+    let result = template;
+    result = this.processConditionalSections(result, variables);
+    if (variables.ISSUE_NUMBER !== void 0) {
+      result = result.replace(/ISSUE_NUMBER/g, String(variables.ISSUE_NUMBER));
+    }
+    if (variables.PR_NUMBER !== void 0) {
+      result = result.replace(/PR_NUMBER/g, String(variables.PR_NUMBER));
+    }
+    if (variables.ISSUE_TITLE !== void 0) {
+      result = result.replace(/ISSUE_TITLE/g, variables.ISSUE_TITLE);
+    }
+    if (variables.PR_TITLE !== void 0) {
+      result = result.replace(/PR_TITLE/g, variables.PR_TITLE);
+    }
+    if (variables.WORKSPACE_PATH !== void 0) {
+      result = result.replace(/WORKSPACE_PATH/g, variables.WORKSPACE_PATH);
+    }
+    if (variables.PORT !== void 0) {
+      result = result.replace(/PORT/g, String(variables.PORT));
+    }
+    return result;
+  }
+  /**
+   * Process conditional sections in template
+   * Format: {{#IF ONE_SHOT_MODE}}content{{/IF ONE_SHOT_MODE}}
+   * 
+   * Note: /s flag allows . to match newlines
+   */
+  processConditionalSections(template, variables) {
+    let result = template;
+    const oneShotRegex = /\{\{#IF ONE_SHOT_MODE\}\}(.*?)\{\{\/IF ONE_SHOT_MODE\}\}/gs;
+    if (variables.ONE_SHOT_MODE === true) {
+      result = result.replace(oneShotRegex, "$1");
+    } else {
+      result = result.replace(oneShotRegex, "");
+    }
+    return result;
+  }
+  /**
+   * Get a fully processed prompt for a workflow type
+   */
+  async getPrompt(type, variables) {
+    const template = await this.loadTemplate(type);
+    return this.substituteVariables(template, variables);
+  }
+};
+
+// src/lib/ClaudeService.ts
+init_SettingsManager();
+init_logger();
+var ClaudeService = class {
+  constructor(templateManager, settingsManager) {
+    this.templateManager = templateManager ?? new PromptTemplateManager();
+    this.settingsManager = settingsManager ?? new SettingsManager();
+  }
+  /**
+   * Check if Claude CLI is available
+   */
+  async isAvailable() {
+    return detectClaudeCli();
+  }
+  /**
+   * Get the appropriate model for a workflow type
+   */
+  getModelForWorkflow(type) {
+    if (type === "issue") {
+      return "claude-sonnet-4-20250514";
+    }
+    return void 0;
+  }
+  /**
+   * Get the appropriate permission mode for a workflow type
+   */
+  getPermissionModeForWorkflow(type) {
+    var _a;
+    if ((_a = this.settings) == null ? void 0 : _a.workflows) {
+      const workflowConfig = type === "issue" ? this.settings.workflows.issue : type === "pr" ? this.settings.workflows.pr : this.settings.workflows.regular;
+      if (workflowConfig == null ? void 0 : workflowConfig.permissionMode) {
+        return workflowConfig.permissionMode;
+      }
+    }
+    if (type === "issue") {
+      return "acceptEdits";
+    }
+    return "default";
+  }
+  /**
+   * Launch Claude for a specific workflow
+   */
+  async launchForWorkflow(options) {
+    const { type, issueNumber, prNumber, title, workspacePath, port, headless = false, branchName, oneShot = "default", setArguments, executablePath } = options;
+    try {
+      this.settings ??= await this.settingsManager.loadSettings();
+      const variables = {
+        WORKSPACE_PATH: workspacePath
+      };
+      if (issueNumber !== void 0) {
+        variables.ISSUE_NUMBER = issueNumber;
+      }
+      if (prNumber !== void 0) {
+        variables.PR_NUMBER = prNumber;
+      }
+      if (title !== void 0) {
+        if (type === "issue") {
+          variables.ISSUE_TITLE = title;
+        } else if (type === "pr") {
+          variables.PR_TITLE = title;
+        }
+      }
+      if (port !== void 0) {
+        variables.PORT = port;
+      }
+      const prompt = await this.templateManager.getPrompt(type, variables);
+      const model = this.getModelForWorkflow(type);
+      const permissionMode = this.getPermissionModeForWorkflow(type);
+      if (permissionMode === "bypassPermissions") {
+        logger.warn(
+          "\u26A0\uFE0F  WARNING: Using bypassPermissions mode - Claude will execute all tool calls without confirmation. This can be dangerous. Use with caution."
+        );
+      }
+      const claudeOptions = {
+        addDir: workspacePath,
+        headless
+      };
+      if (model !== void 0) {
+        claudeOptions.model = model;
+      }
+      if (permissionMode !== void 0 && permissionMode !== "default") {
+        claudeOptions.permissionMode = permissionMode;
+      }
+      if (branchName !== void 0) {
+        claudeOptions.branchName = branchName;
+      }
+      if (port !== void 0) {
+        claudeOptions.port = port;
+      }
+      if (setArguments !== void 0) {
+        claudeOptions.setArguments = setArguments;
+      }
+      if (executablePath !== void 0) {
+        claudeOptions.executablePath = executablePath;
+      }
+      logger.debug("Launching Claude for workflow", {
+        type,
+        model,
+        permissionMode,
+        headless,
+        workspacePath
+      });
+      if (headless) {
+        return await launchClaude(prompt, claudeOptions);
+      } else {
+        if (!claudeOptions.addDir) {
+          throw new Error("workspacePath required for interactive workflow launch");
+        }
+        return await launchClaudeInNewTerminalWindow(prompt, {
+          ...claudeOptions,
+          workspacePath: claudeOptions.addDir,
+          oneShot
+        });
+      }
+    } catch (error) {
+      logger.error("Failed to launch Claude for workflow", { error, options });
+      throw error;
+    }
+  }
+  /**
+   * Generate branch name with Claude, with fallback on failure
+   */
+  async generateBranchNameWithFallback(issueTitle, issueNumber) {
+    try {
+      return await generateBranchName(issueTitle, issueNumber);
+    } catch (error) {
+      logger.warn("Claude branch name generation failed, using fallback", { error });
+      return `feat/issue-${issueNumber}`;
+    }
+  }
+};
+
+// src/lib/ClaudeContextManager.ts
+init_logger();
+var ClaudeContextManager = class {
+  constructor(claudeService, _promptTemplateManager, settingsManager) {
+    this.claudeService = claudeService ?? new ClaudeService(void 0, settingsManager);
+  }
+  /**
+   * Prepare context for Claude launch
+   * Placeholder for future .claude-context.md generation (Issue #11)
+   */
+  async prepareContext(context) {
+    if (!context.workspacePath) {
+      throw new Error("Workspace path is required");
+    }
+    if (context.type === "issue" && typeof context.identifier !== "number") {
+      throw new Error("Issue identifier must be a number");
+    }
+    if (context.type === "pr" && typeof context.identifier !== "number") {
+      throw new Error("PR identifier must be a number");
+    }
+    logger.debug("Context prepared", { context });
+  }
+  /**
+   * Launch Claude with the prepared context
+   */
+  async launchWithContext(context, headless = false) {
+    await this.prepareContext(context);
+    const workflowOptions = {
+      type: context.type,
+      workspacePath: context.workspacePath,
+      ...context.port !== void 0 && { port: context.port },
+      headless,
+      oneShot: context.oneShot ?? "default"
+    };
+    if (context.title !== void 0) {
+      workflowOptions.title = context.title;
+    }
+    if (context.branchName !== void 0) {
+      workflowOptions.branchName = context.branchName;
+    }
+    if (context.setArguments !== void 0) {
+      workflowOptions.setArguments = context.setArguments;
+    }
+    if (context.executablePath !== void 0) {
+      workflowOptions.executablePath = context.executablePath;
+    }
+    if (context.type === "issue") {
+      workflowOptions.issueNumber = context.identifier;
+    } else if (context.type === "pr") {
+      workflowOptions.prNumber = context.identifier;
+    }
+    return this.claudeService.launchForWorkflow(workflowOptions);
+  }
+};
+
+// src/utils/index.ts
+init_logger();
+export {
+  ClaudeContextManager,
+  DatabaseManager,
+  EnvironmentManager,
+  GitHubService,
+  GitWorktreeManager,
+  WorkspaceManager,
+  branchExists,
+  createLogger,
+  ensureRepositoryHasCommits,
+  executeGitCommand,
+  extractPRNumber,
+  findAllBranchesForIssue,
+  findMainWorktreePath,
+  findMainWorktreePathWithSettings,
+  generateWorktreePath,
+  getCurrentBranch,
+  getDefaultBranch,
+  getRepoRoot,
+  hasUncommittedChanges,
+  isEmptyRepository,
+  isPRBranch,
+  isValidGitRepo,
+  isWorktreePath,
+  logger,
+  parseWorktreeList,
+  pushBranchToRemote
+};
+//# sourceMappingURL=index.js.map