autohand-cli 0.7.13 → 0.8.0

package/dist/{chunk-ZBIBLOZL.js → chunk-IVM5F2AE.js}

@@ -1,71 +1,10 @@
 import {
   Theme,
   detectColorMode,
+  getTheme,
+  isThemeInitialized,
   setTheme
 } from "./chunk-JS7IPR7P.js";
-import {
-  AUTOHAND_FILES
-} from "./chunk-PWLLLJHU.js";
-
-// src/ui/theme/loader.ts
-import { readFileSync, existsSync, readdirSync } from "fs";
-import { join } from "path";
-import { homedir } from "os";
-
-// src/ui/theme/types.ts
-var COLOR_TOKENS = [
-  // Core UI
-  "accent",
-  "border",
-  "borderAccent",
-  "borderMuted",
-  "success",
-  "error",
-  "warning",
-  "muted",
-  "dim",
-  "text",
-  // Backgrounds & Content
-  "userMessageBg",
-  "userMessageText",
-  "toolPendingBg",
-  "toolSuccessBg",
-  "toolErrorBg",
-  "toolTitle",
-  "toolOutput",
-  // Diff Colors
-  "diffAdded",
-  "diffRemoved",
-  "diffContext",
-  // Syntax Highlighting
-  "syntaxComment",
-  "syntaxKeyword",
-  "syntaxFunction",
-  "syntaxVariable",
-  "syntaxString",
-  "syntaxNumber",
-  "syntaxType",
-  "syntaxOperator",
-  "syntaxPunctuation",
-  // Markdown
-  "mdHeading",
-  "mdLink",
-  "mdLinkUrl",
-  "mdCode",
-  "mdCodeBlock",
-  "mdCodeBlockBorder",
-  "mdQuote",
-  "mdQuoteBorder",
-  "mdHr",
-  "mdListBullet"
-];
-function isHexColor(value) {
-  if (typeof value !== "string") return false;
-  return /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
-}
-function is256ColorIndex(value) {
-  return typeof value === "number" && value >= 0 && value <= 255 && Number.isInteger(value);
-}
 
 // src/ui/theme/themes.ts
 var darkTheme = {
@@ -102,7 +41,7 @@ var darkTheme = {
     borderMuted: "gray800",
     success: "green",
     error: "red",
-    warning: "yellow",
+    warning: "orange",
     muted: "gray500",
     dim: "gray200",
     text: "gray200",
@@ -371,6 +310,92 @@ var tuiTheme = {
     mdListBullet: "pauaTeal"
   }
 };
+var githubDarkTheme = {
+  name: "github-dark",
+  vars: {
+    // GitHub Dark ANSI palette (colors 0–15)
+    gray: "#6e7681",
+    // ANSI 0/8 - muted gray
+    red: "#f97583",
+    // ANSI 1 - coral red
+    green: "#3fb950",
+    // ANSI 2 - green
+    yellow: "#d29922",
+    // ANSI 3 - orange/yellow
+    blue: "#79c0ff",
+    // ANSI 4 - blue
+    purple: "#d2a8ff",
+    // ANSI 5 - purple
+    cyan: "#56d4dd",
+    // ANSI 6 - cyan
+    lightGray: "#8b949e",
+    // ANSI 7 - light gray
+    brightRed: "#ffa198",
+    // ANSI 9 - light pink
+    brightGreen: "#56d364",
+    // ANSI 10 - light green
+    brightYellow: "#e3b341",
+    // ANSI 11 - light orange
+    brightBlue: "#a5d6ff",
+    // ANSI 12 - light blue
+    brightCyan: "#76e4f7",
+    // ANSI 14 - light cyan
+    white: "#ffffff",
+    // ANSI 15 - white
+    // GitHub Dark semantic backgrounds
+    bg: "#0d1117",
+    bgSurface: "#161b22",
+    bgOverlay: "#1c2128",
+    borderDefault: "#30363d",
+    fgDefault: "#e6edf3"
+  },
+  colors: {
+    // Core UI
+    accent: "blue",
+    border: "borderDefault",
+    borderAccent: "blue",
+    borderMuted: "#21262d",
+    success: "green",
+    error: "red",
+    warning: "yellow",
+    muted: "lightGray",
+    dim: "fgDefault",
+    text: "fgDefault",
+    // Backgrounds & Content
+    userMessageBg: "bgSurface",
+    userMessageText: "fgDefault",
+    toolPendingBg: "bgOverlay",
+    toolSuccessBg: "#0f2d16",
+    toolErrorBg: "#3d1418",
+    toolTitle: "blue",
+    toolOutput: "lightGray",
+    // Diff Colors
+    diffAdded: "green",
+    diffRemoved: "red",
+    diffContext: "lightGray",
+    // Syntax Highlighting
+    syntaxComment: "gray",
+    syntaxKeyword: "red",
+    syntaxFunction: "purple",
+    syntaxVariable: "brightBlue",
+    syntaxString: "brightBlue",
+    syntaxNumber: "blue",
+    syntaxType: "brightRed",
+    syntaxOperator: "red",
+    syntaxPunctuation: "lightGray",
+    // Markdown
+    mdHeading: "blue",
+    mdLink: "blue",
+    mdLinkUrl: "lightGray",
+    mdCode: "brightCyan",
+    mdCodeBlock: "fgDefault",
+    mdCodeBlockBorder: "borderDefault",
+    mdQuote: "lightGray",
+    mdQuoteBorder: "borderDefault",
+    mdHr: "borderDefault",
+    mdListBullet: "blue"
+  }
+};
 var lightTheme = {
   name: "light",
   vars: {
@@ -449,14 +474,337 @@ var builtInThemes = {
   light: lightTheme,
   dracula: draculaTheme,
   sandy: sandyTheme,
-  tui: tuiTheme
+  tui: tuiTheme,
+  "github-dark": githubDarkTheme
 };
 function getDefaultThemeName() {
   return "dark";
 }
 
 // src/ui/theme/loader.ts
-var CUSTOM_THEMES_DIR = join(homedir(), ".autohand", "themes");
+import { readFileSync as readFileSync2, existsSync as existsSync2, readdirSync as readdirSync2 } from "fs";
+import { join as join2 } from "path";
+import { homedir as homedir2 } from "os";
+
+// src/ui/theme/types.ts
+var COLOR_TOKENS = [
+  // Core UI
+  "accent",
+  "border",
+  "borderAccent",
+  "borderMuted",
+  "success",
+  "error",
+  "warning",
+  "muted",
+  "dim",
+  "text",
+  // Backgrounds & Content
+  "userMessageBg",
+  "userMessageText",
+  "toolPendingBg",
+  "toolSuccessBg",
+  "toolErrorBg",
+  "toolTitle",
+  "toolOutput",
+  // Diff Colors
+  "diffAdded",
+  "diffRemoved",
+  "diffContext",
+  // Syntax Highlighting
+  "syntaxComment",
+  "syntaxKeyword",
+  "syntaxFunction",
+  "syntaxVariable",
+  "syntaxString",
+  "syntaxNumber",
+  "syntaxType",
+  "syntaxOperator",
+  "syntaxPunctuation",
+  // Markdown
+  "mdHeading",
+  "mdLink",
+  "mdLinkUrl",
+  "mdCode",
+  "mdCodeBlock",
+  "mdCodeBlockBorder",
+  "mdQuote",
+  "mdQuoteBorder",
+  "mdHr",
+  "mdListBullet"
+];
+function isHexColor(value) {
+  if (typeof value !== "string") return false;
+  return /^#([0-9a-fA-F]{3}|[0-9a-fA-F]{6})$/.test(value);
+}
+function is256ColorIndex(value) {
+  return typeof value === "number" && value >= 0 && value <= 255 && Number.isInteger(value);
+}
+
+// src/ui/theme/ghosttyLoader.ts
+import { readFileSync, existsSync, readdirSync } from "fs";
+import { execSync } from "child_process";
+import { join } from "path";
+import { homedir, platform } from "os";
+function getGhosttyThemeDirs() {
+  const dirs = [];
+  if (platform() === "darwin") {
+    dirs.push("/Applications/Ghostty.app/Contents/Resources/ghostty/themes");
+  }
+  const xdgDataDirs = process.env.XDG_DATA_DIRS?.split(":") ?? ["/usr/share", "/usr/local/share"];
+  for (const dir of xdgDataDirs) {
+    dirs.push(join(dir, "ghostty", "themes"));
+  }
+  const configHome = process.env.XDG_CONFIG_HOME ?? join(process.env.HOME ?? "", ".config");
+  dirs.push(join(configHome, "ghostty", "themes"));
+  return dirs;
+}
+function findGhosttyThemesDir() {
+  for (const dir of getGhosttyThemeDirs()) {
+    if (existsSync(dir)) {
+      return dir;
+    }
+  }
+  return null;
+}
+function parseGhosttyTheme(content) {
+  const palette = /* @__PURE__ */ new Map();
+  let background = "#1a1a1a";
+  let foreground = "#e0e0e0";
+  let cursorColor;
+  let cursorText;
+  let selectionBackground;
+  let selectionForeground;
+  for (const line of content.split("\n")) {
+    const trimmed = line.trim();
+    if (!trimmed || trimmed.startsWith("#")) continue;
+    const eqIdx = trimmed.indexOf("=");
+    if (eqIdx === -1) continue;
+    const key = trimmed.slice(0, eqIdx).trim();
+    const value = trimmed.slice(eqIdx + 1).trim();
+    if (key === "palette") {
+      const paletteEq = value.indexOf("=");
+      if (paletteEq !== -1) {
+        const idx = parseInt(value.slice(0, paletteEq), 10);
+        const color = value.slice(paletteEq + 1).trim();
+        if (!isNaN(idx) && idx >= 0 && idx <= 15 && /^#[0-9a-fA-F]{6}$/.test(color)) {
+          palette.set(idx, color);
+        }
+      }
+    } else if (key === "background") {
+      if (/^#[0-9a-fA-F]{6}$/.test(value)) background = value;
+    } else if (key === "foreground") {
+      if (/^#[0-9a-fA-F]{6}$/.test(value)) foreground = value;
+    } else if (key === "cursor-color") {
+      if (/^#[0-9a-fA-F]{6}$/.test(value)) cursorColor = value;
+    } else if (key === "cursor-text") {
+      if (/^#[0-9a-fA-F]{6}$/.test(value)) cursorText = value;
+    } else if (key === "selection-background") {
+      if (/^#[0-9a-fA-F]{6}$/.test(value)) selectionBackground = value;
+    } else if (key === "selection-foreground") {
+      if (/^#[0-9a-fA-F]{6}$/.test(value)) selectionForeground = value;
+    }
+  }
+  return { palette, background, foreground, cursorColor, cursorText, selectionBackground, selectionForeground };
+}
+function adjustBrightness(hex, factor) {
+  const r = parseInt(hex.slice(1, 3), 16);
+  const g = parseInt(hex.slice(3, 5), 16);
+  const b = parseInt(hex.slice(5, 7), 16);
+  const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+  return `#${clamp(r * factor).toString(16).padStart(2, "0")}${clamp(g * factor).toString(16).padStart(2, "0")}${clamp(b * factor).toString(16).padStart(2, "0")}`;
+}
+function mixColors(hex1, hex2, ratio) {
+  const r1 = parseInt(hex1.slice(1, 3), 16);
+  const g1 = parseInt(hex1.slice(3, 5), 16);
+  const b1 = parseInt(hex1.slice(5, 7), 16);
+  const r2 = parseInt(hex2.slice(1, 3), 16);
+  const g2 = parseInt(hex2.slice(3, 5), 16);
+  const b2 = parseInt(hex2.slice(5, 7), 16);
+  const clamp = (n) => Math.max(0, Math.min(255, Math.round(n)));
+  const r = clamp(r1 + (r2 - r1) * ratio);
+  const g = clamp(g1 + (g2 - g1) * ratio);
+  const b = clamp(b1 + (b2 - b1) * ratio);
+  return `#${r.toString(16).padStart(2, "0")}${g.toString(16).padStart(2, "0")}${b.toString(16).padStart(2, "0")}`;
+}
+function getLuminance(hex) {
+  const r = parseInt(hex.slice(1, 3), 16) / 255;
+  const g = parseInt(hex.slice(3, 5), 16) / 255;
+  const b = parseInt(hex.slice(5, 7), 16) / 255;
+  return 0.2126 * r + 0.7152 * g + 0.0722 * b;
+}
+function ghosttyPaletteToTheme(name, gp) {
+  const p = (idx, fallback) => gp.palette.get(idx) ?? fallback;
+  const bg = gp.background;
+  const fg = gp.foreground;
+  const isDark = getLuminance(bg) < 0.5;
+  const bgSurface = isDark ? adjustBrightness(bg, 1.3) : adjustBrightness(bg, 0.95);
+  const bgOverlay = isDark ? adjustBrightness(bg, 1.5) : adjustBrightness(bg, 0.9);
+  const borderColor = isDark ? adjustBrightness(bg, 2) : adjustBrightness(bg, 0.8);
+  const borderMuted = isDark ? adjustBrightness(bg, 1.6) : adjustBrightness(bg, 0.88);
+  const green = p(2, "#4caf50");
+  const red = p(1, "#f44336");
+  const toolSuccessBg = mixColors(bg, green, 0.15);
+  const toolErrorBg = mixColors(bg, red, 0.15);
+  return {
+    name,
+    vars: {
+      // ANSI palette
+      black: p(0, "#000000"),
+      red: p(1, "#cc0000"),
+      green: p(2, "#4caf50"),
+      yellow: p(3, "#cdcd00"),
+      blue: p(4, "#0000cd"),
+      magenta: p(5, "#cd00cd"),
+      cyan: p(6, "#00cdcd"),
+      white: p(7, "#e5e5e5"),
+      brightBlack: p(8, "#666666"),
+      brightRed: p(9, "#ff0000"),
+      brightGreen: p(10, "#00ff00"),
+      brightYellow: p(11, "#ffff00"),
+      brightBlue: p(12, "#0000ff"),
+      brightMagenta: p(13, "#ff00ff"),
+      brightCyan: p(14, "#00ffff"),
+      brightWhite: p(15, "#ffffff"),
+      // Derived
+      bg,
+      fg,
+      bgSurface,
+      bgOverlay,
+      borderColor,
+      borderMuted,
+      toolSuccessBg,
+      toolErrorBg
+    },
+    colors: {
+      // Core UI
+      accent: "blue",
+      border: "borderColor",
+      borderAccent: "blue",
+      borderMuted: "borderMuted",
+      success: "green",
+      error: "red",
+      warning: "yellow",
+      muted: "brightBlack",
+      dim: "fg",
+      text: "fg",
+      // Backgrounds & Content
+      userMessageBg: "bgSurface",
+      userMessageText: "fg",
+      toolPendingBg: "bgOverlay",
+      toolSuccessBg: "toolSuccessBg",
+      toolErrorBg: "toolErrorBg",
+      toolTitle: "blue",
+      toolOutput: "white",
+      // Diff Colors
+      diffAdded: "green",
+      diffRemoved: "red",
+      diffContext: "brightBlack",
+      // Syntax Highlighting
+      syntaxComment: "brightBlack",
+      syntaxKeyword: "magenta",
+      syntaxFunction: "blue",
+      syntaxVariable: "cyan",
+      syntaxString: "green",
+      syntaxNumber: "yellow",
+      syntaxType: "brightCyan",
+      syntaxOperator: "red",
+      syntaxPunctuation: "white",
+      // Markdown
+      mdHeading: "blue",
+      mdLink: "cyan",
+      mdLinkUrl: "brightBlack",
+      mdCode: "yellow",
+      mdCodeBlock: "fg",
+      mdCodeBlockBorder: "borderColor",
+      mdQuote: "white",
+      mdQuoteBorder: "brightBlack",
+      mdHr: "borderColor",
+      mdListBullet: "cyan"
+    }
+  };
+}
+function loadGhosttyTheme(themeName) {
+  const dir = findGhosttyThemesDir();
+  if (!dir) return null;
+  const filePath = join(dir, themeName);
+  if (!existsSync(filePath)) return null;
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const palette = parseGhosttyTheme(content);
+    return ghosttyPaletteToTheme(themeName, palette);
+  } catch {
+    return null;
+  }
+}
+function isInsideGhostty() {
+  return process.env.TERM_PROGRAM === "ghostty";
+}
+function detectSystemAppearance() {
+  if (platform() === "darwin") {
+    try {
+      const result = execSync("defaults read -g AppleInterfaceStyle 2>/dev/null", {
+        encoding: "utf-8",
+        timeout: 500,
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      return result.trim().toLowerCase() === "dark" ? "dark" : "light";
+    } catch {
+      return "light";
+    }
+  }
+  const gtkTheme = process.env.GTK_THEME ?? "";
+  if (gtkTheme.toLowerCase().includes("dark")) return "dark";
+  return "dark";
+}
+function readGhosttyConfigTheme() {
+  const configDir = process.env.XDG_CONFIG_HOME ? join(process.env.XDG_CONFIG_HOME, "ghostty") : join(homedir(), ".config", "ghostty");
+  const configPath = join(configDir, "config");
+  if (!existsSync(configPath)) return null;
+  try {
+    const content = readFileSync(configPath, "utf-8");
+    let themeLine;
+    for (const line of content.split("\n")) {
+      const trimmed = line.trim();
+      if (trimmed.startsWith("#") || !trimmed.startsWith("theme")) continue;
+      const eq = trimmed.indexOf("=");
+      if (eq === -1) continue;
+      const key = trimmed.slice(0, eq).trim();
+      if (key === "theme") {
+        themeLine = trimmed.slice(eq + 1).trim();
+      }
+    }
+    if (!themeLine) return null;
+    if (themeLine.includes(",") && (themeLine.includes("dark:") || themeLine.includes("light:"))) {
+      const parts = themeLine.split(",").map((p) => p.trim());
+      let dark;
+      let light;
+      for (const part of parts) {
+        if (part.startsWith("dark:")) dark = part.slice("dark:".length).trim();
+        if (part.startsWith("light:")) light = part.slice("light:".length).trim();
+      }
+      return { dark, light };
+    }
+    return { single: themeLine };
+  } catch {
+    return null;
+  }
+}
+function detectGhosttyTheme() {
+  if (!isInsideGhostty()) return null;
+  const config = readGhosttyConfigTheme();
+  if (!config) return null;
+  if (config.single) {
+    return config.single;
+  }
+  const appearance = detectSystemAppearance();
+  if (appearance === "dark" && config.dark) return config.dark;
+  if (appearance === "light" && config.light) return config.light;
+  return config.dark ?? config.light ?? null;
+}
+
+// src/ui/theme/loader.ts
+var CUSTOM_THEMES_DIR = join2(homedir2(), ".autohand", "themes");
 var ThemeLoadError = class extends Error {
   constructor(message, themeName, cause) {
     super(message);
@@ -487,15 +835,19 @@ function getThemeDefinition(themeName) {
   if (themeName in builtInThemes) {
     return builtInThemes[themeName];
   }
-  const customThemePath = join(CUSTOM_THEMES_DIR, `${themeName}.json`);
-  if (existsSync(customThemePath)) {
+  const customThemePath = join2(CUSTOM_THEMES_DIR, `${themeName}.json`);
+  if (existsSync2(customThemePath)) {
     return loadCustomTheme(customThemePath, themeName);
   }
+  const ghosttyTheme = loadGhosttyTheme(themeName);
+  if (ghosttyTheme) {
+    return ghosttyTheme;
+  }
   throw new ThemeLoadError(`Theme "${themeName}" not found`, themeName);
 }
 function loadCustomTheme(filePath, themeName) {
   try {
-    const content = readFileSync(filePath, "utf-8");
+    const content = readFileSync2(filePath, "utf-8");
     const parsed = JSON.parse(content);
     return validateAndMergeTheme(parsed, themeName);
   } catch (error) {
@@ -583,25 +935,59 @@ function resolveColorValue(value, vars, themeName, visited) {
   }
   throw new ThemeLoadError(`Invalid color value: ${value}`, themeName);
 }
+var CURATED_GHOSTTY_THEMES = [
+  "Atom One Dark",
+  "Ayu Mirage",
+  "Catppuccin Frappe",
+  "Catppuccin Latte",
+  "Catppuccin Macchiato",
+  "Catppuccin Mocha",
+  "Everforest Dark Hard",
+  "Gruvbox Dark",
+  "Gruvbox Light",
+  "Kanagawa Wave",
+  "Monokai Pro",
+  "Nord",
+  "One Half Dark",
+  "Rose Pine",
+  "Rose Pine Dawn",
+  "Rose Pine Moon",
+  "Solarized Osaka Night",
+  "TokyoNight",
+  "TokyoNight Storm"
+];
 function listAvailableThemes() {
-  const themes = new Set(Object.keys(builtInThemes));
-  if (existsSync(CUSTOM_THEMES_DIR)) {
+  const builtIn = Object.keys(builtInThemes).sort();
+  const ghostty = [];
+  for (const name of CURATED_GHOSTTY_THEMES) {
+    if (loadGhosttyTheme(name)) {
+      ghostty.push(name);
+    }
+  }
+  ghostty.sort();
+  const custom = [];
+  if (existsSync2(CUSTOM_THEMES_DIR)) {
     try {
-      const files = readdirSync(CUSTOM_THEMES_DIR);
+      const files = readdirSync2(CUSTOM_THEMES_DIR);
       for (const file of files) {
         if (file.endsWith(".json")) {
-          themes.add(file.slice(0, -5));
+          const name = file.slice(0, -5);
+          if (!builtIn.includes(name)) {
+            custom.push(name);
+          }
         }
       }
     } catch {
     }
   }
-  return Array.from(themes).sort();
+  custom.sort();
+  return [...builtIn, ...ghostty, ...custom];
 }
 function themeExists(themeName) {
   if (themeName in builtInThemes) return true;
-  const customPath = join(CUSTOM_THEMES_DIR, `${themeName}.json`);
-  return existsSync(customPath);
+  const customPath = join2(CUSTOM_THEMES_DIR, `${themeName}.json`);
+  if (existsSync2(customPath)) return true;
+  return loadGhosttyTheme(themeName) !== null;
 }
 function detectTerminalBackground() {
   const colorFgBg = process.env.COLORFGBG;
@@ -620,6 +1006,16 @@ function detectTerminalBackground() {
   return "dark";
 }
 function autoInitTheme(themeName) {
+  if (themeName && themeName !== getDefaultThemeName()) {
+    return initTheme(themeName);
+  }
+  const ghosttyThemeName = detectGhosttyTheme();
+  if (ghosttyThemeName) {
+    try {
+      return initTheme(ghosttyThemeName);
+    } catch {
+    }
+  }
   if (themeName) {
     return initTheme(themeName);
   }
@@ -645,255 +1041,42 @@ var defaultContextValue = {
   }
 };
 var ThemeContext = createContext(defaultContextValue);
-
-// src/config.ts
-import fs from "fs-extra";
-import path from "path";
-import YAML from "yaml";
-var DEFAULT_CONFIG_PATH = AUTOHAND_FILES.configJson;
-var YAML_CONFIG_PATH = AUTOHAND_FILES.configYaml;
-var YML_CONFIG_PATH = AUTOHAND_FILES.configYml;
-var DEFAULT_BASE_URL = "https://openrouter.ai/api/v1";
-var DEFAULT_OLLAMA_URL = "http://localhost:11434";
-var DEFAULT_LLAMACPP_URL = "http://localhost:8080";
-var DEFAULT_OPENAI_URL = "https://api.openai.com/v1";
-var DEFAULT_MLX_URL = "http://localhost:8080";
-var DEFAULT_LLMGATEWAY_URL = "https://api.llmgateway.io/v1";
-async function detectConfigPath(customPath) {
-  if (customPath) {
-    return path.resolve(customPath);
-  }
-  const envPath = process.env.AUTOHAND_CONFIG;
-  if (envPath) {
-    return path.resolve(envPath);
-  }
-  if (await fs.pathExists(YAML_CONFIG_PATH)) {
-    return YAML_CONFIG_PATH;
-  }
-  if (await fs.pathExists(YML_CONFIG_PATH)) {
-    return YML_CONFIG_PATH;
-  }
-  return DEFAULT_CONFIG_PATH;
-}
-function isYamlFile(filePath) {
-  const ext = path.extname(filePath).toLowerCase();
-  return ext === ".yaml" || ext === ".yml";
-}
-async function parseConfigFile(configPath) {
-  const content = await fs.readFile(configPath, "utf8");
-  if (isYamlFile(configPath)) {
-    return YAML.parse(content);
-  }
-  return JSON.parse(content);
-}
-async function loadConfig(customPath) {
-  const configPath = await detectConfigPath(customPath);
-  await fs.ensureDir(path.dirname(configPath));
-  let isNewConfig = false;
-  if (!await fs.pathExists(configPath)) {
-    const defaultConfig = {
-      provider: "openrouter",
-      openrouter: {
-        apiKey: "",
-        baseUrl: "https://openrouter.ai/api/v1",
-        model: "anthropic/claude-sonnet-4-20250514"
-      },
-      workspace: {
-        defaultRoot: process.cwd(),
-        allowDangerousOps: false
-      },
-      ui: {
-        theme: "dark",
-        autoConfirm: false
-      },
-      telemetry: {
-        enabled: false
-      }
-    };
-    await fs.writeJson(configPath, defaultConfig, { spaces: 2 });
-    isNewConfig = true;
-  }
-  let parsed;
-  try {
-    parsed = await parseConfigFile(configPath);
-  } catch (error) {
-    throw new Error(`Failed to parse config at ${configPath}: ${error.message}`);
-  }
-  const normalized = normalizeConfig(parsed);
-  const withEnv = mergeEnvVariables(normalized);
-  validateConfig(withEnv, configPath);
-  const themeName = withEnv.ui?.theme || "dark";
-  autoInitTheme(themeName);
-  return { ...withEnv, configPath, isNewConfig };
-}
-function mergeEnvVariables(config) {
-  return {
-    ...config,
-    api: {
-      baseUrl: process.env.AUTOHAND_API_URL || config.api?.baseUrl || "https://api.autohand.ai",
-      companySecret: process.env.AUTOHAND_SECRET || config.api?.companySecret || ""
+var ThemeProvider = ({ theme: providedTheme, themeName, children }) => {
+  const theme = useMemo(() => {
+    if (providedTheme) return providedTheme;
+    if (isThemeInitialized()) {
+      return getTheme();
     }
-  };
-}
-function normalizeConfig(config) {
-  if (isModernConfig(config)) {
-    const provider = config.provider ?? "openrouter";
-    return { provider, ...config };
-  }
-  if (isLegacyConfig(config)) {
-    return {
-      provider: "openrouter",
-      openrouter: {
-        apiKey: config.api_key ?? "replace-me",
-        baseUrl: config.base_url ?? DEFAULT_BASE_URL,
-        model: config.model ?? "anthropic/claude-3.5-sonnet"
-      },
-      workspace: {
-        defaultRoot: process.cwd(),
-        allowDangerousOps: false
-      },
-      ui: {
-        autoConfirm: config.dry_run ?? false,
-        theme: "dark"
-      }
-    };
-  }
-  return config;
-}
-function isModernConfig(config) {
-  return typeof config.openrouter === "object" || typeof config.ollama === "object" || typeof config.llamacpp === "object" || typeof config.openai === "object" || typeof config.mlx === "object";
-}
-function isLegacyConfig(config) {
-  return typeof config.api_key === "string";
-}
-function validateConfig(config, configPath) {
-  if (config.workspace) {
-    if (config.workspace.defaultRoot && typeof config.workspace.defaultRoot !== "string") {
-      throw new Error(`workspace.defaultRoot must be a string in ${configPath}`);
-    }
-    if (config.workspace.allowDangerousOps !== void 0 && typeof config.workspace.allowDangerousOps !== "boolean") {
-      throw new Error(`workspace.allowDangerousOps must be boolean in ${configPath}`);
-    }
-  }
-  if (config.ui) {
-    if (config.ui.theme && typeof config.ui.theme !== "string") {
-      throw new Error(`ui.theme must be a string in ${configPath}`);
+    if (themeName) {
+      return initTheme(themeName);
     }
-    if (config.ui.theme && !themeExists(config.ui.theme)) {
-      throw new Error(`ui.theme '${config.ui.theme}' not found. Use 'dark', 'light', or a custom theme in ~/.autohand/themes/`);
-    }
-    if (config.ui.autoConfirm !== void 0 && typeof config.ui.autoConfirm !== "boolean") {
-      throw new Error(`ui.autoConfirm must be boolean in ${configPath}`);
-    }
-  }
-  if (config.mcp) {
-    if (config.mcp.enabled !== void 0 && typeof config.mcp.enabled !== "boolean") {
-      throw new Error(`mcp.enabled must be boolean in ${configPath}`);
-    }
-    if (config.mcp.servers !== void 0) {
-      if (!Array.isArray(config.mcp.servers)) {
-        throw new Error(`mcp.servers must be an array in ${configPath}`);
-      }
-      for (const server of config.mcp.servers) {
-        if (!server.name || typeof server.name !== "string") {
-          throw new Error(`mcp.servers[].name must be a non-empty string in ${configPath}`);
-        }
-        if (!["stdio", "sse", "http"].includes(server.transport)) {
-          throw new Error(`mcp.servers[].transport must be 'stdio', 'sse', or 'http' in ${configPath}`);
-        }
-        if (server.transport === "stdio" && (!server.command || typeof server.command !== "string")) {
-          throw new Error(`mcp.servers[].command is required for stdio transport in ${configPath}`);
-        }
-        if ((server.transport === "sse" || server.transport === "http") && (!server.url || typeof server.url !== "string")) {
-          throw new Error(`mcp.servers[].url is required for ${server.transport} transport in ${configPath}`);
-        }
-      }
-    }
-  }
-  if (config.externalAgents) {
-    if (config.externalAgents.enabled !== void 0 && typeof config.externalAgents.enabled !== "boolean") {
-      throw new Error(`externalAgents.enabled must be boolean in ${configPath}`);
-    }
-    if (config.externalAgents.paths !== void 0) {
-      if (!Array.isArray(config.externalAgents.paths)) {
-        throw new Error(`externalAgents.paths must be an array in ${configPath}`);
-      }
-      for (const p of config.externalAgents.paths) {
-        if (typeof p !== "string") {
-          throw new Error(`externalAgents.paths must contain only strings in ${configPath}`);
-        }
-      }
-    }
-  }
-}
-function resolveWorkspaceRoot(config, requestedPath) {
-  const candidate = requestedPath ?? process.cwd() ?? config.workspace?.defaultRoot;
-  return path.resolve(candidate);
-}
-function getProviderConfig(config, provider) {
-  const chosen = provider ?? config.provider ?? "openrouter";
-  const configByProvider = {
-    openrouter: config.openrouter,
-    ollama: config.ollama,
-    llamacpp: config.llamacpp,
-    openai: config.openai,
-    mlx: config.mlx,
-    llmgateway: config.llmgateway
-  };
-  const entry = configByProvider[chosen];
-  if (!entry) {
-    return null;
-  }
-  if (chosen === "openrouter" || chosen === "llmgateway") {
-    const { apiKey, model } = entry;
-    if (!apiKey || apiKey === "replace-me" || !model) {
-      return null;
-    }
-  } else {
-    if (!entry.model) {
-      return null;
-    }
-  }
-  return {
-    ...entry,
-    baseUrl: entry.baseUrl ?? defaultBaseUrlFor(chosen, entry.port)
-  };
-}
-function defaultBaseUrlFor(provider, port) {
-  if (provider === "openrouter") return DEFAULT_BASE_URL;
-  if (provider === "llmgateway") return DEFAULT_LLMGATEWAY_URL;
-  const p = port ? port.toString() : void 0;
-  switch (provider) {
-    case "ollama":
-      return p ? `http://localhost:${p}` : DEFAULT_OLLAMA_URL;
-    case "llamacpp":
-      return p ? `http://localhost:${p}` : DEFAULT_LLAMACPP_URL;
-    case "openai":
-      return DEFAULT_OPENAI_URL;
-    case "mlx":
-      return p ? `http://localhost:${p}` : DEFAULT_MLX_URL;
-    default:
-      return void 0;
-  }
-}
-async function saveConfig(config) {
-  const { configPath, ...data } = config;
-  if (isYamlFile(configPath)) {
-    const yamlContent = YAML.stringify(data, { indent: 2 });
-    await fs.writeFile(configPath, yamlContent, "utf8");
-  } else {
-    await fs.writeJson(configPath, data, { spaces: 2 });
-  }
+    return initTheme();
+  }, [providedTheme, themeName]);
+  const value = useMemo(
+    () => ({
+      theme,
+      colors: theme.colors,
+      name: theme.name,
+      getColor: (token) => theme.getColor(token)
+    }),
+    [theme]
+  );
+  return /* @__PURE__ */ jsx(ThemeContext.Provider, { value, children });
+};
+function useTheme() {
+  const context = useContext(ThemeContext);
+  return context;
 }
 
 export {
+  builtInThemes,
   CUSTOM_THEMES_DIR,
   initTheme,
   listAvailableThemes,
-  loadConfig,
-  resolveWorkspaceRoot,
-  getProviderConfig,
-  saveConfig
+  themeExists,
+  autoInitTheme,
+  ThemeProvider,
+  useTheme
 };
 /**
  * @license