@ashx-j/lunr-dev 0.2.13-dev.8.1 → 0.2.19-dev.10.1

package/dist/node-runtime/chunk-MX3GJNXJ.js

@@ -0,0 +1,986 @@
+import { createRequire as __lunrRequire } from "node:module"; const require = __lunrRequire(import.meta.url);
+import {
+  getCustomThemesDir,
+  getThemesDir
+} from "./chunk-PCIGF2XK.js";
+
+// packages/coding-agent/dist/modes/interactive/theme/theme.js
+import * as fs from "node:fs";
+import { createRequire as createRequire2 } from "node:module";
+import * as path from "node:path";
+import { getCapabilities } from "@ashx-j/lunr-tui";
+import chalk from "chalk";
+
+// packages/coding-agent/dist/utils/fs-watch.js
+import { watch } from "node:fs";
+var FS_WATCH_RETRY_DELAY_MS = 5e3;
+function closeWatcher(watcher) {
+  if (watcher)
+    try {
+      watcher.close();
+    } catch {
+    }
+}
+function watchWithErrorHandler(path2, listener, onError) {
+  try {
+    let watcher = watch(path2, listener);
+    return watcher.on("error", onError), watcher;
+  } catch {
+    return onError(), null;
+  }
+}
+
+// packages/coding-agent/dist/utils/syntax-highlight.js
+import { createRequire } from "node:module";
+
+// packages/coding-agent/dist/utils/html.js
+function decodeCodePoint(codePoint) {
+  if (!(!Number.isInteger(codePoint) || codePoint < 0 || codePoint > 1114111))
+    return String.fromCodePoint(codePoint);
+}
+function decodeHtmlEntity(entity) {
+  switch (entity) {
+    case "amp":
+      return "&";
+    case "lt":
+      return "<";
+    case "gt":
+      return ">";
+    case "quot":
+      return '"';
+    case "apos":
+      return "'";
+  }
+  if (entity.startsWith("#x") || entity.startsWith("#X"))
+    return decodeCodePoint(Number.parseInt(entity.slice(2), 16));
+  if (entity.startsWith("#"))
+    return decodeCodePoint(Number.parseInt(entity.slice(1), 10));
+}
+function decodeHtmlEntityAt(html, index) {
+  let semicolonIndex = html.indexOf(";", index + 1);
+  if (semicolonIndex === -1 || semicolonIndex - index > 16)
+    return;
+  let entity = html.slice(index + 1, semicolonIndex), decoded = decodeHtmlEntity(entity);
+  if (decoded !== void 0)
+    return { text: decoded, length: semicolonIndex - index + 1 };
+}
+
+// packages/coding-agent/dist/utils/syntax-highlight.js
+var require2 = createRequire(new URL("../utils/syntax-highlight.js", import.meta.url).href), highlighter;
+function getHighlighter() {
+  return highlighter ??= require2("highlight.js/lib/index.js"), highlighter;
+}
+var SPAN_CLOSE = "</span>", HIGHLIGHT_CLASS_PREFIX = "hljs-";
+function getScopeFromSpanTag(tag) {
+  let match = /\sclass\s*=\s*(?:"([^"]*)"|'([^']*)')/.exec(tag), classValue = match?.[1] ?? match?.[2];
+  if (classValue) {
+    for (let className of classValue.split(/\s+/))
+      if (className.startsWith(HIGHLIGHT_CLASS_PREFIX))
+        return className.slice(HIGHLIGHT_CLASS_PREFIX.length);
+  }
+}
+function getScopeFormatter(scope, theme2) {
+  let exact = theme2[scope];
+  if (exact)
+    return exact;
+  let dotIndex = scope.indexOf(".");
+  if (dotIndex !== -1) {
+    let prefixFormatter = theme2[scope.slice(0, dotIndex)];
+    if (prefixFormatter)
+      return prefixFormatter;
+  }
+  let dashIndex = scope.indexOf("-");
+  if (dashIndex !== -1) {
+    let prefixFormatter = theme2[scope.slice(0, dashIndex)];
+    if (prefixFormatter)
+      return prefixFormatter;
+  }
+}
+function getActiveFormatter(scopes, theme2) {
+  for (let i = scopes.length - 1; i >= 0; i--) {
+    let scope = scopes[i];
+    if (!scope)
+      continue;
+    let formatter = getScopeFormatter(scope, theme2);
+    if (formatter)
+      return formatter;
+  }
+  return theme2.default;
+}
+function isSpanOpenTagStart(html, index) {
+  if (!html.startsWith("<span", index))
+    return !1;
+  let nextChar = html[index + 5];
+  return nextChar === ">" || nextChar === " " || nextChar === "	" || nextChar === `
+` || nextChar === "\r";
+}
+function renderHighlightedHtml(html, theme2 = {}) {
+  let output = "", textBuffer = "", scopes = [], flushText = () => {
+    if (!textBuffer)
+      return;
+    let formatter = getActiveFormatter(scopes, theme2);
+    output += formatter ? formatter(textBuffer) : textBuffer, textBuffer = "";
+  }, index = 0;
+  for (; index < html.length; ) {
+    if (isSpanOpenTagStart(html, index)) {
+      let tagEndIndex = html.indexOf(">", index + 5);
+      if (tagEndIndex !== -1) {
+        flushText();
+        let tag = html.slice(index, tagEndIndex + 1), scope = getScopeFromSpanTag(tag);
+        scopes.push(scope), index = tagEndIndex + 1;
+        continue;
+      }
+    }
+    if (html.startsWith(SPAN_CLOSE, index)) {
+      flushText(), scopes.length > 0 && scopes.pop(), index += SPAN_CLOSE.length;
+      continue;
+    }
+    if (html[index] === "&") {
+      let decoded = decodeHtmlEntityAt(html, index);
+      if (decoded) {
+        textBuffer += decoded.text, index += decoded.length;
+        continue;
+      }
+    }
+    textBuffer += html[index], index++;
+  }
+  return flushText(), output;
+}
+function highlight(code, options = {}) {
+  let html = options.language ? getHighlighter().highlight(code, {
+    language: options.language,
+    ignoreIllegals: options.ignoreIllegals
+  }).value : getHighlighter().highlightAuto(code, options.languageSubset).value;
+  return renderHighlightedHtml(html, options.theme);
+}
+function supportsLanguage(name) {
+  return getHighlighter().getLanguage(name) !== void 0;
+}
+
+// packages/coding-agent/dist/modes/interactive/theme/theme.js
+var require3 = createRequire2(new URL("../modes/interactive/theme/theme.js", import.meta.url).href);
+function createThemeSchema() {
+  let { Type } = require3("typebox"), ColorValueSchema = Type.Union([
+    Type.String(),
+    // hex "#ff0000", var ref "primary", or empty ""
+    Type.Integer({ minimum: 0, maximum: 255 })
+    // 256-color index
+  ]);
+  return Type.Object({
+    $schema: Type.Optional(Type.String()),
+    name: Type.String(),
+    vars: Type.Optional(Type.Record(Type.String(), ColorValueSchema)),
+    colors: Type.Object({
+      // Core UI (10 colors)
+      accent: ColorValueSchema,
+      accent2: Type.Optional(ColorValueSchema),
+      border: ColorValueSchema,
+      borderAccent: ColorValueSchema,
+      borderMuted: ColorValueSchema,
+      success: ColorValueSchema,
+      error: ColorValueSchema,
+      warning: ColorValueSchema,
+      muted: ColorValueSchema,
+      dim: ColorValueSchema,
+      text: ColorValueSchema,
+      white: Type.Optional(ColorValueSchema),
+      thinkingText: ColorValueSchema,
+      // Backgrounds & Content Text (11 colors)
+      selectedBg: ColorValueSchema,
+      userMessageBg: ColorValueSchema,
+      userMessageText: ColorValueSchema,
+      customMessageBg: ColorValueSchema,
+      customMessageText: ColorValueSchema,
+      customMessageLabel: ColorValueSchema,
+      toolPendingBg: ColorValueSchema,
+      toolSuccessBg: ColorValueSchema,
+      toolErrorBg: ColorValueSchema,
+      toolTitle: ColorValueSchema,
+      toolOutput: ColorValueSchema,
+      // Markdown (10 colors)
+      mdHeading: ColorValueSchema,
+      mdLink: ColorValueSchema,
+      mdLinkUrl: ColorValueSchema,
+      mdCode: ColorValueSchema,
+      mdCodeBlock: ColorValueSchema,
+      mdCodeBlockBorder: ColorValueSchema,
+      mdQuote: ColorValueSchema,
+      mdQuoteBorder: ColorValueSchema,
+      mdHr: ColorValueSchema,
+      mdListBullet: ColorValueSchema,
+      // Tool Diffs (3 colors)
+      toolDiffAdded: ColorValueSchema,
+      toolDiffRemoved: ColorValueSchema,
+      toolDiffContext: ColorValueSchema,
+      // Syntax Highlighting (9 colors)
+      syntaxComment: ColorValueSchema,
+      syntaxKeyword: ColorValueSchema,
+      syntaxFunction: ColorValueSchema,
+      syntaxVariable: ColorValueSchema,
+      syntaxString: ColorValueSchema,
+      syntaxNumber: ColorValueSchema,
+      syntaxType: ColorValueSchema,
+      syntaxOperator: ColorValueSchema,
+      syntaxPunctuation: ColorValueSchema,
+      // Thinking Level Borders (6 colors)
+      thinkingOff: ColorValueSchema,
+      thinkingMinimal: ColorValueSchema,
+      thinkingLow: ColorValueSchema,
+      thinkingMedium: ColorValueSchema,
+      thinkingHigh: ColorValueSchema,
+      thinkingXhigh: ColorValueSchema,
+      thinkingMax: Type.Optional(ColorValueSchema),
+      // Bash Mode (1 color)
+      bashMode: ColorValueSchema
+    }),
+    glyphs: Type.Optional(Type.Object({
+      promptMoon: Type.Optional(Type.String()),
+      promptArrow: Type.Optional(Type.String())
+    })),
+    export: Type.Optional(Type.Object({
+      pageBg: Type.Optional(ColorValueSchema),
+      cardBg: Type.Optional(ColorValueSchema),
+      infoBg: Type.Optional(ColorValueSchema)
+    }))
+  });
+}
+function createThemeValidator() {
+  let { Compile } = require3("typebox/compile");
+  return Compile(createThemeSchema());
+}
+var themeValidator;
+function hexToRgb(hex) {
+  let cleaned = hex.replace("#", "");
+  if (cleaned.length !== 6)
+    throw new Error(`Invalid hex color: ${hex}`);
+  let r = parseInt(cleaned.substring(0, 2), 16), g = parseInt(cleaned.substring(2, 4), 16), b = parseInt(cleaned.substring(4, 6), 16);
+  if (Number.isNaN(r) || Number.isNaN(g) || Number.isNaN(b))
+    throw new Error(`Invalid hex color: ${hex}`);
+  return { r, g, b };
+}
+var CUBE_VALUES = [0, 95, 135, 175, 215, 255], GRAY_VALUES = Array.from({ length: 24 }, (_, i) => 8 + i * 10);
+function findClosestCubeIndex(value) {
+  let minDist = 1 / 0, minIdx = 0;
+  for (let i = 0; i < CUBE_VALUES.length; i++) {
+    let dist = Math.abs(value - CUBE_VALUES[i]);
+    dist < minDist && (minDist = dist, minIdx = i);
+  }
+  return minIdx;
+}
+function findClosestGrayIndex(gray) {
+  let minDist = 1 / 0, minIdx = 0;
+  for (let i = 0; i < GRAY_VALUES.length; i++) {
+    let dist = Math.abs(gray - GRAY_VALUES[i]);
+    dist < minDist && (minDist = dist, minIdx = i);
+  }
+  return minIdx;
+}
+function colorDistance(r1, g1, b1, r2, g2, b2) {
+  let dr = r1 - r2, dg = g1 - g2, db = b1 - b2;
+  return dr * dr * 0.299 + dg * dg * 0.587 + db * db * 0.114;
+}
+function rgbTo256(r, g, b) {
+  let rIdx = findClosestCubeIndex(r), gIdx = findClosestCubeIndex(g), bIdx = findClosestCubeIndex(b), cubeR = CUBE_VALUES[rIdx], cubeG = CUBE_VALUES[gIdx], cubeB = CUBE_VALUES[bIdx], cubeIndex = 16 + 36 * rIdx + 6 * gIdx + bIdx, cubeDist = colorDistance(r, g, b, cubeR, cubeG, cubeB), gray = Math.round(0.299 * r + 0.587 * g + 0.114 * b), grayIdx = findClosestGrayIndex(gray), grayValue = GRAY_VALUES[grayIdx], grayIndex = 232 + grayIdx, grayDist = colorDistance(r, g, b, grayValue, grayValue, grayValue), maxC = Math.max(r, g, b), minC = Math.min(r, g, b);
+  return maxC - minC < 10 && grayDist < cubeDist ? grayIndex : cubeIndex;
+}
+function hexTo256(hex) {
+  let { r, g, b } = hexToRgb(hex);
+  return rgbTo256(r, g, b);
+}
+function fgAnsi(color, mode) {
+  if (color === "")
+    return "\x1B[39m";
+  if (typeof color == "number")
+    return `\x1B[38;5;${color}m`;
+  if (color.startsWith("#"))
+    if (mode === "truecolor") {
+      let { r, g, b } = hexToRgb(color);
+      return `\x1B[38;2;${r};${g};${b}m`;
+    } else
+      return `\x1B[38;5;${hexTo256(color)}m`;
+  throw new Error(`Invalid color value: ${color}`);
+}
+function bgAnsi(color, mode) {
+  if (color === "")
+    return "\x1B[49m";
+  if (typeof color == "number")
+    return `\x1B[48;5;${color}m`;
+  if (color.startsWith("#"))
+    if (mode === "truecolor") {
+      let { r, g, b } = hexToRgb(color);
+      return `\x1B[48;2;${r};${g};${b}m`;
+    } else
+      return `\x1B[48;5;${hexTo256(color)}m`;
+  throw new Error(`Invalid color value: ${color}`);
+}
+function resolveVarRefs(value, vars, visited = /* @__PURE__ */ new Set()) {
+  if (typeof value == "number" || value === "" || value.startsWith("#"))
+    return value;
+  if (visited.has(value))
+    throw new Error(`Circular variable reference detected: ${value}`);
+  if (!(value in vars))
+    throw new Error(`Variable reference not found: ${value}`);
+  return visited.add(value), resolveVarRefs(vars[value], vars, visited);
+}
+function resolveThemeColors(colors, vars = {}) {
+  let resolved = {};
+  for (let [key, value] of Object.entries(colors))
+    resolved[key] = resolveVarRefs(value, vars);
+  return resolved;
+}
+function withThemeColorFallbacks(colors) {
+  return {
+    ...colors,
+    thinkingMax: colors.thinkingMax ?? colors.thinkingXhigh,
+    accent2: colors.accent2 ?? colors.accent,
+    white: colors.white ?? colors.text
+  };
+}
+var DEFAULT_THEME_GLYPHS = {
+  promptArrow: ">"
+}, Theme = class {
+  name;
+  sourcePath;
+  sourceInfo;
+  fgColors;
+  bgColors;
+  glyphs;
+  mode;
+  constructor(fgColors, bgColors, mode, options = {}) {
+    this.name = options.name, this.sourcePath = options.sourcePath, this.sourceInfo = options.sourceInfo, this.mode = mode, this.glyphs = { ...DEFAULT_THEME_GLYPHS, ...options.glyphs }, this.fgColors = /* @__PURE__ */ new Map();
+    let colors = { ...fgColors, thinkingMax: fgColors.thinkingMax ?? fgColors.thinkingXhigh };
+    for (let [key, value] of Object.entries(colors))
+      this.fgColors.set(key, fgAnsi(value, mode));
+    this.bgColors = /* @__PURE__ */ new Map();
+    for (let [key, value] of Object.entries(bgColors))
+      this.bgColors.set(key, bgAnsi(value, mode));
+  }
+  fg(color, text) {
+    let ansi = this.fgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme color: ${color}`);
+    return `${ansi}${text}\x1B[39m`;
+  }
+  bg(color, text) {
+    let ansi = this.bgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme background color: ${color}`);
+    return `${ansi}${text}\x1B[49m`;
+  }
+  bold(text) {
+    return chalk.bold(text);
+  }
+  italic(text) {
+    return chalk.italic(text);
+  }
+  underline(text) {
+    return chalk.underline(text);
+  }
+  inverse(text) {
+    return chalk.inverse(text);
+  }
+  strikethrough(text) {
+    return chalk.strikethrough(text);
+  }
+  getFgAnsi(color) {
+    let ansi = this.fgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme color: ${color}`);
+    return ansi;
+  }
+  getBgAnsi(color) {
+    let ansi = this.bgColors.get(color);
+    if (!ansi)
+      throw new Error(`Unknown theme background color: ${color}`);
+    return ansi;
+  }
+  getColorMode() {
+    return this.mode;
+  }
+  /** lunr: prompt glyph tokens; empty string means that part is hidden. */
+  glyph(name) {
+    return this.glyphs[name];
+  }
+  getThinkingBorderColor(level) {
+    switch (level) {
+      case "off":
+        return (str) => this.fg("thinkingOff", str);
+      case "minimal":
+        return (str) => this.fg("thinkingMinimal", str);
+      case "low":
+        return (str) => this.fg("thinkingLow", str);
+      case "medium":
+        return (str) => this.fg("thinkingMedium", str);
+      case "high":
+        return (str) => this.fg("thinkingHigh", str);
+      case "xhigh":
+        return (str) => this.fg("thinkingXhigh", str);
+      case "max":
+        return (str) => this.fg("thinkingMax", str);
+      default:
+        return (str) => this.fg("thinkingOff", str);
+    }
+  }
+  getBashModeBorderColor() {
+    return (str) => this.fg("bashMode", str);
+  }
+}, BUILTIN_THEMES;
+function getBuiltinThemes() {
+  if (!BUILTIN_THEMES) {
+    let themesDir = getThemesDir(), moonPath = path.join(themesDir, "moon.json");
+    BUILTIN_THEMES = {
+      moon: JSON.parse(fs.readFileSync(moonPath, "utf-8"))
+    };
+  }
+  return BUILTIN_THEMES;
+}
+function getAvailableThemes() {
+  return getAvailableThemesWithPaths().map(({ name }) => name);
+}
+function getAvailableThemesWithPaths() {
+  let themesDir = getThemesDir(), result = [], seen = /* @__PURE__ */ new Set(), addTheme = (themeInfo) => {
+    seen.has(themeInfo.name) || (seen.add(themeInfo.name), result.push(themeInfo));
+  };
+  for (let name of Object.keys(getBuiltinThemes()))
+    addTheme({ name, path: path.join(themesDir, `${name}.json`) });
+  for (let themeInfo of getCustomThemeInfos())
+    addTheme(themeInfo);
+  for (let [name, theme2] of registeredThemes.entries())
+    addTheme({ name, path: theme2.sourcePath });
+  return result.sort((a, b) => a.name.localeCompare(b.name));
+}
+function getCustomThemeInfos() {
+  let customThemesDir = getCustomThemesDir(), result = [];
+  if (!fs.existsSync(customThemesDir))
+    return result;
+  for (let file of fs.readdirSync(customThemesDir)) {
+    if (!file.endsWith(".json"))
+      continue;
+    let themePath = path.join(customThemesDir, file);
+    try {
+      let customTheme = loadThemeFromPath(themePath);
+      customTheme.name && result.push({ name: customTheme.name, path: themePath });
+    } catch {
+    }
+  }
+  return result;
+}
+function assertThemeNameIsValid(name) {
+  if (name.includes("/"))
+    throw new Error(`Invalid theme name "${name}": theme names cannot contain "/" because it is reserved for automatic light/dark theme settings.`);
+}
+function parseThemeJson(label, json) {
+  themeValidator ??= createThemeValidator();
+  let validateThemeJson = themeValidator;
+  if (!validateThemeJson.Check(json)) {
+    let errors = Array.from(validateThemeJson.Errors(json)), missingColors = /* @__PURE__ */ new Set(), otherErrors = [];
+    for (let error of errors) {
+      if (error.keyword === "required" && error.instancePath === "/colors") {
+        let requiredProperties = error.params.requiredProperties;
+        for (let requiredProperty of requiredProperties ?? [])
+          missingColors.add(requiredProperty);
+        continue;
+      }
+      let path2 = error.instancePath || "/";
+      otherErrors.push(`  - ${path2}: ${error.message}`);
+    }
+    let errorMessage = `Invalid theme "${label}":
+`;
+    throw missingColors.size > 0 && (errorMessage += `
+Missing required color tokens:
+`, errorMessage += Array.from(missingColors).sort().map((color) => `  - ${color}`).join(`
+`), errorMessage += `
+
+Please add these colors to your theme's "colors" object.`, errorMessage += `
+See the built-in theme (moon.json) for reference values.`), otherErrors.length > 0 && (errorMessage += `
+
+Other errors:
+${otherErrors.join(`
+`)}`), new Error(errorMessage);
+  }
+  let themeJson = json;
+  return assertThemeNameIsValid(themeJson.name), themeJson;
+}
+function parseThemeJsonContent(label, content) {
+  let json;
+  try {
+    json = JSON.parse(content);
+  } catch (error) {
+    throw new Error(`Failed to parse theme ${label}: ${error}`);
+  }
+  return parseThemeJson(label, json);
+}
+function loadThemeJson(name) {
+  let builtinThemes = getBuiltinThemes();
+  if (name in builtinThemes)
+    return builtinThemes[name];
+  let registeredTheme = registeredThemes.get(name);
+  if (registeredTheme?.sourcePath) {
+    let content2 = fs.readFileSync(registeredTheme.sourcePath, "utf-8");
+    return parseThemeJsonContent(registeredTheme.sourcePath, content2);
+  }
+  if (registeredTheme)
+    throw new Error(`Theme "${name}" does not have a source path for export`);
+  let customThemesDir = getCustomThemesDir(), themePath = path.join(customThemesDir, `${name}.json`);
+  if (!fs.existsSync(themePath))
+    throw new Error(`Theme not found: ${name}`);
+  let content = fs.readFileSync(themePath, "utf-8");
+  return parseThemeJsonContent(name, content);
+}
+function createTheme(themeJson, mode, sourcePath) {
+  let colorMode = mode ?? (getCapabilities().trueColor ? "truecolor" : "256color"), resolvedColors = resolveThemeColors(withThemeColorFallbacks(themeJson.colors), themeJson.vars), fgColors = {}, bgColors = {}, bgColorKeys = /* @__PURE__ */ new Set([
+    "selectedBg",
+    "userMessageBg",
+    "customMessageBg",
+    "toolPendingBg",
+    "toolSuccessBg",
+    "toolErrorBg"
+  ]);
+  for (let [key, value] of Object.entries(resolvedColors))
+    bgColorKeys.has(key) ? bgColors[key] = value : fgColors[key] = value;
+  return new Theme(fgColors, bgColors, colorMode, {
+    name: themeJson.name,
+    sourcePath,
+    glyphs: {
+      promptArrow: themeJson.glyphs?.promptArrow ?? DEFAULT_THEME_GLYPHS.promptArrow
+    }
+  });
+}
+function loadThemeFromPath(themePath, mode) {
+  let content = fs.readFileSync(themePath, "utf-8"), themeJson = parseThemeJsonContent(themePath, content);
+  return createTheme(themeJson, mode, themePath);
+}
+function loadTheme(name, mode) {
+  let registeredTheme = registeredThemes.get(name);
+  if (registeredTheme)
+    return registeredTheme;
+  let themeJson = loadThemeJson(name);
+  return createTheme(themeJson, mode);
+}
+function getThemeByName(name) {
+  try {
+    return loadTheme(name);
+  } catch {
+    return;
+  }
+}
+function parseAutoThemeSetting(themeSetting) {
+  if (!themeSetting)
+    return;
+  let slashIndex = themeSetting.indexOf("/");
+  if (slashIndex === -1 || themeSetting.indexOf("/", slashIndex + 1) !== -1)
+    return;
+  let lightTheme = themeSetting.slice(0, slashIndex).trim(), darkTheme = themeSetting.slice(slashIndex + 1).trim();
+  if (!(!lightTheme || !darkTheme))
+    return { lightTheme, darkTheme };
+}
+function resolveThemeSetting(themeSetting, terminalTheme) {
+  let autoTheme = parseAutoThemeSetting(themeSetting);
+  if (autoTheme)
+    return terminalTheme === "light" ? autoTheme.lightTheme : autoTheme.darkTheme;
+  if (!themeSetting?.includes("/") && typeof themeSetting == "string")
+    return themeSetting;
+}
+function getColorFgBgBackgroundIndex(colorfgbg) {
+  let parts = colorfgbg.split(";");
+  for (let i = parts.length - 1; i >= 0; i--) {
+    let bg = parseInt(parts[i].trim(), 10);
+    if (Number.isInteger(bg) && bg >= 0 && bg <= 255)
+      return bg;
+  }
+}
+function getRgbColorLuminance({ r, g, b }) {
+  let toLinear = (channel) => {
+    let value = channel / 255;
+    return value <= 0.03928 ? value / 12.92 : ((value + 0.055) / 1.055) ** 2.4;
+  };
+  return 0.2126 * toLinear(r) + 0.7152 * toLinear(g) + 0.0722 * toLinear(b);
+}
+function getAnsiColorLuminance(index) {
+  return getRgbColorLuminance(hexToRgb(ansi256ToHex(index)));
+}
+function getThemeForRgbColor(rgb) {
+  return getRgbColorLuminance(rgb) >= 0.5 ? "light" : "dark";
+}
+function detectTerminalBackgroundFromEnv(options = {}) {
+  let colorfgbg = (options.env ?? process.env).COLORFGBG || "", bg = getColorFgBgBackgroundIndex(colorfgbg);
+  return bg !== void 0 ? {
+    theme: getAnsiColorLuminance(bg) >= 0.5 ? "light" : "dark",
+    source: "COLORFGBG",
+    detail: `background color index ${bg}`,
+    confidence: "high"
+  } : {
+    theme: "dark",
+    source: "fallback",
+    detail: "no terminal background hint found",
+    confidence: "low"
+  };
+}
+async function detectTerminalBackgroundTheme({ ui, timeoutMs, env }) {
+  try {
+    let rgb = await ui.queryTerminalBackgroundColor({ timeoutMs });
+    if (rgb)
+      return {
+        theme: getThemeForRgbColor(rgb),
+        source: "terminal background",
+        detail: `OSC 11 background rgb(${rgb.r}, ${rgb.g}, ${rgb.b})`,
+        confidence: "high"
+      };
+  } catch {
+  }
+  return detectTerminalBackgroundFromEnv({ env });
+}
+async function detectTerminalThemeForAuto({ ui, timeoutMs, env }) {
+  try {
+    let colorScheme = await ui.queryTerminalColorScheme?.({ timeoutMs });
+    if (colorScheme)
+      return colorScheme;
+  } catch {
+  }
+  return (await detectTerminalBackgroundTheme({ ui, timeoutMs, env })).theme;
+}
+function getDefaultTheme() {
+  return "moon";
+}
+var THEME_KEY = /* @__PURE__ */ Symbol.for("@ashx-j/lunr-dev:theme"), THEME_KEY_OLD = /* @__PURE__ */ Symbol.for("@mariozechner/pi-coding-agent:theme"), theme = new Proxy({}, {
+  get(_target, prop) {
+    let t = globalThis[THEME_KEY];
+    if (!t)
+      throw new Error("Theme not initialized. Call initTheme() first.");
+    return t[prop];
+  }
+});
+function setGlobalTheme(t) {
+  globalThis[THEME_KEY] = t, globalThis[THEME_KEY_OLD] = t;
+}
+var currentThemeName, themeWatcher, themeReloadTimer, onThemeChangeCallback, registeredThemes = /* @__PURE__ */ new Map();
+function setRegisteredThemes(themes) {
+  registeredThemes.clear();
+  for (let theme2 of themes)
+    theme2.name && (assertThemeNameIsValid(theme2.name), registeredThemes.set(theme2.name, theme2));
+}
+function initTheme(themeName, enableWatcher = !1) {
+  let name = themeName ?? getDefaultTheme();
+  currentThemeName = name;
+  try {
+    setGlobalTheme(loadTheme(name)), enableWatcher && startThemeWatcher();
+  } catch {
+    currentThemeName = "moon", setGlobalTheme(loadTheme("moon"));
+  }
+}
+function setTheme(name, enableWatcher = !1) {
+  currentThemeName = name;
+  try {
+    return setGlobalTheme(loadTheme(name)), enableWatcher && startThemeWatcher(), onThemeChangeCallback && onThemeChangeCallback(), { success: !0 };
+  } catch (error) {
+    return currentThemeName = "moon", setGlobalTheme(loadTheme("moon")), {
+      success: !1,
+      error: error instanceof Error ? error.message : String(error)
+    };
+  }
+}
+function setThemeInstance(themeInstance) {
+  setGlobalTheme(themeInstance), currentThemeName = "<in-memory>", stopThemeWatcher(), onThemeChangeCallback && onThemeChangeCallback();
+}
+function onThemeChange(callback) {
+  onThemeChangeCallback = callback;
+}
+function getThemeName() {
+  return currentThemeName ?? getDefaultTheme();
+}
+function startThemeWatcher() {
+  if (stopThemeWatcher(), !currentThemeName || currentThemeName === "moon")
+    return;
+  let customThemesDir = getCustomThemesDir(), watchedThemeName = currentThemeName, watchedFileName = `${watchedThemeName}.json`, themeFile = path.join(customThemesDir, watchedFileName);
+  if (!fs.existsSync(themeFile))
+    return;
+  let scheduleReload = () => {
+    themeReloadTimer && clearTimeout(themeReloadTimer), themeReloadTimer = setTimeout(() => {
+      if (themeReloadTimer = void 0, currentThemeName === watchedThemeName && fs.existsSync(themeFile))
+        try {
+          let reloadedTheme = loadThemeFromPath(themeFile);
+          registeredThemes.set(watchedThemeName, reloadedTheme), setGlobalTheme(reloadedTheme), onThemeChangeCallback && onThemeChangeCallback();
+        } catch {
+        }
+    }, 100);
+  };
+  themeWatcher = watchWithErrorHandler(customThemesDir, (_eventType, filename) => {
+    if (currentThemeName === watchedThemeName) {
+      if (!filename) {
+        scheduleReload();
+        return;
+      }
+      filename === watchedFileName && scheduleReload();
+    }
+  }, () => {
+    closeWatcher(themeWatcher), themeWatcher = void 0;
+  }) ?? void 0;
+}
+function stopThemeWatcher() {
+  themeReloadTimer && (clearTimeout(themeReloadTimer), themeReloadTimer = void 0), closeWatcher(themeWatcher), themeWatcher = void 0;
+}
+function ansi256ToHex(index) {
+  let basicColors = [
+    "#000000",
+    "#800000",
+    "#008000",
+    "#808000",
+    "#000080",
+    "#800080",
+    "#008080",
+    "#c0c0c0",
+    "#808080",
+    "#ff0000",
+    "#00ff00",
+    "#ffff00",
+    "#0000ff",
+    "#ff00ff",
+    "#00ffff",
+    "#ffffff"
+  ];
+  if (index < 16)
+    return basicColors[index];
+  if (index < 232) {
+    let cubeIndex = index - 16, r = Math.floor(cubeIndex / 36), g = Math.floor(cubeIndex % 36 / 6), b = cubeIndex % 6, toHex = (n) => (n === 0 ? 0 : 55 + n * 40).toString(16).padStart(2, "0");
+    return `#${toHex(r)}${toHex(g)}${toHex(b)}`;
+  }
+  let grayHex = (8 + (index - 232) * 10).toString(16).padStart(2, "0");
+  return `#${grayHex}${grayHex}${grayHex}`;
+}
+function getResolvedThemeColors(themeName) {
+  let name = themeName ?? currentThemeName ?? getDefaultTheme(), isLight = name === "light", themeJson = loadThemeJson(name), resolved = resolveThemeColors(withThemeColorFallbacks(themeJson.colors), themeJson.vars), defaultText = isLight ? "#000000" : "#e5e5e7", cssColors = {};
+  for (let [key, value] of Object.entries(resolved))
+    typeof value == "number" ? cssColors[key] = ansi256ToHex(value) : value === "" ? cssColors[key] = defaultText : cssColors[key] = value;
+  return cssColors;
+}
+function getThemeExportColors(themeName) {
+  let name = themeName ?? currentThemeName ?? getDefaultTheme();
+  try {
+    let themeJson = loadThemeJson(name), exportSection = themeJson.export;
+    if (!exportSection)
+      return {};
+    let vars = themeJson.vars ?? {}, resolve = (value) => {
+      if (value === void 0)
+        return;
+      let resolved = resolveVarRefs(value, vars);
+      if (typeof resolved == "number")
+        return ansi256ToHex(resolved);
+      if (resolved !== "")
+        return resolved;
+    };
+    return {
+      pageBg: resolve(exportSection.pageBg),
+      cardBg: resolve(exportSection.cardBg),
+      infoBg: resolve(exportSection.infoBg)
+    };
+  } catch {
+    return {};
+  }
+}
+var cachedHighlightThemeFor, cachedCliHighlightTheme;
+function buildCliHighlightTheme(t) {
+  return {
+    keyword: (s) => t.fg("syntaxKeyword", s),
+    built_in: (s) => t.fg("syntaxType", s),
+    literal: (s) => t.fg("syntaxNumber", s),
+    number: (s) => t.fg("syntaxNumber", s),
+    regexp: (s) => t.fg("syntaxString", s),
+    string: (s) => t.fg("syntaxString", s),
+    comment: (s) => t.fg("syntaxComment", s),
+    doctag: (s) => t.fg("syntaxComment", s),
+    meta: (s) => t.fg("muted", s),
+    function: (s) => t.fg("syntaxFunction", s),
+    title: (s) => t.fg("syntaxFunction", s),
+    class: (s) => t.fg("syntaxType", s),
+    type: (s) => t.fg("syntaxType", s),
+    tag: (s) => t.fg("syntaxPunctuation", s),
+    name: (s) => t.fg("syntaxKeyword", s),
+    attr: (s) => t.fg("syntaxVariable", s),
+    variable: (s) => t.fg("syntaxVariable", s),
+    params: (s) => t.fg("syntaxVariable", s),
+    operator: (s) => t.fg("syntaxOperator", s),
+    punctuation: (s) => t.fg("syntaxPunctuation", s),
+    emphasis: (s) => t.italic(s),
+    strong: (s) => t.bold(s),
+    link: (s) => t.underline(s),
+    addition: (s) => t.fg("toolDiffAdded", s),
+    deletion: (s) => t.fg("toolDiffRemoved", s)
+  };
+}
+function getCliHighlightTheme(t) {
+  return (cachedHighlightThemeFor !== t || !cachedCliHighlightTheme) && (cachedHighlightThemeFor = t, cachedCliHighlightTheme = buildCliHighlightTheme(t)), cachedCliHighlightTheme;
+}
+function highlightCode(code, lang) {
+  let validLang = lang && supportsLanguage(lang) ? lang : void 0;
+  if (!validLang)
+    return code.split(`
+`).map((line) => theme.fg("mdCodeBlock", line));
+  let opts = {
+    language: validLang,
+    ignoreIllegals: !0,
+    theme: getCliHighlightTheme(theme)
+  };
+  try {
+    return highlight(code, opts).split(`
+`);
+  } catch {
+    return code.split(`
+`);
+  }
+}
+function getLanguageFromPath(filePath) {
+  let ext = filePath.split(".").pop()?.toLowerCase();
+  return ext ? {
+    ts: "typescript",
+    tsx: "typescript",
+    js: "javascript",
+    jsx: "javascript",
+    mjs: "javascript",
+    cjs: "javascript",
+    py: "python",
+    rb: "ruby",
+    rs: "rust",
+    go: "go",
+    java: "java",
+    kt: "kotlin",
+    swift: "swift",
+    c: "c",
+    h: "c",
+    cpp: "cpp",
+    cc: "cpp",
+    cxx: "cpp",
+    hpp: "cpp",
+    cs: "csharp",
+    php: "php",
+    sh: "bash",
+    bash: "bash",
+    zsh: "bash",
+    fish: "fish",
+    ps1: "powershell",
+    sql: "sql",
+    html: "html",
+    htm: "html",
+    css: "css",
+    scss: "scss",
+    sass: "sass",
+    less: "less",
+    json: "json",
+    yaml: "yaml",
+    yml: "yaml",
+    toml: "toml",
+    xml: "xml",
+    md: "markdown",
+    markdown: "markdown",
+    dockerfile: "dockerfile",
+    makefile: "makefile",
+    cmake: "cmake",
+    lua: "lua",
+    perl: "perl",
+    r: "r",
+    scala: "scala",
+    clj: "clojure",
+    ex: "elixir",
+    exs: "elixir",
+    erl: "erlang",
+    hs: "haskell",
+    ml: "ocaml",
+    vim: "vim",
+    graphql: "graphql",
+    proto: "protobuf",
+    tf: "hcl",
+    hcl: "hcl"
+  }[ext] : void 0;
+}
+function getMarkdownTheme() {
+  return {
+    heading: (text) => theme.fg("mdHeading", text),
+    link: (text) => theme.fg("mdLink", text),
+    linkUrl: (text) => theme.fg("mdLinkUrl", text),
+    code: (text) => theme.fg("mdCode", text),
+    codeBlock: (text) => theme.fg("mdCodeBlock", text),
+    codeBlockBorder: (text) => theme.fg("mdCodeBlockBorder", text),
+    quote: (text) => theme.fg("mdQuote", text),
+    quoteBorder: (text) => theme.fg("mdQuoteBorder", text),
+    hr: (text) => theme.fg("mdHr", text),
+    listBullet: (text) => theme.fg("mdListBullet", text),
+    bold: (text) => theme.bold(text),
+    italic: (text) => theme.italic(text),
+    underline: (text) => theme.underline(text),
+    strikethrough: (text) => chalk.strikethrough(text),
+    highlightCode: (code, lang) => {
+      let validLang = lang && supportsLanguage(lang) ? lang : void 0;
+      if (!validLang)
+        return code.split(`
+`).map((line) => theme.fg("mdCodeBlock", line));
+      let opts = {
+        language: validLang,
+        ignoreIllegals: !0,
+        theme: getCliHighlightTheme(theme)
+      };
+      try {
+        return highlight(code, opts).split(`
+`);
+      } catch {
+        return code.split(`
+`).map((line) => theme.fg("mdCodeBlock", line));
+      }
+    }
+  };
+}
+function getSelectListTheme() {
+  return {
+    selectedPrefix: (text) => theme.fg("accent", text),
+    selectedText: (text) => theme.fg("accent", text),
+    description: (text) => theme.fg("muted", text),
+    scrollInfo: (text) => theme.fg("muted", text),
+    noMatch: (text) => theme.fg("muted", text)
+  };
+}
+function getEditorTheme() {
+  return {
+    borderColor: (text) => theme.fg("borderMuted", text),
+    selectList: getSelectListTheme()
+  };
+}
+function getSettingsListTheme() {
+  return {
+    label: (text, selected) => selected ? theme.fg("accent", text) : text,
+    value: (text, selected) => selected ? theme.fg("accent", text) : theme.fg("muted", text),
+    description: (text) => theme.fg("dim", text),
+    disabled: (text) => theme.fg("dim", text),
+    cursor: theme.fg("accent", "\u2192 "),
+    hint: (text) => theme.fg("dim", text)
+  };
+}
+
+export {
+  FS_WATCH_RETRY_DELAY_MS,
+  closeWatcher,
+  watchWithErrorHandler,
+  Theme,
+  getAvailableThemes,
+  getAvailableThemesWithPaths,
+  loadThemeFromPath,
+  getThemeByName,
+  parseAutoThemeSetting,
+  resolveThemeSetting,
+  detectTerminalBackgroundFromEnv,
+  detectTerminalThemeForAuto,
+  getDefaultTheme,
+  theme,
+  setRegisteredThemes,
+  initTheme,
+  setTheme,
+  setThemeInstance,
+  onThemeChange,
+  getThemeName,
+  stopThemeWatcher,
+  getResolvedThemeColors,
+  getThemeExportColors,
+  highlightCode,
+  getLanguageFromPath,
+  getMarkdownTheme,
+  getSelectListTheme,
+  getEditorTheme,
+  getSettingsListTheme
+};