@iloom/cli 0.3.1 → 0.3.3

package/dist/index.js

@@ -226,7 +226,7 @@ var init_SettingsManager = __esm({
     IloomSettingsSchema = z.object({
       mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
       sourceEnvOnStart: z.boolean().default(false).describe(
-        "Source .env file when launching terminal processes (Claude, dev server, terminal). NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check  .env compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify your .env file does not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
+        "Source all dotenv-flow files (.env, .env.local, .env.development, .env.development.local) when launching terminal processes (Claude, dev server, terminal). Files are sourced in precedence order so later files override earlier ones. NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check .env file compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify ALL your .env.* files do not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
       ),
       worktreePrefix: z.string().optional().refine(
         (val) => {
@@ -272,17 +272,23 @@ var init_SettingsManager = __esm({
         remote: z.string().optional()
       }).optional().describe("Merge behavior configuration: local (merge locally) or github-pr (create PR)"),
       ide: z.object({
-        type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf"]).default("vscode").describe(
-          "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor)."
+        type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf", "antigravity"]).default("vscode").describe(
+          "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor), antigravity (Antigravity IDE)."
         )
       }).optional().describe(
-        "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, and Windsurf. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf)."
-      )
+        "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, Windsurf, and Antigravity. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf, antigravity)."
+      ),
+      colors: z.object({
+        terminal: z.boolean().default(true).describe("Apply terminal background colors based on branch name (macOS only)"),
+        vscode: z.boolean().default(false).describe(
+          "Apply VSCode/Cursor title bar colors based on branch name. Note: This modifies .vscode/settings.json which may be in source control. Default is false for safety; enable via init or explicitly if .vscode is gitignored."
+        )
+      }).optional().describe("Color synchronization settings for workspace identification")
     });
     IloomSettingsSchemaNoDefaults = z.object({
       mainBranch: z.string().min(1, "Settings 'mainBranch' cannot be empty").optional().describe("Name of the main/primary branch for the repository"),
       sourceEnvOnStart: z.boolean().optional().describe(
-        "Source .env file when launching terminal processes (Claude, dev server, terminal). NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check  .env compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify your .env file does not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
+        "Source all dotenv-flow files (.env, .env.local, .env.development, .env.development.local) when launching terminal processes (Claude, dev server, terminal). Files are sourced in precedence order so later files override earlier ones. NOTE TO AI AGENTS: Before making changes to settings files, YOU MUST OFFER to check .env compatibility. WARNING: Unquoted values in .env files may break sourcing in bash/zsh shells. Before enabling, verify ALL your .env.* files do not contain unquoted special characters (e.g., database URLs with ?, &, or other shell metacharacters). Shell compatibility issues may cause processes to fail or behave unexpectedly."
       ),
       worktreePrefix: z.string().optional().refine(
         (val) => {
@@ -328,12 +334,18 @@ var init_SettingsManager = __esm({
         remote: z.string().optional()
       }).optional().describe("Merge behavior configuration: local (merge locally) or github-pr (create PR)"),
       ide: z.object({
-        type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf"]).optional().describe(
-          "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor)."
+        type: z.enum(["vscode", "cursor", "webstorm", "sublime", "intellij", "windsurf", "antigravity"]).optional().describe(
+          "IDE to launch when starting a loom. Options: vscode (Visual Studio Code), cursor (Cursor AI editor), webstorm (JetBrains WebStorm), sublime (Sublime Text), intellij (JetBrains IntelliJ IDEA), windsurf (Windsurf editor), antigravity (Antigravity IDE)."
         )
       }).optional().describe(
-        "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, and Windsurf. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf)."
-      )
+        "IDE configuration for workspace launches. Controls which editor opens when you start a loom. Supports VSCode, Cursor, WebStorm, Sublime Text, IntelliJ, Windsurf, and Antigravity. Note: Color synchronization (title bar colors) only works with VSCode-compatible editors (vscode, cursor, windsurf, antigravity)."
+      ),
+      colors: z.object({
+        terminal: z.boolean().optional().describe("Apply terminal background colors based on branch name (macOS only)"),
+        vscode: z.boolean().optional().describe(
+          "Apply VSCode/Cursor title bar colors based on branch name. Note: This modifies .vscode/settings.json which may be in source control."
+        )
+      }).optional().describe("Color synchronization settings for workspace identification")
     });
     SettingsManager = class {
       /**
@@ -433,8 +445,8 @@ Note: CLI overrides were applied. Check your --set arguments.`);
        */
       formatAllZodErrors(error, settingsPath) {
         const errorMessages = error.issues.map((issue) => {
-          const path5 = issue.path.length > 0 ? issue.path.join(".") : "root";
-          return `  - ${path5}: ${issue.message}`;
+          const path6 = issue.path.length > 0 ? issue.path.join(".") : "root";
+          return `  - ${path6}: ${issue.message}`;
         });
         return new Error(
           `Settings validation failed at ${settingsPath}:
@@ -540,333 +552,55 @@ ${errorMessages.join("\n")}`
   }
 });
 
-// src/utils/terminal.ts
-var terminal_exports = {};
-__export(terminal_exports, {
-  detectITerm2: () => detectITerm2,
-  detectPlatform: () => detectPlatform,
-  openDualTerminalWindow: () => openDualTerminalWindow,
-  openMultipleTerminalWindows: () => openMultipleTerminalWindows,
-  openTerminalWindow: () => openTerminalWindow
-});
-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 ? buildITerm2SingleTabScript(options) : 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"}`
-    );
-  }
-}
-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 buildITerm2SingleTabScript(options) {
-  const command = 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;
-}
-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 execa3("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, {
+  MIN_COLOR_DISTANCE: () => MIN_COLOR_DISTANCE,
   calculateForegroundColor: () => calculateForegroundColor,
+  colorDistance: () => colorDistance,
   generateColorFromBranchName: () => generateColorFromBranchName,
   getColorPalette: () => getColorPalette,
   hexToRgb: () => hexToRgb,
   lightenColor: () => lightenColor,
   rgbToHex: () => rgbToHex,
-  saturateColor: () => saturateColor
+  saturateColor: () => saturateColor,
+  selectDistinctColor: () => selectDistinctColor
 });
 import { createHash as createHash2 } from "crypto";
 function getColorPalette() {
   return [
-    // First 10 colors preserved for backward compatibility
-    { r: 220, g: 235, b: 248 },
+    { r: 220, g: 235, b: 255 },
     // 0: Soft blue
-    { r: 248, g: 220, b: 235 },
+    { r: 255, g: 220, b: 235 },
     // 1: Soft pink
-    { r: 220, g: 248, b: 235 },
+    { r: 220, g: 255, b: 235 },
     // 2: Soft green
-    { r: 248, g: 240, b: 220 },
+    { r: 255, g: 245, b: 220 },
     // 3: Soft cream
-    { r: 240, g: 220, b: 248 },
+    { r: 245, g: 220, b: 255 },
     // 4: Soft lavender
-    { r: 220, g: 240, b: 248 },
+    { r: 220, g: 245, b: 255 },
     // 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
+    { r: 255, g: 230, b: 230 },
+    // 7: Soft coral
+    { r: 230, g: 255, b: 230 },
+    // 8: Soft mint
+    { r: 255, g: 245, b: 230 },
+    // 9: Soft peach
+    { r: 220, g: 255, b: 255 },
+    // 10: Soft aqua
+    { r: 255, g: 220, b: 255 },
+    // 11: Soft magenta
+    { r: 255, g: 255, b: 220 },
+    // 12: Soft yellow
+    { r: 235, g: 220, b: 255 },
+    // 13: Soft violet
+    { r: 220, g: 255, b: 245 },
+    // 14: Soft sea green
+    { r: 255, g: 235, b: 220 }
+    // 15: Soft salmon
   ];
 }
 function rgbToHex(r, g, b) {
@@ -906,6 +640,51 @@ function generateColorFromBranchName(branchName) {
     index
   };
 }
+function colorDistance(a, b) {
+  return Math.sqrt(
+    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);
+  if (usedHexColors.length === 0) {
+    return hashBasedColor;
+  }
+  const usedRgbColors = [];
+  for (const hex of usedHexColors) {
+    try {
+      usedRgbColors.push(hexToRgb(hex));
+    } catch {
+      logger_default.debug(`[selectDistinctColor] Skipping invalid hex color: ${hex}`);
+    }
+  }
+  if (usedRgbColors.length === 0) {
+    return hashBasedColor;
+  }
+  const isTooSimilar = usedRgbColors.some(
+    (usedRgb) => colorDistance(hashBasedColor.rgb, usedRgb) < MIN_COLOR_DISTANCE
+  );
+  if (!isTooSimilar) {
+    return hashBasedColor;
+  }
+  for (let i = 0; i < palette.length; i++) {
+    const candidateRgb = palette[i];
+    if (!candidateRgb) continue;
+    const isDistinct = usedRgbColors.every(
+      (usedRgb) => colorDistance(candidateRgb, usedRgb) >= MIN_COLOR_DISTANCE
+    );
+    if (isDistinct) {
+      return {
+        rgb: candidateRgb,
+        hex: rgbToHex(candidateRgb.r, candidateRgb.g, candidateRgb.b),
+        index: i
+      };
+    }
+  }
+  logger_default.debug(`[selectDistinctColor] No distinct color found, falling back to hash-based for ${branchName}`);
+  return hashBasedColor;
+}
 function lightenColor(rgb, amount) {
   const clamp = (value) => Math.min(255, Math.max(0, Math.round(value)));
   return {
@@ -934,10 +713,12 @@ function calculateForegroundColor(rgb) {
   const luminance = 0.2126 * r + 0.7152 * g + 0.0722 * b;
   return luminance > 0.5 ? "#000000" : "#ffffff";
 }
+var MIN_COLOR_DISTANCE;
 var init_color = __esm({
   "src/utils/color.ts"() {
     "use strict";
     init_logger();
+    MIN_COLOR_DISTANCE = 20;
   }
 });
 
@@ -951,6 +732,7 @@ import path3 from "path";
 import fs from "fs-extra";
 
 // src/utils/git.ts
+init_SettingsManager();
 init_logger();
 import path2 from "path";
 import { execa } from "execa";
@@ -1097,7 +879,7 @@ function extractIssueNumber(branchName) {
   }
   return null;
 }
-function isWorktreePath(path5) {
+function isWorktreePath(path6) {
   const worktreePatterns = [
     /\/worktrees?\//i,
     // Contains /worktree/ or /worktrees/
@@ -1112,7 +894,7 @@ function isWorktreePath(path5) {
     /\.worktree$/i
     // ends with .worktree
   ];
-  return worktreePatterns.some((pattern) => pattern.test(path5));
+  return worktreePatterns.some((pattern) => pattern.test(path6));
 }
 function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
   let sanitized = branchName.replace(/\//g, "-");
@@ -1154,31 +936,31 @@ function generateWorktreePath(branchName, rootDir = process.cwd(), options) {
     return path2.join(parentDir, `${prefix}${sanitized}`);
   }
 }
-async function isValidGitRepo(path5) {
+async function isValidGitRepo(path6) {
   try {
-    await executeGitCommand(["rev-parse", "--git-dir"], { cwd: path5 });
+    await executeGitCommand(["rev-parse", "--git-dir"], { cwd: path6 });
     return true;
   } catch {
     return false;
   }
 }
-async function getCurrentBranch(path5 = process.cwd()) {
+async function getCurrentBranch(path6 = process.cwd()) {
   try {
-    const result = await executeGitCommand(["branch", "--show-current"], { cwd: path5 });
+    const result = await executeGitCommand(["branch", "--show-current"], { cwd: path6 });
     return result.trim();
   } catch {
     return null;
   }
 }
-async function branchExists(branchName, path5 = process.cwd(), includeRemote = true) {
+async function branchExists(branchName, path6 = process.cwd(), includeRemote = true) {
   try {
-    const localResult = await executeGitCommand(["branch", "--list", branchName], { cwd: path5 });
+    const localResult = await executeGitCommand(["branch", "--list", branchName], { cwd: path6 });
     if (localResult.trim()) {
       return true;
     }
     if (includeRemote) {
       const remoteResult = await executeGitCommand(["branch", "-r", "--list", `*/${branchName}`], {
-        cwd: path5
+        cwd: path6
       });
       if (remoteResult.trim()) {
         return true;
@@ -1189,17 +971,31 @@ async function branchExists(branchName, path5 = process.cwd(), includeRemote = t
     return false;
   }
 }
-async function getRepoRoot(path5 = process.cwd()) {
+async function getWorktreeRoot(path6 = process.cwd()) {
   try {
-    const result = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd: path5 });
+    const result = await executeGitCommand(["rev-parse", "--show-toplevel"], { cwd: path6 });
     return result.trim();
   } catch {
     return null;
   }
 }
-async function findMainWorktreePath(path5 = process.cwd(), options) {
+async function getRepoRoot(path6 = process.cwd()) {
+  try {
+    const gitCommonDir = await executeGitCommand(
+      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
+      { cwd: path6 }
+    );
+    const trimmedPath = gitCommonDir.trim();
+    const repoRoot = trimmedPath.replace(/\/\.git\/worktrees\/[^/]+$/, "").replace(/\/\.git$/, "");
+    return repoRoot;
+  } catch (error) {
+    logger.warn(`Failed to determine repo root from git-common-dir: ${path6}`, error instanceof Error ? error.message : String(error));
+    return null;
+  }
+}
+async function findMainWorktreePath(path6 = process.cwd(), options) {
   try {
-    const output = await executeGitCommand(["worktree", "list", "--porcelain"], { cwd: path5 });
+    const output = await executeGitCommand(["worktree", "list", "--porcelain"], { cwd: path6 });
     const worktrees = parseWorktreeList(output, options == null ? void 0 : options.mainBranch);
     if (worktrees.length === 0) {
       throw new Error("No worktrees found in repository");
@@ -1229,33 +1025,30 @@ async function findMainWorktreePath(path5 = process.cwd(), options) {
     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);
+async function findMainWorktreePathWithSettings(path6, settingsManager) {
+  settingsManager ??= new SettingsManager();
+  const settings = await settingsManager.loadSettings(path6);
   const findOptions = settings.mainBranch ? { mainBranch: settings.mainBranch } : void 0;
-  return findMainWorktreePath(path5, findOptions);
+  return findMainWorktreePath(path6, findOptions);
 }
-async function hasUncommittedChanges(path5 = process.cwd()) {
+async function hasUncommittedChanges(path6 = process.cwd()) {
   try {
-    const result = await executeGitCommand(["status", "--porcelain"], { cwd: path5 });
+    const result = await executeGitCommand(["status", "--porcelain"], { cwd: path6 });
     return result.trim().length > 0;
   } catch {
     return false;
   }
 }
-async function getDefaultBranch(path5 = process.cwd()) {
+async function getDefaultBranch(path6 = process.cwd()) {
   try {
     const remoteResult = await executeGitCommand(["symbolic-ref", "refs/remotes/origin/HEAD"], {
-      cwd: path5
+      cwd: path6
     });
     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)) {
+      if (await branchExists(branch, path6)) {
         return branch;
       }
     }
@@ -1264,13 +1057,13 @@ async function getDefaultBranch(path5 = process.cwd()) {
     return "main";
   }
 }
-async function findAllBranchesForIssue(issueNumber, path5 = process.cwd(), settingsManager) {
+async function findAllBranchesForIssue(issueNumber, path6 = 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 protectedBranches = await settingsManager.getProtectedBranches(path6);
+  const output = await executeGitCommand(["branch", "-a"], { cwd: path6 });
   const branches = [];
   const lines = output.split("\n").filter(Boolean);
   for (const line of lines) {
@@ -1327,18 +1120,18 @@ async function findAllBranchesForIssue(issueNumber, path5 = process.cwd(), setti
   }
   return branches;
 }
-async function isEmptyRepository(path5 = process.cwd()) {
+async function isEmptyRepository(path6 = process.cwd()) {
   try {
-    await executeGitCommand(["rev-parse", "--verify", "HEAD"], { cwd: path5 });
+    await executeGitCommand(["rev-parse", "--verify", "HEAD"], { cwd: path6 });
     return false;
   } catch {
     return true;
   }
 }
-async function ensureRepositoryHasCommits(path5 = process.cwd()) {
-  const isEmpty = await isEmptyRepository(path5);
+async function ensureRepositoryHasCommits(path6 = process.cwd()) {
+  const isEmpty = await isEmptyRepository(path6);
   if (isEmpty) {
-    await executeGitCommand(["commit", "--no-verify", "--allow-empty", "-m", "Initial commit"], { cwd: path5 });
+    await executeGitCommand(["commit", "--no-verify", "--allow-empty", "-m", "Initial commit"], { cwd: path6 });
   }
 }
 async function pushBranchToRemote(branchName, worktreePath, options) {
@@ -1383,6 +1176,29 @@ async function pushBranchToRemote(branchName, worktreePath, options) {
     throw new Error(`Failed to push to remote: ${errorMessage}`);
   }
 }
+async function isFileTrackedByGit(filePath, cwd = process.cwd()) {
+  try {
+    const result = await executeGitCommand(
+      ["ls-files", "--error-unmatch", filePath],
+      { cwd }
+    );
+    return result.trim().length > 0;
+  } catch (error) {
+    const errorMessage = error instanceof Error ? error.message : String(error);
+    if (errorMessage.includes("pathspec") && errorMessage.includes("did not match")) {
+      return false;
+    }
+    throw error;
+  }
+}
+async function isFileGitignored(filePath, cwd = process.cwd()) {
+  try {
+    await executeGitCommand(["check-ignore", "-q", filePath], { cwd });
+    return true;
+  } catch {
+    return false;
+  }
+}
 
 // src/lib/GitWorktreeManager.ts
 var GitWorktreeManager = class {
@@ -1752,6 +1568,9 @@ var GitWorktreeManager = class {
   }
 };
 
+// src/lib/GitHubService.ts
+import { execSync } from "child_process";
+
 // src/types/github.ts
 var GitHubError = class extends Error {
   constructor(code, message, details) {
@@ -1991,6 +1810,18 @@ var GitHubService = class {
     this.supportsPullRequests = true;
     this.prompter = (options == null ? void 0 : options.prompter) ?? promptConfirmation;
   }
+  /**
+   * Check if GitHub CLI (gh) is available on the system
+   * @returns true if gh CLI is installed and accessible, false otherwise
+   */
+  static isCliAvailable() {
+    try {
+      execSync("gh --version", { stdio: "ignore" });
+      return true;
+    } catch {
+      return false;
+    }
+  }
   // Input detection - IssueTracker interface implementation
   async detectInputType(input, repo) {
     const numberMatch = input.match(/^#?(\d+)$/);
@@ -2611,6 +2442,7 @@ import fs2 from "fs-extra";
 
 // src/utils/env.ts
 init_logger();
+import path4 from "path";
 import dotenvFlow from "dotenv-flow";
 function parseEnvFile(content) {
   const envMap = /* @__PURE__ */ new Map();
@@ -2664,6 +2496,45 @@ function isValidEnvKey(key) {
   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 = path4.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 = path4.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;
+}
 
 // src/utils/port.ts
 import { createHash } from "crypto";
@@ -2882,6 +2753,7 @@ var EnvironmentManager = class {
 
 // src/lib/DatabaseManager.ts
 init_logger();
+import fs3 from "fs-extra";
 var logger3 = createLogger({ prefix: "\u{1F5C2}\uFE0F" });
 var DatabaseManager = class {
   constructor(provider, environment, databaseUrlEnvVarName = "DATABASE_URL") {
@@ -2904,17 +2776,17 @@ var DatabaseManager = class {
    * 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
+   *   2. Any dotenv-flow file contains the configured database URL variable
    */
-  async shouldUseDatabaseBranching(envFilePath) {
+  async shouldUseDatabaseBranching(workspacePath) {
     if (!this.provider.isConfigured()) {
       logger3.debug("Skipping database branching: Database provider not configured");
       return false;
     }
-    const hasDatabaseUrl = await this.hasDatabaseUrlInEnv(envFilePath);
+    const hasDatabaseUrl = await this.hasDatabaseUrlInEnv(workspacePath);
     if (!hasDatabaseUrl) {
       logger3.debug(
-        "Skipping database branching: configured database URL variable not found in .env file"
+        "Skipping database branching: configured database URL variable not found in any env file"
       );
       return false;
     }
@@ -2925,12 +2797,12 @@ var DatabaseManager = class {
    * 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 workspacePath - Path to workspace for configuration checks (checks all dotenv-flow files)
    * @param cwd - Optional working directory to run commands from
    * @param fromBranch - Optional parent branch to create from (for child looms)
    */
-  async createBranchIfConfigured(branchName, envFilePath, cwd, fromBranch) {
-    if (!await this.shouldUseDatabaseBranching(envFilePath)) {
+  async createBranchIfConfigured(branchName, workspacePath, cwd, fromBranch) {
+    if (!await this.shouldUseDatabaseBranching(workspacePath)) {
       return null;
     }
     if (!await this.provider.isCliAvailable()) {
@@ -3057,19 +2929,24 @@ var DatabaseManager = class {
     return null;
   }
   /**
-   * Check if .env has the configured database URL variable
+   * Check if any dotenv-flow file 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
+   * throw an error if it's missing from all env files
    */
-  async hasDatabaseUrlInEnv(envFilePath) {
+  async hasDatabaseUrlInEnv(workspacePath) {
     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)) {
+      const hasConfiguredVar = await hasVariableInAnyEnvFile(
+        workspacePath,
+        this.databaseUrlEnvVarName,
+        async (p) => fs3.pathExists(p),
+        async (p, v) => this.environment.getEnvVariable(p, v)
+      );
+      if (hasConfiguredVar) {
         if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
           logger3.debug(`\u2705 Found custom database URL variable: ${this.databaseUrlEnvVarName}`);
         } else {
@@ -3078,20 +2955,25 @@ var DatabaseManager = class {
         return true;
       }
       if (this.databaseUrlEnvVarName !== "DATABASE_URL") {
-        logger3.debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in .env file`);
+        logger3.debug(`\u274C Custom database URL variable '${this.databaseUrlEnvVarName}' not found in any 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.`
+          `Configured database URL environment variable '${this.databaseUrlEnvVarName}' not found in any dotenv-flow file. Please add it to an .env file or update your iloom configuration.`
         );
       }
-      const hasDefaultVar = envMap.has("DATABASE_URL");
+      const hasDefaultVar = await hasVariableInAnyEnvFile(
+        workspacePath,
+        "DATABASE_URL",
+        async (p) => fs3.pathExists(p),
+        async (p, v) => this.environment.getEnvVariable(p, v)
+      );
       if (hasDefaultVar) {
         logger3.debug("\u2705 Found fallback DATABASE_URL variable");
       } else {
-        logger3.debug("\u274C No DATABASE_URL variable found in .env file");
+        logger3.debug("\u274C No DATABASE_URL variable found in any env file");
       }
       return hasDefaultVar;
     } catch (error) {
-      if (error instanceof Error && error.message.includes("not found in .env")) {
+      if (error instanceof Error && error.message.includes("not found in")) {
         throw error;
       }
       return false;
@@ -3104,6 +2986,140 @@ init_logger();
 import { execa as execa4 } from "execa";
 import { existsSync as existsSync2 } from "fs";
 import { join } from "path";
+
+// 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(path6) {
+  return path6.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
 async function detectClaudeCli() {
   try {
     await execa4("command", ["-v", "claude"], {
@@ -3247,7 +3263,6 @@ async function launchClaudeInNewTerminalWindow(_prompt, 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") {
@@ -3271,7 +3286,7 @@ async function launchClaudeInNewTerminalWindow(_prompt, options) {
     }
   }
   const hasEnvFile = existsSync2(join(workspacePath, ".env"));
-  await openTerminalWindow2({
+  await openTerminalWindow({
     workspacePath,
     command: launchCommand,
     ...backgroundColor && { backgroundColor },
@@ -3285,7 +3300,7 @@ async function launchClaudeInNewTerminalWindow(_prompt, options) {
 init_logger();
 import { readFile as readFile2 } from "fs/promises";
 import { accessSync } from "fs";
-import path4 from "path";
+import path5 from "path";
 import { fileURLToPath } from "url";
 var PromptTemplateManager = class {
   constructor(templateDir) {
@@ -3294,17 +3309,17 @@ var PromptTemplateManager = class {
     } else {
       const currentFileUrl = import.meta.url;
       const currentFilePath = fileURLToPath(currentFileUrl);
-      const distDir = path4.dirname(currentFilePath);
-      let templateDir2 = path4.join(distDir, "prompts");
+      const distDir = path5.dirname(currentFilePath);
+      let templateDir2 = path5.join(distDir, "prompts");
       let currentDir = distDir;
-      while (currentDir !== path4.dirname(currentDir)) {
-        const candidatePath = path4.join(currentDir, "prompts");
+      while (currentDir !== path5.dirname(currentDir)) {
+        const candidatePath = path5.join(currentDir, "prompts");
         try {
           accessSync(candidatePath);
           templateDir2 = candidatePath;
           break;
         } catch {
-          currentDir = path4.dirname(currentDir);
+          currentDir = path5.dirname(currentDir);
         }
       }
       this.templateDir = templateDir2;
@@ -3319,7 +3334,7 @@ var PromptTemplateManager = class {
    * Load a template file by name
    */
   async loadTemplate(templateName) {
-    const templatePath = path4.join(this.templateDir, `${templateName}-prompt.txt`);
+    const templatePath = path5.join(this.templateDir, `${templateName}-prompt.txt`);
     logger.debug("Loading template", {
       templateName,
       templateDir: this.templateDir,
@@ -3401,6 +3416,9 @@ var PromptTemplateManager = class {
     if (variables.SETTINGS_SCHEMA_CONTENT !== void 0) {
       result = result.replace(/SETTINGS_SCHEMA_CONTENT/g, variables.SETTINGS_SCHEMA_CONTENT);
     }
+    if (variables.VSCODE_SETTINGS_GITIGNORED !== void 0) {
+      result = result.replace(/VSCODE_SETTINGS_GITIGNORED/g, variables.VSCODE_SETTINGS_GITIGNORED);
+    }
     return result;
   }
   /**
@@ -3646,6 +3664,14 @@ var ClaudeContextManager = class {
   }
 };
 
+// src/types/index.ts
+var UserAbortedCommitError = class extends Error {
+  constructor(message = "User aborted the commit") {
+    super(message);
+    this.name = "UserAbortedCommitError";
+  }
+};
+
 // src/utils/index.ts
 init_logger();
 
@@ -3958,6 +3984,7 @@ export {
   IssueTrackerFactory,
   LinearMarkupConverter,
   TableFormatter,
+  UserAbortedCommitError,
   WorkspaceManager,
   branchExists,
   createLogger,
@@ -3972,8 +3999,11 @@ export {
   getCurrentBranch,
   getDefaultBranch,
   getRepoRoot,
+  getWorktreeRoot,
   hasUncommittedChanges,
   isEmptyRepository,
+  isFileGitignored,
+  isFileTrackedByGit,
   isPRBranch,
   isValidGitRepo,
   isWorktreePath,