autohand-cli 0.6.1 → 0.6.3

package/dist/chunk-UBGEAEKS.js

@@ -0,0 +1,1135 @@
+import {
+  AUTOHAND_FILES
+} from "./chunk-737A24RB.js";
+
+// src/ui/theme/Theme.ts
+var Theme = class {
+  constructor(name, colors, colorMode) {
+    this.ansiCache = /* @__PURE__ */ new Map();
+    this.name = name;
+    this.colors = colors;
+    this.colorMode = colorMode ?? detectColorMode();
+  }
+  /**
+   * Apply foreground color to text.
+   */
+  fg(token, text) {
+    if (this.colorMode === "none") return text;
+    const color = this.colors[token];
+    if (!color) return text;
+    const ansi = this.getAnsiCode(color, "fg");
+    return `${ansi}${text}\x1B[39m`;
+  }
+  /**
+   * Apply background color to text.
+   */
+  bg(token, text) {
+    if (this.colorMode === "none") return text;
+    const color = this.colors[token];
+    if (!color) return text;
+    const ansi = this.getAnsiCode(color, "bg");
+    return `${ansi}${text}\x1B[49m`;
+  }
+  /**
+   * Apply both foreground and background colors.
+   */
+  fgBg(fgToken, bgToken, text) {
+    if (this.colorMode === "none") return text;
+    const fgColor = this.colors[fgToken];
+    const bgColor = this.colors[bgToken];
+    const fgAnsi = fgColor ? this.getAnsiCode(fgColor, "fg") : "";
+    const bgAnsi = bgColor ? this.getAnsiCode(bgColor, "bg") : "";
+    return `${fgAnsi}${bgAnsi}${text}\x1B[0m`;
+  }
+  /**
+   * Apply bold style.
+   */
+  bold(text) {
+    return `\x1B[1m${text}\x1B[22m`;
+  }
+  /**
+   * Apply italic style.
+   */
+  italic(text) {
+    return `\x1B[3m${text}\x1B[23m`;
+  }
+  /**
+   * Apply underline style.
+   */
+  underline(text) {
+    return `\x1B[4m${text}\x1B[24m`;
+  }
+  /**
+   * Apply dim style.
+   */
+  dimStyle(text) {
+    return `\x1B[2m${text}\x1B[22m`;
+  }
+  /**
+   * Apply strikethrough style.
+   */
+  strikethrough(text) {
+    return `\x1B[9m${text}\x1B[29m`;
+  }
+  /**
+   * Reset all styles.
+   */
+  reset(text) {
+    return `\x1B[0m${text}\x1B[0m`;
+  }
+  /**
+   * Get raw color value for a token.
+   */
+  getColor(token) {
+    return this.colors[token] || "";
+  }
+  /**
+   * Get current color mode.
+   */
+  getColorMode() {
+    return this.colorMode;
+  }
+  /**
+   * Convert color value to ANSI escape code.
+   */
+  getAnsiCode(color, type) {
+    const cacheKey = `${color}:${type}`;
+    const cached = this.ansiCache.get(cacheKey);
+    if (cached) return cached;
+    const code = this.colorToAnsi(color, type);
+    this.ansiCache.set(cacheKey, code);
+    return code;
+  }
+  /**
+   * Convert a color value to ANSI code based on color mode.
+   */
+  colorToAnsi(color, type) {
+    if (!color) return "";
+    if (color.startsWith("#")) {
+      return this.hexToAnsi(color, type);
+    }
+    const numValue = parseInt(color, 10);
+    if (!isNaN(numValue) && numValue >= 0 && numValue <= 255) {
+      return this.index256ToAnsi(numValue, type);
+    }
+    return "";
+  }
+  /**
+   * Convert hex color to ANSI code.
+   */
+  hexToAnsi(hex, type) {
+    const rgb = hexToRgb(hex);
+    if (!rgb) return "";
+    const base = type === "fg" ? 38 : 48;
+    if (this.colorMode === "truecolor") {
+      return `\x1B[${base};2;${rgb.r};${rgb.g};${rgb.b}m`;
+    } else if (this.colorMode === "256") {
+      const index = rgbTo256(rgb.r, rgb.g, rgb.b);
+      return `\x1B[${base};5;${index}m`;
+    } else if (this.colorMode === "16") {
+      const index = rgbTo16(rgb.r, rgb.g, rgb.b);
+      const code = type === "fg" ? index < 8 ? 30 + index : 90 + index - 8 : index < 8 ? 40 + index : 100 + index - 8;
+      return `\x1B[${code}m`;
+    }
+    return "";
+  }
+  /**
+   * Convert 256-color index to ANSI code.
+   */
+  index256ToAnsi(index, type) {
+    const base = type === "fg" ? 38 : 48;
+    if (this.colorMode === "truecolor" || this.colorMode === "256") {
+      return `\x1B[${base};5;${index}m`;
+    } else if (this.colorMode === "16") {
+      const basicIndex = index < 16 ? index : index256To16(index);
+      const code = type === "fg" ? basicIndex < 8 ? 30 + basicIndex : 90 + basicIndex - 8 : basicIndex < 8 ? 40 + basicIndex : 100 + basicIndex - 8;
+      return `\x1B[${code}m`;
+    }
+    return "";
+  }
+};
+function detectColorMode() {
+  if (process.env.NO_COLOR !== void 0) {
+    return "none";
+  }
+  if (process.env.FORCE_COLOR !== void 0) {
+    const level = parseInt(process.env.FORCE_COLOR, 10);
+    if (level === 0) return "none";
+    if (level === 1) return "16";
+    if (level === 2) return "256";
+    if (level >= 3) return "truecolor";
+  }
+  const colorterm = process.env.COLORTERM;
+  if (colorterm === "truecolor" || colorterm === "24bit") {
+    return "truecolor";
+  }
+  const term = process.env.TERM || "";
+  if (term.includes("256color") || term.includes("256-color")) {
+    return "256";
+  }
+  if (term.includes("color") || term.includes("ansi") || term === "xterm") {
+    return "16";
+  }
+  if (process.stdout.isTTY) {
+    return "256";
+  }
+  return "none";
+}
+function hexToRgb(hex) {
+  const match = hex.match(/^#?([a-fA-F0-9]{2})([a-fA-F0-9]{2})([a-fA-F0-9]{2})$/);
+  if (match) {
+    return {
+      r: parseInt(match[1], 16),
+      g: parseInt(match[2], 16),
+      b: parseInt(match[3], 16)
+    };
+  }
+  const shortMatch = hex.match(/^#?([a-fA-F0-9])([a-fA-F0-9])([a-fA-F0-9])$/);
+  if (shortMatch) {
+    return {
+      r: parseInt(shortMatch[1] + shortMatch[1], 16),
+      g: parseInt(shortMatch[2] + shortMatch[2], 16),
+      b: parseInt(shortMatch[3] + shortMatch[3], 16)
+    };
+  }
+  return null;
+}
+function rgbTo256(r, g, b) {
+  if (r === g && g === b) {
+    if (r < 8) return 16;
+    if (r > 248) return 231;
+    return Math.round((r - 8) / 10) + 232;
+  }
+  const ri = Math.round(r / 51);
+  const gi = Math.round(g / 51);
+  const bi = Math.round(b / 51);
+  return 16 + 36 * ri + 6 * gi + bi;
+}
+function rgbTo16(r, g, b) {
+  const bright = (r + g + b) / 3 > 128 ? 8 : 0;
+  const ri = r > 128 ? 1 : 0;
+  const gi = g > 128 ? 2 : 0;
+  const bi = b > 128 ? 4 : 0;
+  return bright + ri + gi + bi;
+}
+function index256To16(index) {
+  if (index < 16) return index;
+  if (index >= 232) {
+    const gray = (index - 232) * 10 + 8;
+    return gray > 128 ? 15 : 0;
+  }
+  const adjusted = index - 16;
+  const r = Math.floor(adjusted / 36) * 51;
+  const g = Math.floor(adjusted % 36 / 6) * 51;
+  const b = adjusted % 6 * 51;
+  return rgbTo16(r, g, b);
+}
+var globalTheme = null;
+function getTheme() {
+  if (!globalTheme) {
+    throw new Error("Theme not initialized. Call initTheme() first.");
+  }
+  return globalTheme;
+}
+function setTheme(theme) {
+  globalTheme = theme;
+}
+function isThemeInitialized() {
+  return globalTheme !== null;
+}
+
+// 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 = {
+  name: "dark",
+  vars: {
+    // Base colors
+    cyan: "#00bcd4",
+    green: "#4caf50",
+    red: "#f44336",
+    yellow: "#ffeb3b",
+    blue: "#2196f3",
+    magenta: "#e91e63",
+    orange: "#ff9800",
+    // Grays
+    gray100: "#f5f5f5",
+    gray200: "#eeeeee",
+    gray300: "#e0e0e0",
+    gray400: "#bdbdbd",
+    gray500: "#9e9e9e",
+    gray600: "#757575",
+    gray700: "#616161",
+    gray800: "#424242",
+    gray900: "#212121",
+    // Backgrounds
+    bgDark: "#1a1a1a",
+    bgMedium: "#2b2b2b",
+    bgLight: "#3a3a3a"
+  },
+  colors: {
+    // Core UI
+    accent: "cyan",
+    border: "gray700",
+    borderAccent: "cyan",
+    borderMuted: "gray800",
+    success: "green",
+    error: "red",
+    warning: "yellow",
+    muted: "gray500",
+    dim: "gray700",
+    text: "gray200",
+    // Backgrounds & Content
+    userMessageBg: "bgMedium",
+    userMessageText: "gray200",
+    toolPendingBg: "bgLight",
+    toolSuccessBg: "#1b3d1b",
+    toolErrorBg: "#3d1b1b",
+    toolTitle: "cyan",
+    toolOutput: "gray400",
+    // Diff Colors
+    diffAdded: "#4caf50",
+    diffRemoved: "#f44336",
+    diffContext: "gray500",
+    // Syntax Highlighting
+    syntaxComment: "gray600",
+    syntaxKeyword: "magenta",
+    syntaxFunction: "blue",
+    syntaxVariable: "cyan",
+    syntaxString: "green",
+    syntaxNumber: "yellow",
+    syntaxType: "cyan",
+    syntaxOperator: "gray300",
+    syntaxPunctuation: "gray400",
+    // Markdown
+    mdHeading: "cyan",
+    mdLink: "blue",
+    mdLinkUrl: "gray500",
+    mdCode: "orange",
+    mdCodeBlock: "gray300",
+    mdCodeBlockBorder: "gray700",
+    mdQuote: "gray400",
+    mdQuoteBorder: "gray600",
+    mdHr: "gray700",
+    mdListBullet: "cyan"
+  }
+};
+var draculaTheme = {
+  name: "dracula",
+  vars: {
+    // Dracula palette
+    background: "#282a36",
+    currentLine: "#44475a",
+    foreground: "#f8f8f2",
+    comment: "#6272a4",
+    cyan: "#8be9fd",
+    green: "#50fa7b",
+    orange: "#ffb86c",
+    pink: "#ff79c6",
+    purple: "#bd93f9",
+    red: "#ff5555",
+    yellow: "#f1fa8c",
+    // Additional grays
+    gray100: "#f8f8f2",
+    gray200: "#e6e6e6",
+    gray300: "#bfbfbf",
+    gray400: "#6272a4",
+    gray500: "#44475a",
+    gray600: "#383a46",
+    gray700: "#282a36",
+    gray800: "#21222c",
+    gray900: "#191a21"
+  },
+  colors: {
+    // Core UI
+    accent: "purple",
+    border: "comment",
+    borderAccent: "purple",
+    borderMuted: "currentLine",
+    success: "green",
+    error: "red",
+    warning: "orange",
+    muted: "comment",
+    dim: "currentLine",
+    text: "foreground",
+    // Backgrounds & Content
+    userMessageBg: "currentLine",
+    userMessageText: "foreground",
+    toolPendingBg: "gray800",
+    toolSuccessBg: "#1e3a1e",
+    toolErrorBg: "#3a1e1e",
+    toolTitle: "purple",
+    toolOutput: "foreground",
+    // Diff Colors
+    diffAdded: "green",
+    diffRemoved: "red",
+    diffContext: "comment",
+    // Syntax Highlighting
+    syntaxComment: "comment",
+    syntaxKeyword: "pink",
+    syntaxFunction: "green",
+    syntaxVariable: "foreground",
+    syntaxString: "yellow",
+    syntaxNumber: "purple",
+    syntaxType: "cyan",
+    syntaxOperator: "pink",
+    syntaxPunctuation: "foreground",
+    // Markdown
+    mdHeading: "purple",
+    mdLink: "cyan",
+    mdLinkUrl: "comment",
+    mdCode: "green",
+    mdCodeBlock: "foreground",
+    mdCodeBlockBorder: "comment",
+    mdQuote: "yellow",
+    mdQuoteBorder: "comment",
+    mdHr: "comment",
+    mdListBullet: "cyan"
+  }
+};
+var sandyTheme = {
+  name: "sandy",
+  vars: {
+    // Sandy/desert palette
+    sand: "#e8d5b7",
+    sandDark: "#d4c4a8",
+    sandLight: "#f5ece0",
+    terracotta: "#c45c3e",
+    rust: "#a04030",
+    cactus: "#6b8e23",
+    sage: "#8fbc8f",
+    clay: "#8b6914",
+    dune: "#c4a35a",
+    stone: "#7a6a5a",
+    adobe: "#bc8f8f",
+    // Grays (warm-tinted)
+    gray100: "#f5f0e8",
+    gray200: "#e8e0d5",
+    gray300: "#d5c8b8",
+    gray400: "#a89888",
+    gray500: "#8a7a6a",
+    gray600: "#6a5a4a",
+    gray700: "#4a3a2a",
+    gray800: "#3a2a1a",
+    gray900: "#2a1a0a"
+  },
+  colors: {
+    // Core UI
+    accent: "terracotta",
+    border: "stone",
+    borderAccent: "terracotta",
+    borderMuted: "gray600",
+    success: "cactus",
+    error: "rust",
+    warning: "dune",
+    muted: "stone",
+    dim: "gray600",
+    text: "gray100",
+    // Backgrounds & Content
+    userMessageBg: "gray700",
+    userMessageText: "gray100",
+    toolPendingBg: "gray800",
+    toolSuccessBg: "#2a3a2a",
+    toolErrorBg: "#3a2a2a",
+    toolTitle: "terracotta",
+    toolOutput: "gray300",
+    // Diff Colors
+    diffAdded: "cactus",
+    diffRemoved: "rust",
+    diffContext: "stone",
+    // Syntax Highlighting
+    syntaxComment: "stone",
+    syntaxKeyword: "terracotta",
+    syntaxFunction: "cactus",
+    syntaxVariable: "dune",
+    syntaxString: "sage",
+    syntaxNumber: "clay",
+    syntaxType: "adobe",
+    syntaxOperator: "gray300",
+    syntaxPunctuation: "gray400",
+    // Markdown
+    mdHeading: "terracotta",
+    mdLink: "cactus",
+    mdLinkUrl: "stone",
+    mdCode: "dune",
+    mdCodeBlock: "gray200",
+    mdCodeBlockBorder: "stone",
+    mdQuote: "sage",
+    mdQuoteBorder: "stone",
+    mdHr: "gray600",
+    mdListBullet: "terracotta"
+  }
+};
+var tuiTheme = {
+  name: "tui",
+  vars: {
+    // New Zealand palette
+    silverFern: "#7fb069",
+    // Silver fern green
+    fernDark: "#4a7c3f",
+    // Dark fern
+    paua: "#4b0082",
+    // Paua shell purple
+    pauaBlue: "#1e90ff",
+    // Paua shell blue
+    pauaTeal: "#20b2aa",
+    // Paua teal highlights
+    kowhai: "#ffd700",
+    // Kowhai yellow
+    pohutukawa: "#dc143c",
+    // Pohutukawa red
+    kiwi: "#8b4513",
+    // Kiwi brown
+    sky: "#87ceeb",
+    // NZ sky blue
+    snow: "#f0f8ff",
+    // Southern Alps snow
+    obsidian: "#1a1a2e",
+    // Maori obsidian
+    // Grays (cool-tinted)
+    gray100: "#e8f0f0",
+    gray200: "#c0d0d8",
+    gray300: "#90a8b0",
+    gray400: "#607880",
+    gray500: "#405058",
+    gray600: "#303840",
+    gray700: "#202830",
+    gray800: "#151c22",
+    gray900: "#0a1015"
+  },
+  colors: {
+    // Core UI
+    accent: "pauaBlue",
+    border: "gray500",
+    borderAccent: "pauaTeal",
+    borderMuted: "gray600",
+    success: "silverFern",
+    error: "pohutukawa",
+    warning: "kowhai",
+    muted: "gray400",
+    dim: "gray600",
+    text: "snow",
+    // Backgrounds & Content
+    userMessageBg: "gray700",
+    userMessageText: "snow",
+    toolPendingBg: "gray800",
+    toolSuccessBg: "#1a2a1a",
+    toolErrorBg: "#2a1a1a",
+    toolTitle: "pauaTeal",
+    toolOutput: "gray200",
+    // Diff Colors
+    diffAdded: "silverFern",
+    diffRemoved: "pohutukawa",
+    diffContext: "gray400",
+    // Syntax Highlighting
+    syntaxComment: "gray400",
+    syntaxKeyword: "paua",
+    syntaxFunction: "pauaBlue",
+    syntaxVariable: "pauaTeal",
+    syntaxString: "silverFern",
+    syntaxNumber: "kowhai",
+    syntaxType: "sky",
+    syntaxOperator: "gray200",
+    syntaxPunctuation: "gray300",
+    // Markdown
+    mdHeading: "pauaBlue",
+    mdLink: "pauaTeal",
+    mdLinkUrl: "gray400",
+    mdCode: "silverFern",
+    mdCodeBlock: "gray200",
+    mdCodeBlockBorder: "gray500",
+    mdQuote: "kowhai",
+    mdQuoteBorder: "gray500",
+    mdHr: "gray600",
+    mdListBullet: "pauaTeal"
+  }
+};
+var lightTheme = {
+  name: "light",
+  vars: {
+    // Base colors (darker for light bg)
+    cyan: "#0097a7",
+    green: "#388e3c",
+    red: "#d32f2f",
+    yellow: "#f9a825",
+    blue: "#1976d2",
+    magenta: "#c2185b",
+    orange: "#ef6c00",
+    // Grays (inverted)
+    gray100: "#212121",
+    gray200: "#424242",
+    gray300: "#616161",
+    gray400: "#757575",
+    gray500: "#9e9e9e",
+    gray600: "#bdbdbd",
+    gray700: "#e0e0e0",
+    gray800: "#eeeeee",
+    gray900: "#f5f5f5",
+    // Backgrounds
+    bgLight: "#ffffff",
+    bgMedium: "#f5f5f5",
+    bgDark: "#eeeeee"
+  },
+  colors: {
+    // Core UI
+    accent: "cyan",
+    border: "gray600",
+    borderAccent: "cyan",
+    borderMuted: "gray700",
+    success: "green",
+    error: "red",
+    warning: "yellow",
+    muted: "gray400",
+    dim: "gray500",
+    text: "gray100",
+    // Backgrounds & Content
+    userMessageBg: "bgMedium",
+    userMessageText: "gray100",
+    toolPendingBg: "bgDark",
+    toolSuccessBg: "#e8f5e9",
+    toolErrorBg: "#ffebee",
+    toolTitle: "cyan",
+    toolOutput: "gray300",
+    // Diff Colors
+    diffAdded: "#2e7d32",
+    diffRemoved: "#c62828",
+    diffContext: "gray400",
+    // Syntax Highlighting
+    syntaxComment: "gray500",
+    syntaxKeyword: "magenta",
+    syntaxFunction: "blue",
+    syntaxVariable: "cyan",
+    syntaxString: "green",
+    syntaxNumber: "orange",
+    syntaxType: "cyan",
+    syntaxOperator: "gray300",
+    syntaxPunctuation: "gray400",
+    // Markdown
+    mdHeading: "cyan",
+    mdLink: "blue",
+    mdLinkUrl: "gray400",
+    mdCode: "orange",
+    mdCodeBlock: "gray200",
+    mdCodeBlockBorder: "gray600",
+    mdQuote: "gray300",
+    mdQuoteBorder: "gray500",
+    mdHr: "gray600",
+    mdListBullet: "cyan"
+  }
+};
+var builtInThemes = {
+  dark: darkTheme,
+  light: lightTheme,
+  dracula: draculaTheme,
+  sandy: sandyTheme,
+  tui: tuiTheme
+};
+function getDefaultThemeName() {
+  return "dark";
+}
+
+// src/ui/theme/loader.ts
+var CUSTOM_THEMES_DIR = join(homedir(), ".autohand", "themes");
+var ThemeLoadError = class extends Error {
+  constructor(message, themeName, cause) {
+    super(message);
+    this.themeName = themeName;
+    this.cause = cause;
+    this.name = "ThemeLoadError";
+  }
+};
+function loadTheme(themeName) {
+  const definition = getThemeDefinition(themeName);
+  const resolvedColors = resolveThemeColors(definition);
+  return new Theme(definition.name, resolvedColors, detectColorMode());
+}
+function initTheme(themeName) {
+  const name = themeName || getDefaultThemeName();
+  try {
+    const theme = loadTheme(name);
+    setTheme(theme);
+    return theme;
+  } catch (error) {
+    console.warn(`Failed to load theme "${name}", falling back to dark theme:`, error instanceof Error ? error.message : error);
+    const theme = loadTheme("dark");
+    setTheme(theme);
+    return theme;
+  }
+}
+function getThemeDefinition(themeName) {
+  if (themeName in builtInThemes) {
+    return builtInThemes[themeName];
+  }
+  const customThemePath = join(CUSTOM_THEMES_DIR, `${themeName}.json`);
+  if (existsSync(customThemePath)) {
+    return loadCustomTheme(customThemePath, themeName);
+  }
+  throw new ThemeLoadError(`Theme "${themeName}" not found`, themeName);
+}
+function loadCustomTheme(filePath, themeName) {
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    return validateAndMergeTheme(parsed, themeName);
+  } catch (error) {
+    if (error instanceof SyntaxError) {
+      throw new ThemeLoadError(`Invalid JSON in theme file: ${filePath}`, themeName, error);
+    }
+    if (error instanceof ThemeLoadError) {
+      throw error;
+    }
+    throw new ThemeLoadError(
+      `Failed to load theme file: ${filePath}`,
+      themeName,
+      error instanceof Error ? error : new Error(String(error))
+    );
+  }
+}
+function validateAndMergeTheme(partial, themeName) {
+  const name = partial.name || themeName;
+  if (partial.vars) {
+    for (const [key, value] of Object.entries(partial.vars)) {
+      if (!isValidColorValue(value)) {
+        throw new ThemeLoadError(`Invalid color value for variable "${key}": ${value}`, name);
+      }
+    }
+  }
+  if (partial.colors) {
+    for (const [key, value] of Object.entries(partial.colors)) {
+      if (!COLOR_TOKENS.includes(key)) {
+        continue;
+      }
+      if (!isValidColorValue(value)) {
+        throw new ThemeLoadError(`Invalid color value for token "${key}": ${value}`, name);
+      }
+    }
+  }
+  return {
+    name,
+    vars: { ...darkTheme.vars, ...partial.vars },
+    colors: { ...darkTheme.colors, ...partial.colors }
+  };
+}
+function isValidColorValue(value) {
+  if (value === "") return true;
+  if (typeof value === "string") {
+    if (isHexColor(value)) return true;
+    if (value.length > 0) return true;
+  }
+  if (is256ColorIndex(value)) return true;
+  return false;
+}
+function resolveThemeColors(definition) {
+  const vars = definition.vars || {};
+  const colors = definition.colors;
+  const resolved = {};
+  for (const token of COLOR_TOKENS) {
+    const value = colors[token];
+    if (value === void 0) {
+      throw new ThemeLoadError(`Missing required color token: ${token}`, definition.name);
+    }
+    resolved[token] = resolveColorValue(value, vars, definition.name, /* @__PURE__ */ new Set());
+  }
+  return resolved;
+}
+function resolveColorValue(value, vars, themeName, visited) {
+  if (value === "") return "";
+  if (typeof value === "number") {
+    if (!is256ColorIndex(value)) {
+      throw new ThemeLoadError(`Invalid 256-color index: ${value}`, themeName);
+    }
+    return String(value);
+  }
+  if (isHexColor(value)) {
+    return value;
+  }
+  if (typeof value === "string") {
+    if (visited.has(value)) {
+      throw new ThemeLoadError(`Circular variable reference detected: ${value}`, themeName);
+    }
+    const varValue = vars[value];
+    if (varValue === void 0) {
+      throw new ThemeLoadError(`Unknown variable reference: ${value}`, themeName);
+    }
+    visited.add(value);
+    return resolveColorValue(varValue, vars, themeName, visited);
+  }
+  throw new ThemeLoadError(`Invalid color value: ${value}`, themeName);
+}
+function listAvailableThemes() {
+  const themes = new Set(Object.keys(builtInThemes));
+  if (existsSync(CUSTOM_THEMES_DIR)) {
+    try {
+      const files = readdirSync(CUSTOM_THEMES_DIR);
+      for (const file of files) {
+        if (file.endsWith(".json")) {
+          themes.add(file.slice(0, -5));
+        }
+      }
+    } catch {
+    }
+  }
+  return Array.from(themes).sort();
+}
+function themeExists(themeName) {
+  if (themeName in builtInThemes) return true;
+  const customPath = join(CUSTOM_THEMES_DIR, `${themeName}.json`);
+  return existsSync(customPath);
+}
+function detectTerminalBackground() {
+  const colorFgBg = process.env.COLORFGBG;
+  if (colorFgBg) {
+    const parts = colorFgBg.split(";");
+    if (parts.length >= 2) {
+      const bg = parseInt(parts[parts.length - 1], 10);
+      if (bg === 7 || bg === 15 || bg > 8) {
+        return "light";
+      }
+    }
+  }
+  if (process.env.TERMINAL_EMULATOR?.includes("JetBrains")) {
+    return "light";
+  }
+  return "dark";
+}
+function autoInitTheme(themeName) {
+  if (themeName) {
+    return initTheme(themeName);
+  }
+  const background = detectTerminalBackground();
+  return initTheme(background);
+}
+
+// src/ui/theme/ThemeContext.tsx
+import { createContext, useContext, useMemo } from "react";
+import { jsx } from "react/jsx-runtime";
+var defaultContextValue = {
+  get theme() {
+    throw new Error("ThemeContext not initialized. Wrap your app with ThemeProvider.");
+  },
+  get colors() {
+    throw new Error("ThemeContext not initialized. Wrap your app with ThemeProvider.");
+  },
+  get name() {
+    throw new Error("ThemeContext not initialized. Wrap your app with ThemeProvider.");
+  },
+  getColor: () => {
+    throw new Error("ThemeContext not initialized. Wrap your app with ThemeProvider.");
+  }
+};
+var ThemeContext = createContext(defaultContextValue);
+var ThemeProvider = ({ theme: providedTheme, themeName, children }) => {
+  const theme = useMemo(() => {
+    if (providedTheme) return providedTheme;
+    if (isThemeInitialized()) {
+      return getTheme();
+    }
+    if (themeName) {
+      return initTheme(themeName);
+    }
+    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;
+}
+
+// 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";
+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: true
+      }
+    };
+    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 || ""
+    }
+  };
+}
+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";
+}
+function isLegacyConfig(config) {
+  return typeof config.api_key === "string";
+}
+function validateConfig(config, configPath) {
+  const provider = config.provider ?? "openrouter";
+  const providerConfig = getProviderConfig(config, provider);
+  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 (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.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
+  };
+  const entry = configByProvider[chosen];
+  if (!entry) {
+    return null;
+  }
+  if (chosen === "openrouter") {
+    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;
+  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;
+    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 });
+  }
+}
+
+export {
+  hexToRgb,
+  getTheme,
+  isThemeInitialized,
+  CUSTOM_THEMES_DIR,
+  initTheme,
+  listAvailableThemes,
+  ThemeProvider,
+  useTheme,
+  loadConfig,
+  resolveWorkspaceRoot,
+  getProviderConfig,
+  saveConfig
+};
+/**
+ * @license
+ * Copyright 2025 Autohand AI LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */