@iloom/cli 0.5.1 → 0.5.2

package/dist/index.js

@@ -8,8 +8,282 @@ var __export = (target, all) => {
     __defProp(target, name, { get: all[name], enumerable: true });
 };
 
+// src/utils/env.ts
+import path from "path";
+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);
+}
+function getDotenvFlowFiles() {
+  return [
+    ".env",
+    ".env.local",
+    `.env.${DOTENV_FLOW_NODE_ENV}`,
+    `.env.${DOTENV_FLOW_NODE_ENV}.local`
+  ];
+}
+async function buildEnvSourceCommands(workspacePath, fileExists) {
+  const files = getDotenvFlowFiles();
+  const commands = [];
+  for (const file of files) {
+    const fullPath = path.join(workspacePath, file);
+    const exists = await fileExists(fullPath);
+    if (exists) {
+      commands.push(`source ${file}`);
+    }
+  }
+  return commands;
+}
+async function findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable) {
+  const files = getDotenvFlowFiles().reverse();
+  for (const file of files) {
+    const fullPath = path.join(workspacePath, file);
+    if (!await fileExists(fullPath)) {
+      continue;
+    }
+    const value = await getEnvVariable(fullPath, variableName);
+    if (value !== null) {
+      return file;
+    }
+  }
+  return null;
+}
+async function hasVariableInAnyEnvFile(workspacePath, variableName, fileExists, getEnvVariable) {
+  const file = await findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable);
+  return file !== null;
+}
+var DOTENV_FLOW_NODE_ENV;
+var init_env = __esm({
+  "src/utils/env.ts"() {
+    "use strict";
+    init_logger();
+    DOTENV_FLOW_NODE_ENV = process.env.DOTENV_FLOW_NODE_ENV ?? "development";
+  }
+});
+
+// src/utils/terminal.ts
+import { execa } 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 detectDarkMode() {
+  const platform = detectPlatform();
+  if (platform !== "darwin") {
+    return "light";
+  }
+  try {
+    const result = await execa("defaults", ["read", "-g", "AppleInterfaceStyle"]);
+    return result.stdout.trim().toLowerCase() === "dark" ? "dark" : "light";
+  } catch {
+    return "light";
+  }
+}
+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 hasITerm2 = await detectITerm2();
+  const applescript = hasITerm2 ? await buildITerm2SingleTabScript(options) : await buildAppleScript(options);
+  try {
+    await execa("osascript", ["-e", applescript]);
+    if (!hasITerm2) {
+      await execa("osascript", ["-e", 'tell application "Terminal" to activate']);
+    }
+  } catch (error) {
+    throw new Error(
+      `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
+    );
+  }
+}
+async function buildAppleScript(options) {
+  const {
+    workspacePath,
+    command,
+    backgroundColor,
+    port,
+    includeEnvSetup,
+    includePortExport
+  } = options;
+  const commands = [];
+  if (workspacePath) {
+    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+  }
+  if (includeEnvSetup && workspacePath) {
+    const sourceCommands = await buildEnvSourceCommands(
+      workspacePath,
+      async (p) => existsSync(p)
+    );
+    commands.push(...sourceCommands);
+  }
+  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(path7) {
+  return path7.replace(/'/g, "'\\''");
+}
+function escapeForAppleScript(command) {
+  return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
+}
+async function buildITerm2SingleTabScript(options) {
+  const command = await buildCommandSequence(options);
+  let script = 'tell application id "com.googlecode.iterm2"\n';
+  script += "  create window with default profile\n";
+  script += "  set s1 to current session of current window\n\n";
+  if (options.backgroundColor) {
+    const { r, g, b } = options.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(command)}"
+
+`;
+  if (options.title) {
+    script += `  set name of s1 to "${escapeForAppleScript(options.title)}"
+
+`;
+  }
+  script += "  activate\n";
+  script += "end tell";
+  return script;
+}
+async function buildCommandSequence(options) {
+  const {
+    workspacePath,
+    command,
+    port,
+    includeEnvSetup,
+    includePortExport
+  } = options;
+  const commands = [];
+  if (workspacePath) {
+    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
+  }
+  if (includeEnvSetup && workspacePath) {
+    const sourceCommands = await buildEnvSourceCommands(
+      workspacePath,
+      async (p) => existsSync(p)
+    );
+    commands.push(...sourceCommands);
+  }
+  if (includePortExport && port !== void 0) {
+    commands.push(`export PORT=${port}`);
+  }
+  if (command) {
+    commands.push(command);
+  }
+  const fullCommand = commands.join(" && ");
+  return ` ${fullCommand}`;
+}
+var init_terminal = __esm({
+  "src/utils/terminal.ts"() {
+    "use strict";
+    init_env();
+  }
+});
+
 // src/utils/logger.ts
 import chalk, { Chalk } from "chalk";
+async function initializeThemeMode() {
+  try {
+    currentThemeMode = await detectDarkMode();
+  } catch {
+    currentThemeMode = "light";
+  }
+}
+function getInfoColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.cyan : chalkInstance.blue;
+}
+function getSuccessColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.greenBright : chalkInstance.green;
+}
+function getWarnColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.yellowBright : chalkInstance.yellow;
+}
+function getErrorColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.redBright : chalkInstance.red;
+}
+function getDebugColor(chalkInstance) {
+  return currentThemeMode === "dark" ? chalkInstance.gray : chalkInstance.gray;
+}
 function formatMessage(message, ...args) {
   const formattedArgs = args.map(
     (arg) => typeof arg === "object" ? JSON.stringify(arg, null, 2) : String(arg)
@@ -54,32 +328,32 @@ function createLogger(options = {}) {
     info: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", customStdoutChalk.blue);
+      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", getInfoColor(customStdoutChalk));
       console.log(output);
     },
     success: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u2705", customStdoutChalk.green);
+      const output = formatWithEmoji(fullMessage, "\u2705", getSuccessColor(customStdoutChalk));
       console.log(output);
     },
     warn: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", customStderrChalk.yellow);
+      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", getWarnColor(customStderrChalk));
       console.error(output);
     },
     error: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u274C", customStderrChalk.red);
+      const output = formatWithEmoji(fullMessage, "\u274C", getErrorColor(customStderrChalk));
       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);
+        const output = formatWithEmoji(fullMessage, "\u{1F50D}", getDebugColor(customStdoutChalk));
         console.log(output);
       }
     },
@@ -102,32 +376,32 @@ function createStderrLogger(options = {}) {
     info: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", customChalk.blue);
+      const output = formatWithEmoji(fullMessage, "\u{1F5C2}\uFE0F ", getInfoColor(customChalk));
       console.error(output);
     },
     success: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u2705", customChalk.green);
+      const output = formatWithEmoji(fullMessage, "\u2705", getSuccessColor(customChalk));
       console.error(output);
     },
     warn: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", customChalk.yellow);
+      const output = formatWithEmoji(fullMessage, "\u26A0\uFE0F ", getWarnColor(customChalk));
       console.error(output);
     },
     error: (message, ...args) => {
       const formatted = formatMessage(message, ...args);
       const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-      const output = formatWithEmoji(fullMessage, "\u274C", customChalk.red);
+      const output = formatWithEmoji(fullMessage, "\u274C", getErrorColor(customChalk));
       console.error(output);
     },
     debug: (message, ...args) => {
       if (localDebugEnabled) {
         const formatted = formatMessage(message, ...args);
         const fullMessage = `${getTimestamp()}${prefixStr}${formatted}`;
-        const output = formatWithEmoji(fullMessage, "\u{1F50D}", customChalk.gray);
+        const output = formatWithEmoji(fullMessage, "\u{1F50D}", getDebugColor(customChalk));
         console.error(output);
       }
     },
@@ -141,38 +415,47 @@ function createStderrLogger(options = {}) {
     // Use stderr for progress output in JSON mode
   };
 }
-var stdoutChalk, stderrChalk, globalDebugEnabled, logger, logger_default;
+function setThemeMode(mode) {
+  currentThemeMode = mode;
+}
+function getThemeMode() {
+  return currentThemeMode;
+}
+var stdoutChalk, stderrChalk, currentThemeMode, globalDebugEnabled, logger, logger_default;
 var init_logger = __esm({
   "src/utils/logger.ts"() {
     "use strict";
+    init_terminal();
     stdoutChalk = new Chalk({ level: chalk.level });
     stderrChalk = new Chalk({ level: chalk.level });
+    currentThemeMode = "light";
+    void initializeThemeMode();
     globalDebugEnabled = false;
     logger = {
       info: (message, ...args) => {
         const formatted = formatMessage(message, ...args);
-        const output = formatWithEmoji(formatted, "\u{1F5C2}\uFE0F ", stdoutChalk.blue);
+        const output = formatWithEmoji(formatted, "\u{1F5C2}\uFE0F ", getInfoColor(stdoutChalk));
         console.log(output);
       },
       success: (message, ...args) => {
         const formatted = formatMessage(message, ...args);
-        const output = formatWithEmoji(formatted, "\u2705", stdoutChalk.green);
+        const output = formatWithEmoji(formatted, "\u2705", getSuccessColor(stdoutChalk));
         console.log(output);
       },
       warn: (message, ...args) => {
         const formatted = formatMessage(message, ...args);
-        const output = formatWithEmoji(formatted, "\u26A0\uFE0F ", stderrChalk.yellow);
+        const output = formatWithEmoji(formatted, "\u26A0\uFE0F ", getWarnColor(stderrChalk));
         console.error(output);
       },
       error: (message, ...args) => {
         const formatted = formatMessage(message, ...args);
-        const output = formatWithEmoji(formatted, "\u274C", stderrChalk.red);
+        const output = formatWithEmoji(formatted, "\u274C", getErrorColor(stderrChalk));
         console.error(output);
       },
       debug: (message, ...args) => {
         if (globalDebugEnabled) {
           const formatted = formatMessage(message, ...args);
-          const output = formatWithEmoji(formatted, "\u{1F50D}", stdoutChalk.gray);
+          const output = formatWithEmoji(formatted, "\u{1F50D}", getDebugColor(stdoutChalk));
           console.log(output);
         }
       },
@@ -207,7 +490,7 @@ __export(SettingsManager_exports, {
   WorkflowsSettingsSchemaNoDefaults: () => WorkflowsSettingsSchemaNoDefaults
 });
 import { readFile } from "fs/promises";
-import path from "path";
+import path2 from "path";
 import os from "os";
 import { z } from "zod";
 import deepmerge from "deepmerge";
@@ -437,10 +720,10 @@ var init_SettingsManager = __esm({
         const globalSettingsPath = this.getGlobalSettingsPath();
         logger.debug(`\u{1F30D} Global settings from ${globalSettingsPath}:`, JSON.stringify(globalSettings, null, 2));
         const baseSettings = await this.loadSettingsFile(root, "settings.json");
-        const baseSettingsPath = path.join(root, ".iloom", "settings.json");
+        const baseSettingsPath = path2.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");
+        const localSettingsPath = path2.join(root, ".iloom", "settings.local.json");
         logger.debug(`\u{1F4C4} Local settings from ${localSettingsPath}:`, JSON.stringify(localSettings, null, 2));
         let merged = this.mergeSettings(this.mergeSettings(globalSettings, baseSettings), localSettings);
         logger.debug("\u{1F504} After merging global + base + local settings:", JSON.stringify(merged, null, 2));
@@ -478,7 +761,7 @@ Note: CLI overrides were applied. Check your --set arguments.`);
        * Uses non-defaulting schema to prevent polluting partial settings with defaults before merge
        */
       async loadSettingsFile(projectRoot, filename) {
-        const settingsPath = path.join(projectRoot, ".iloom", filename);
+        const settingsPath = path2.join(projectRoot, ".iloom", filename);
         try {
           const content = await readFile(settingsPath, "utf-8");
           let parsed;
@@ -553,13 +836,13 @@ ${errorMessages.join("\n")}`
        * Get global config directory path (~/.config/iloom-ai)
        */
       getGlobalConfigDir() {
-        return path.join(os.homedir(), ".config", "iloom-ai");
+        return path2.join(os.homedir(), ".config", "iloom-ai");
       }
       /**
        * Get global settings file path (~/.config/iloom-ai/settings.json)
        */
       getGlobalSettingsPath() {
-        return path.join(this.getGlobalConfigDir(), "settings.json");
+        return path2.join(this.getGlobalConfigDir(), "settings.json");
       }
       /**
        * Load and parse global settings file
@@ -656,6 +939,7 @@ __export(color_exports, {
   colorDistance: () => colorDistance,
   generateColorFromBranchName: () => generateColorFromBranchName,
   getColorPalette: () => getColorPalette,
+  getDarkColorPalette: () => getDarkColorPalette,
   hexToRgb: () => hexToRgb,
   lightenColor: () => lightenColor,
   rgbToHex: () => rgbToHex,
@@ -699,6 +983,42 @@ function getColorPalette() {
     // 15: Soft salmon
   ];
 }
+function getDarkColorPalette() {
+  return [
+    { r: 30, g: 45, b: 85 },
+    // 0: Dark blue
+    { r: 85, g: 30, b: 50 },
+    // 1: Dark rose
+    { r: 30, g: 75, b: 40 },
+    // 2: Dark green
+    { r: 75, g: 65, b: 30 },
+    // 3: Dark olive
+    { r: 60, g: 35, b: 85 },
+    // 4: Dark lavender
+    { r: 30, g: 65, b: 75 },
+    // 5: Dark cyan
+    { r: 55, g: 55, b: 55 },
+    // 6: Dark grey
+    { r: 85, g: 40, b: 40 },
+    // 7: Dark coral
+    { r: 35, g: 80, b: 50 },
+    // 8: Dark mint
+    { r: 70, g: 50, b: 30 },
+    // 9: Dark brown
+    { r: 30, g: 75, b: 75 },
+    // 10: Dark aqua
+    { r: 75, g: 30, b: 75 },
+    // 11: Dark magenta
+    { r: 75, g: 75, b: 30 },
+    // 12: Dark yellow
+    { r: 50, g: 35, b: 85 },
+    // 13: Dark violet
+    { r: 30, g: 80, b: 65 },
+    // 14: Dark sea green
+    { r: 85, g: 40, b: 30 }
+    // 15: Dark rust
+  ];
+}
 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");
@@ -718,10 +1038,10 @@ function hexToRgb(hex) {
   const b = parseInt(cleanHex.slice(4, 6), 16);
   return { r, g, b };
 }
-function generateColorFromBranchName(branchName) {
+function generateColorFromBranchName(branchName, themeMode = "light") {
   const hash = createHash2("sha256").update(branchName).digest("hex");
   const hashPrefix = hash.slice(0, 8);
-  const palette = getColorPalette();
+  const palette = themeMode === "dark" ? getDarkColorPalette() : 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}`);
@@ -741,9 +1061,9 @@ function colorDistance(a, b) {
     Math.pow(a.r - b.r, 2) + Math.pow(a.g - b.g, 2) + Math.pow(a.b - b.b, 2)
   );
 }
-function selectDistinctColor(branchName, usedHexColors) {
-  const palette = getColorPalette();
-  const hashBasedColor = generateColorFromBranchName(branchName);
+function selectDistinctColor(branchName, usedHexColors, themeMode = "light") {
+  const palette = themeMode === "dark" ? getDarkColorPalette() : getColorPalette();
+  const hashBasedColor = generateColorFromBranchName(branchName, themeMode);
   if (usedHexColors.length === 0) {
     return hashBasedColor;
   }
@@ -824,16 +1144,16 @@ var WorkspaceManager = class {
 };
 
 // src/lib/GitWorktreeManager.ts
-import path4 from "path";
+import path5 from "path";
 import fs2 from "fs-extra";
 
 // src/utils/git.ts
 init_SettingsManager();
-import path3 from "path";
-import { execa } from "execa";
+import path4 from "path";
+import { execa as execa2 } from "execa";
 
 // src/lib/MetadataManager.ts
-import path2 from "path";
+import path3 from "path";
 import os2 from "os";
 import fs from "fs-extra";
 
@@ -848,7 +1168,7 @@ function getLogger() {
 // src/lib/MetadataManager.ts
 var MetadataManager = class {
   constructor() {
-    this.loomsDir = path2.join(os2.homedir(), ".config", "iloom-ai", "looms");
+    this.loomsDir = path3.join(os2.homedir(), ".config", "iloom-ai", "looms");
   }
   /**
    * Convert worktree path to filename slug per spec section 2.2
@@ -874,7 +1194,7 @@ var MetadataManager = class {
    */
   getFilePath(worktreePath) {
     const filename = this.slugifyPath(worktreePath);
-    return path2.join(this.loomsDir, filename);
+    return path3.join(this.loomsDir, filename);
   }
   /**
    * Get the full path to the metadata file for a worktree (public API)
@@ -981,7 +1301,7 @@ var MetadataManager = class {
           continue;
         }
         try {
-          const filePath = path2.join(this.loomsDir, file);
+          const filePath = path3.join(this.loomsDir, file);
           const content = await fs.readFile(filePath, "utf8");
           const data = JSON.parse(content);
           if (!data.description) {
@@ -1046,7 +1366,7 @@ var MetadataManager = class {
 init_logger();
 async function executeGitCommand(args, options) {
   try {
-    const result = await execa("git", args, {
+    const result = await execa2("git", args, {
       cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
       timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
       encoding: "utf8",
@@ -1211,10 +1531,10 @@ function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
   if ((options == null ? void 0 : options.isPR) && (options == null ? void 0 : options.prNumber)) {
     sanitized = `${sanitized}_pr_${options.prNumber}`;
   }
-  const parentDir = path3.dirname(rootDir);
+  const parentDir = path4.dirname(rootDir);
   let prefix;
   if ((options == null ? void 0 : options.prefix) === void 0) {
-    const mainFolderName = path3.basename(rootDir);
+    const mainFolderName = path4.basename(rootDir);
     prefix = mainFolderName ? `${mainFolderName}-looms/` : "looms/";
   } else if (options.prefix === "") {
     prefix = "";
@@ -1234,16 +1554,16 @@ function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
     }
   }
   if (prefix === "") {
-    return path3.join(parentDir, sanitized);
+    return path4.join(parentDir, sanitized);
   } else if (prefix.endsWith("/")) {
-    return path3.join(parentDir, prefix, sanitized);
+    return path4.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 path3.join(parentDir, dirPath, `${prefixWithSeparator}${sanitized}`);
+    return path4.join(parentDir, dirPath, `${prefixWithSeparator}${sanitized}`);
   } else {
-    return path3.join(parentDir, `${prefix}${sanitized}`);
+    return path4.join(parentDir, `${prefix}${sanitized}`);
   }
 }
 async function isValidGitRepo(path7) {
@@ -1767,7 +2087,7 @@ var GitWorktreeManager = class {
     if (!options.branch) {
       throw new Error("Branch name is required");
     }
-    const absolutePath = path4.resolve(options.path);
+    const absolutePath = path5.resolve(options.path);
     if (await fs2.pathExists(absolutePath)) {
       if (!options.force) {
         throw new Error(`Path already exists: ${absolutePath}`);
@@ -2083,9 +2403,9 @@ var GitHubError = class extends Error {
 
 // src/utils/github.ts
 init_logger();
-import { execa as execa2 } from "execa";
+import { execa as execa3 } from "execa";
 async function executeGhCommand(args, options) {
-  const result = await execa2("gh", args, {
+  const result = await execa3("gh", args, {
     cwd: (options == null ? void 0 : options.cwd) ?? process.cwd(),
     timeout: (options == null ? void 0 : options.timeout) ?? 3e4,
     encoding: "utf8"
@@ -2251,7 +2571,7 @@ async function createIssue(title, body, options) {
   if (!repo) {
     execaOptions.cwd = process.cwd();
   }
-  const result = await execa2("gh", args, execaOptions);
+  const result = await execa3("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}`);
@@ -2936,102 +3256,7 @@ var IssueTrackerFactory = class {
 
 // src/lib/EnvironmentManager.ts
 import fs3 from "fs-extra";
-
-// src/utils/env.ts
-init_logger();
-import path5 from "path";
-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);
-}
-var DOTENV_FLOW_NODE_ENV = process.env.DOTENV_FLOW_NODE_ENV ?? "development";
-function getDotenvFlowFiles() {
-  return [
-    ".env",
-    ".env.local",
-    `.env.${DOTENV_FLOW_NODE_ENV}`,
-    `.env.${DOTENV_FLOW_NODE_ENV}.local`
-  ];
-}
-async function buildEnvSourceCommands(workspacePath, fileExists) {
-  const files = getDotenvFlowFiles();
-  const commands = [];
-  for (const file of files) {
-    const fullPath = path5.join(workspacePath, file);
-    const exists = await fileExists(fullPath);
-    if (exists) {
-      commands.push(`source ${file}`);
-    }
-  }
-  return commands;
-}
-async function findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable) {
-  const files = getDotenvFlowFiles().reverse();
-  for (const file of files) {
-    const fullPath = path5.join(workspacePath, file);
-    if (!await fileExists(fullPath)) {
-      continue;
-    }
-    const value = await getEnvVariable(fullPath, variableName);
-    if (value !== null) {
-      return file;
-    }
-  }
-  return null;
-}
-async function hasVariableInAnyEnvFile(workspacePath, variableName, fileExists, getEnvVariable) {
-  const file = await findEnvFileContainingVariable(workspacePath, variableName, fileExists, getEnvVariable);
-  return file !== null;
-}
+init_env();
 
 // src/utils/port.ts
 import { createHash } from "crypto";
@@ -3248,6 +3473,7 @@ var EnvironmentManager = class {
 };
 
 // src/lib/DatabaseManager.ts
+init_env();
 import fs4 from "fs-extra";
 var DatabaseManager = class {
   constructor(provider, environment, databaseUrlEnvVarName = "DATABASE_URL") {
@@ -3481,140 +3707,7 @@ import { execa as execa4 } from "execa";
 import { existsSync as existsSync2 } from "fs";
 import { join } from "path";
 import { createHash as createHash3 } from "crypto";
-
-// src/utils/terminal.ts
-import { execa as execa3 } 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 hasITerm2 = await detectITerm2();
-  const applescript = hasITerm2 ? await buildITerm2SingleTabScript(options) : await buildAppleScript(options);
-  try {
-    await execa3("osascript", ["-e", applescript]);
-    if (!hasITerm2) {
-      await execa3("osascript", ["-e", 'tell application "Terminal" to activate']);
-    }
-  } catch (error) {
-    throw new Error(
-      `Failed to open terminal window: ${error instanceof Error ? error.message : "Unknown error"}`
-    );
-  }
-}
-async function buildAppleScript(options) {
-  const {
-    workspacePath,
-    command,
-    backgroundColor,
-    port,
-    includeEnvSetup,
-    includePortExport
-  } = options;
-  const commands = [];
-  if (workspacePath) {
-    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
-  }
-  if (includeEnvSetup && workspacePath) {
-    const sourceCommands = await buildEnvSourceCommands(
-      workspacePath,
-      async (p) => existsSync(p)
-    );
-    commands.push(...sourceCommands);
-  }
-  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(path7) {
-  return path7.replace(/'/g, "'\\''");
-}
-function escapeForAppleScript(command) {
-  return command.replace(/\\/g, "\\\\").replace(/"/g, '\\"');
-}
-async function buildITerm2SingleTabScript(options) {
-  const command = await buildCommandSequence(options);
-  let script = 'tell application id "com.googlecode.iterm2"\n';
-  script += "  create window with default profile\n";
-  script += "  set s1 to current session of current window\n\n";
-  if (options.backgroundColor) {
-    const { r, g, b } = options.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(command)}"
-
-`;
-  if (options.title) {
-    script += `  set name of s1 to "${escapeForAppleScript(options.title)}"
-
-`;
-  }
-  script += "  activate\n";
-  script += "end tell";
-  return script;
-}
-async function buildCommandSequence(options) {
-  const {
-    workspacePath,
-    command,
-    port,
-    includeEnvSetup,
-    includePortExport
-  } = options;
-  const commands = [];
-  if (workspacePath) {
-    commands.push(`cd '${escapePathForAppleScript(workspacePath)}'`);
-  }
-  if (includeEnvSetup && workspacePath) {
-    const sourceCommands = await buildEnvSourceCommands(
-      workspacePath,
-      async (p) => existsSync(p)
-    );
-    commands.push(...sourceCommands);
-  }
-  if (includePortExport && port !== void 0) {
-    commands.push(`export PORT=${port}`);
-  }
-  if (command) {
-    commands.push(command);
-  }
-  const fullCommand = commands.join(" && ");
-  return ` ${fullCommand}`;
-}
-
-// src/utils/claude.ts
+init_terminal();
 async function detectClaudeCli() {
   try {
     await execa4("command", ["-v", "claude"], {
@@ -4630,6 +4723,7 @@ export {
   getDefaultBranch,
   getMergeTargetBranch,
   getRepoRoot,
+  getThemeMode,
   getWorktreeRoot,
   hasUncommittedChanges,
   isBranchMergedIntoMain,
@@ -4645,6 +4739,7 @@ export {
   parseWorktreeList,
   pushBranchToRemote,
   removePlaceholderCommitFromHead,
-  removePlaceholderCommitFromHistory
+  removePlaceholderCommitFromHistory,
+  setThemeMode
 };
 //# sourceMappingURL=index.js.map