bashio 1.1.0 → 2.0.0

package/dist/App-SRRDMIMW.js

@@ -0,0 +1,2378 @@
+#!/usr/bin/env node
+import {
+  CHATGPT_SUBSCRIPTION_MODELS,
+  CLAUDE_MODELS,
+  CLAUDE_SUBSCRIPTION_MODELS,
+  COPILOT_MODELS,
+  OLLAMA_RECOMMENDED_MODELS,
+  OPENAI_MODELS,
+  OPENROUTER_MODELS,
+  THEMES,
+  configExists,
+  copyToClipboard,
+  createProvider,
+  getThemeByName,
+  loadConfig,
+  runAuthSetup,
+  saveConfig
+} from "./chunk-PYTBTPZN.js";
+
+// src/chat/App.tsx
+import { MouseProvider } from "@ink-tools/ink-mouse";
+import { Box as Box11, render, Text as Text11, useApp, useInput as useInput7, useStdout as useStdout4 } from "ink";
+import { useCallback as useCallback2, useEffect as useEffect2, useMemo as useMemo5, useRef as useRef8, useState as useState7 } from "react";
+
+// src/chat/components/InputBox.tsx
+import { Box as Box2, Text as Text2, useInput } from "ink";
+import { memo as memo2, useMemo as useMemo2, useRef as useRef2, useState } from "react";
+
+// src/chat/utils/slashCommands.ts
+var SLASH_COMMANDS = [
+  {
+    name: "models",
+    description: "Switch AI model",
+    action: "openModelSwitcher"
+  },
+  {
+    name: "sessions",
+    description: "Browse chat sessions",
+    action: "openSessionPicker"
+  },
+  {
+    name: "theme",
+    description: "Change color theme",
+    action: "openThemePicker"
+  },
+  { name: "new", description: "Start new chat session", action: "newSession" },
+  { name: "clear", description: "Clear current chat", action: "clearChat" },
+  { name: "exit", description: "Exit chat", action: "exitChat" }
+];
+function filterCommands(query) {
+  const normalizedQuery = query.toLowerCase().replace(/^\//, "");
+  if (!normalizedQuery) return SLASH_COMMANDS;
+  return SLASH_COMMANDS.filter(
+    (cmd) => cmd.name.toLowerCase().startsWith(normalizedQuery) || cmd.description.toLowerCase().includes(normalizedQuery)
+  );
+}
+
+// src/chat/utils/ThemeContext.tsx
+import { createContext, useContext } from "react";
+var ThemeContext = createContext(THEMES[0]);
+var ThemeProvider = ThemeContext.Provider;
+function useTheme() {
+  return useContext(ThemeContext);
+}
+
+// src/chat/components/SlashCommandMenu.tsx
+import { useOnClick, useOnMouseMove } from "@ink-tools/ink-mouse";
+import { Box, Text } from "ink";
+import { memo, useMemo, useRef } from "react";
+import { jsx, jsxs } from "react/jsx-runtime";
+var VISIBLE_ROWS = 5;
+var MenuItem = memo(function MenuItem2({
+  cmd,
+  isSelected,
+  width,
+  index,
+  accent,
+  textPrimary,
+  onHover,
+  onClick
+}) {
+  const rowRef = useRef(null);
+  const nameColWidth = 15;
+  const nameText = `/${cmd.name}`.padEnd(nameColWidth);
+  const descWidth = width - nameColWidth - 6;
+  const descText = cmd.description.length > descWidth ? `${cmd.description.slice(0, descWidth - 3)}...` : cmd.description;
+  useOnMouseMove(rowRef, () => {
+    onHover(index);
+  });
+  useOnClick(rowRef, () => {
+    onClick(index);
+  });
+  if (isSelected) {
+    return /* @__PURE__ */ jsx(Box, { ref: rowRef, backgroundColor: accent, paddingX: 1, children: /* @__PURE__ */ jsxs(Text, { color: "white", bold: true, children: [
+      nameText,
+      descText
+    ] }) });
+  }
+  return /* @__PURE__ */ jsxs(Box, { ref: rowRef, paddingX: 1, children: [
+    /* @__PURE__ */ jsx(Text, { color: textPrimary, children: nameText }),
+    /* @__PURE__ */ jsx(Text, { dimColor: true, children: descText })
+  ] });
+});
+var SlashCommandMenu = memo(function SlashCommandMenu2({
+  commands,
+  selectedIndex,
+  width,
+  onHover,
+  onSelect
+}) {
+  const theme = useTheme();
+  const menuWidth = width;
+  const { visibleCommands, startIndex } = useMemo(() => {
+    let start = 0;
+    if (commands.length > VISIBLE_ROWS) {
+      start = Math.max(
+        0,
+        Math.min(
+          selectedIndex - Math.floor(VISIBLE_ROWS / 2),
+          commands.length - VISIBLE_ROWS
+        )
+      );
+    }
+    return {
+      visibleCommands: commands.slice(start, start + VISIBLE_ROWS),
+      startIndex: start
+    };
+  }, [commands, selectedIndex]);
+  const handleHover = (index) => {
+    onHover?.(index);
+  };
+  const handleClick = (index) => {
+    onSelect?.(index);
+  };
+  if (commands.length === 0) {
+    return /* @__PURE__ */ jsx(
+      Box,
+      {
+        borderStyle: "round",
+        borderColor: "gray",
+        paddingX: 1,
+        width: menuWidth,
+        flexDirection: "column",
+        children: /* @__PURE__ */ jsx(Text, { dimColor: true, children: "No matching commands" })
+      }
+    );
+  }
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      borderStyle: "round",
+      borderColor: theme.accent,
+      backgroundColor: theme.secondaryBg,
+      flexDirection: "column",
+      width: menuWidth,
+      children: visibleCommands.map((cmd, i) => /* @__PURE__ */ jsx(
+        MenuItem,
+        {
+          cmd,
+          isSelected: startIndex + i === selectedIndex,
+          width: menuWidth,
+          index: startIndex + i,
+          accent: theme.accent,
+          textPrimary: theme.textPrimary,
+          onHover: handleHover,
+          onClick: handleClick
+        },
+        cmd.name
+      ))
+    }
+  );
+});
+
+// src/chat/components/InputBox.tsx
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+var InputBox = memo2(function InputBox2({
+  onSubmit,
+  onSlashCommand,
+  slashModeRef,
+  modelName,
+  disabled = false,
+  width = 50,
+  placeholder = "Ask anything..."
+}) {
+  const [value, setValue] = useState("");
+  const [cursorPos, setCursorPos] = useState(0);
+  const [menuIndex, setMenuIndex] = useState(0);
+  const isSlashMode = value.startsWith("/") && !value.includes("\n");
+  const filteredCommands = useMemo2(
+    () => isSlashMode ? filterCommands(value) : [],
+    [isSlashMode, value]
+  );
+  const prevSlashMode = useRef2(false);
+  if (prevSlashMode.current !== isSlashMode) {
+    prevSlashMode.current = isSlashMode;
+    slashModeRef.current = isSlashMode;
+  }
+  useInput(
+    (input, key) => {
+      if (disabled) return;
+      const normalizedInput = input.replaceAll("\x1B[200~", "").replaceAll("\x1B[201~", "").replaceAll("\r", "");
+      if (isSlashMode && filteredCommands.length > 0) {
+        if (key.upArrow) {
+          setMenuIndex((i) => Math.max(0, i - 1));
+          return;
+        }
+        if (key.downArrow) {
+          setMenuIndex((i) => Math.min(filteredCommands.length - 1, i + 1));
+          return;
+        }
+        if (key.tab) {
+          const selected = filteredCommands[menuIndex];
+          if (selected) {
+            setValue(`/${selected.name}`);
+            setCursorPos(selected.name.length + 1);
+          }
+          return;
+        }
+        if (key.return && !key.shift) {
+          const selected = filteredCommands[menuIndex];
+          if (selected) {
+            onSlashCommand(selected.action);
+            setValue("");
+            setCursorPos(0);
+            setMenuIndex(0);
+          }
+          return;
+        }
+      }
+      if (key.return && !key.shift) {
+        if (value.trim()) {
+          onSubmit(value);
+          setValue("");
+          setCursorPos(0);
+          setMenuIndex(0);
+        }
+        return;
+      }
+      if (key.escape && isSlashMode) {
+        setValue("");
+        setCursorPos(0);
+        setMenuIndex(0);
+        return;
+      }
+      if (key.return && key.shift || key.ctrl && input === "j") {
+        setValue((v) => `${v.slice(0, cursorPos)}
+${v.slice(cursorPos)}`);
+        setCursorPos((p) => p + 1);
+        return;
+      }
+      const isControlSequence = normalizedInput.length > 1 && (/^\[<?\d+;/.test(normalizedInput) || /^\[[0-9;]*[A-Za-z~]$/.test(normalizedInput));
+      if (isControlSequence) {
+        return;
+      }
+      if (normalizedInput.length > 1 && !key.ctrl && !key.meta && !normalizedInput.includes("\x1B")) {
+        setValue(
+          (v) => v.slice(0, cursorPos) + normalizedInput + v.slice(cursorPos)
+        );
+        setCursorPos((p) => p + normalizedInput.length);
+        setMenuIndex(0);
+        return;
+      }
+      if (key.backspace || key.delete) {
+        if (cursorPos > 0) {
+          setValue((v) => v.slice(0, cursorPos - 1) + v.slice(cursorPos));
+          setCursorPos((p) => p - 1);
+          setMenuIndex(0);
+        }
+        return;
+      }
+      if (key.leftArrow) {
+        if (key.ctrl) {
+          const before = value.slice(0, cursorPos);
+          const match = before.match(/\S+\s*$/);
+          setCursorPos((p) => match ? p - match[0].length : 0);
+        } else {
+          setCursorPos((p) => Math.max(0, p - 1));
+        }
+        return;
+      }
+      if (key.rightArrow) {
+        if (key.ctrl) {
+          const after = value.slice(cursorPos);
+          const match = after.match(/^\s*\S+/);
+          setCursorPos((p) => match ? p + match[0].length : value.length);
+        } else {
+          setCursorPos((p) => Math.min(value.length, p + 1));
+        }
+        return;
+      }
+      if (key.ctrl && input === "a") {
+        setCursorPos(0);
+        return;
+      }
+      if (key.ctrl && input === "e") {
+        setCursorPos(value.length);
+        return;
+      }
+      if (key.ctrl && input === "u") {
+        setValue("");
+        setCursorPos(0);
+        setMenuIndex(0);
+        return;
+      }
+      if (normalizedInput && !key.ctrl && !key.meta && normalizedInput.length === 1) {
+        const charCode = normalizedInput.charCodeAt(0);
+        if (charCode >= 32) {
+          setValue(
+            (v) => v.slice(0, cursorPos) + normalizedInput + v.slice(cursorPos)
+          );
+          setCursorPos((p) => p + 1);
+          setMenuIndex(0);
+        }
+      }
+    },
+    { isActive: !disabled }
+  );
+  const beforeCursor = value.slice(0, cursorPos);
+  const atCursor = value[cursorPos] || " ";
+  const afterCursor = value.slice(cursorPos + 1);
+  const isEmpty = value.length === 0;
+  const menuHeight = filteredCommands.length > 0 ? Math.min(filteredCommands.length, 5) + 2 : 3;
+  const cursor = "\u258B";
+  const theme = useTheme();
+  const handleMenuHover = (index) => {
+    setMenuIndex(index);
+  };
+  const handleMenuSelect = (index) => {
+    const selected = filteredCommands[index];
+    if (selected) {
+      onSlashCommand(selected.action);
+      setValue("");
+      setCursorPos(0);
+      setMenuIndex(0);
+    }
+  };
+  return /* @__PURE__ */ jsxs2(
+    Box2,
+    {
+      flexDirection: "column",
+      width,
+      backgroundColor: theme.background,
+      children: [
+        isSlashMode && /* @__PURE__ */ jsx2(Box2, { position: "absolute", marginTop: -menuHeight, marginLeft: 0, children: /* @__PURE__ */ jsx2(
+          SlashCommandMenu,
+          {
+            commands: filteredCommands,
+            selectedIndex: menuIndex,
+            width: width - 2,
+            onHover: handleMenuHover,
+            onSelect: handleMenuSelect
+          }
+        ) }),
+        /* @__PURE__ */ jsx2(
+          Box2,
+          {
+            flexDirection: "column",
+            paddingTop: 1,
+            backgroundColor: theme.background,
+            children: /* @__PURE__ */ jsx2(
+              Box2,
+              {
+                flexDirection: "column",
+                borderStyle: "round",
+                borderColor: theme.accent,
+                backgroundColor: theme.secondaryBg,
+                paddingX: 2,
+                paddingY: 1,
+                children: /* @__PURE__ */ jsx2(Box2, { children: isEmpty && !disabled ? /* @__PURE__ */ jsxs2(Text2, { children: [
+                  /* @__PURE__ */ jsx2(Text2, { color: theme.textPrimary, children: cursor }),
+                  /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: placeholder })
+                ] }) : /* @__PURE__ */ jsxs2(
+                  Text2,
+                  {
+                    color: disabled ? "gray" : isSlashMode ? theme.accent : theme.textPrimary,
+                    children: [
+                      beforeCursor,
+                      !disabled && /* @__PURE__ */ jsx2(Text2, { color: theme.textPrimary, children: cursor }),
+                      atCursor !== " " && atCursor,
+                      afterCursor.replace(/\n/g, "\u21B5")
+                    ]
+                  }
+                ) })
+              }
+            )
+          }
+        ),
+        /* @__PURE__ */ jsxs2(
+          Box2,
+          {
+            justifyContent: "space-between",
+            paddingX: 1,
+            backgroundColor: theme.background,
+            children: [
+              /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(Text2, { color: theme.accent, children: "\u25C6 " }),
+                /* @__PURE__ */ jsx2(Text2, { color: theme.textPrimary, children: modelName })
+              ] }),
+              /* @__PURE__ */ jsxs2(Box2, { children: [
+                /* @__PURE__ */ jsx2(Text2, { color: theme.textPrimary, bold: true, children: "/" }),
+                /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " commands " }),
+                /* @__PURE__ */ jsx2(Text2, { color: theme.textPrimary, bold: true, children: "ctrl+c" }),
+                /* @__PURE__ */ jsx2(Text2, { dimColor: true, children: " exit" })
+              ] })
+            ]
+          }
+        )
+      ]
+    }
+  );
+});
+
+// src/chat/components/MessageList.tsx
+import { useOnClick as useOnClick3, useOnWheel } from "@ink-tools/ink-mouse";
+import { highlight } from "cli-highlight";
+import { Box as Box4, Text as Text4, useInput as useInput3 } from "ink";
+import { ScrollView } from "ink-scroll-view";
+import Spinner from "ink-spinner";
+import {
+  forwardRef,
+  memo as memo4,
+  useCallback,
+  useEffect,
+  useImperativeHandle,
+  useMemo as useMemo3,
+  useRef as useRef4,
+  useState as useState3
+} from "react";
+
+// src/chat/components/MessageContextMenu.tsx
+import { useOnClick as useOnClick2, useOnMouseMove as useOnMouseMove2 } from "@ink-tools/ink-mouse";
+import { Box as Box3, Text as Text3, useInput as useInput2 } from "ink";
+import { memo as memo3, useRef as useRef3, useState as useState2 } from "react";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+var menuItems = [
+  { label: "Copy", description: "message text to clipboard", action: "copy" },
+  { label: "Exit", description: "close this menu", action: "exit" }
+];
+var MenuItemRow = memo3(function MenuItemRow2({
+  item,
+  index,
+  isSelected,
+  rowWidth,
+  accent,
+  onHover,
+  onClick
+}) {
+  const rowRef = useRef3(null);
+  useOnMouseMove2(rowRef, () => {
+    onHover(index);
+  });
+  useOnClick2(rowRef, () => {
+    onClick(item.action);
+  });
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      ref: rowRef,
+      backgroundColor: isSelected ? accent : void 0,
+      width: rowWidth,
+      justifyContent: "space-between",
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsx3(Text3, { color: isSelected ? "white" : "white", bold: isSelected, children: item.label }),
+        isSelected ? /* @__PURE__ */ jsx3(Text3, { color: "white", children: item.description }) : /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: item.description })
+      ]
+    }
+  );
+});
+var MessageContextMenu = memo3(function MessageContextMenu2({
+  onSelect,
+  onClose,
+  width = 50
+}) {
+  const [selectedIndex, setSelectedIndex] = useState2(0);
+  useInput2((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      const selected = menuItems[selectedIndex];
+      if (selected) {
+        if (selected.action === "exit") {
+          onClose();
+        } else {
+          onSelect(selected.action);
+        }
+      }
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((i) => Math.min(menuItems.length - 1, i + 1));
+    }
+  });
+  const handleHover = (index) => {
+    setSelectedIndex(index);
+  };
+  const handleClick = (action) => {
+    if (action === "exit") {
+      onClose();
+    } else {
+      onSelect(action);
+    }
+  };
+  const theme = useTheme();
+  const menuWidth = Math.min(width, 50);
+  return /* @__PURE__ */ jsxs3(
+    Box3,
+    {
+      flexDirection: "column",
+      width: menuWidth,
+      borderStyle: "round",
+      borderColor: theme.accent,
+      backgroundColor: theme.background,
+      children: [
+        /* @__PURE__ */ jsxs3(Box3, { paddingX: 1, justifyContent: "space-between", children: [
+          /* @__PURE__ */ jsx3(Text3, { bold: true, color: theme.textPrimary, children: "Message Actions" }),
+          /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "esc" })
+        ] }),
+        /* @__PURE__ */ jsx3(Box3, { paddingX: 1, children: /* @__PURE__ */ jsx3(Text3, { dimColor: true, children: "\u2500".repeat(menuWidth - 4) }) }),
+        /* @__PURE__ */ jsx3(Box3, { flexDirection: "column", paddingBottom: 1, children: menuItems.map((item, index) => /* @__PURE__ */ jsx3(
+          MenuItemRow,
+          {
+            item,
+            index,
+            isSelected: index === selectedIndex,
+            rowWidth: menuWidth - 2,
+            accent: theme.accent,
+            onHover: handleHover,
+            onClick: handleClick
+          },
+          item.action
+        )) })
+      ]
+    }
+  );
+});
+
+// src/chat/components/MessageList.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+function parseInlineMarkdown(text, keyPrefix) {
+  const nodes = [];
+  const inlineRegex = /(\*\*|__)(.+?)\1|(\*|_)(.+?)\3|`([^`]+)`/g;
+  let lastIndex = 0;
+  let match;
+  let idx = 0;
+  match = inlineRegex.exec(text);
+  while (match !== null) {
+    if (match.index > lastIndex) {
+      nodes.push(text.slice(lastIndex, match.index));
+    }
+    if (match[2]) {
+      nodes.push(
+        /* @__PURE__ */ jsx4(Text4, { bold: true, children: match[2] }, `${keyPrefix}-b-${idx++}`)
+      );
+    } else if (match[4]) {
+      nodes.push(
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: match[4] }, `${keyPrefix}-i-${idx++}`)
+      );
+    } else if (match[5]) {
+      nodes.push(
+        /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: match[5] }, `${keyPrefix}-c-${idx++}`)
+      );
+    }
+    lastIndex = match.index + match[0].length;
+    match = inlineRegex.exec(text);
+  }
+  if (lastIndex < text.length) {
+    nodes.push(text.slice(lastIndex));
+  }
+  return nodes.length > 0 ? nodes : [text];
+}
+function parseLine(line, keyIndex, _maxWidth) {
+  const trimmed = line.trimStart();
+  const indent = line.length - trimmed.length;
+  if (/^(-{3,}|\*{3,}|_{3,})$/.test(trimmed)) {
+    return null;
+  }
+  const headerMatch = trimmed.match(/^(#{1,6})\s+(.+)$/);
+  if (headerMatch) {
+    const level = headerMatch[1].length;
+    const headerText = headerMatch[2];
+    const parsed2 = parseInlineMarkdown(headerText, `h-${keyIndex}`);
+    if (level === 1) {
+      return /* @__PURE__ */ jsx4(Text4, { bold: true, color: "yellow", children: parsed2 }, keyIndex);
+    }
+    if (level === 2) {
+      return /* @__PURE__ */ jsx4(Text4, { bold: true, color: "white", children: parsed2 }, keyIndex);
+    }
+    return /* @__PURE__ */ jsx4(Text4, { bold: true, children: parsed2 }, keyIndex);
+  }
+  const bulletMatch = trimmed.match(/^[-*]\s+(.+)$/);
+  if (bulletMatch) {
+    const bulletText = bulletMatch[1];
+    const parsed2 = parseInlineMarkdown(bulletText, `li-${keyIndex}`);
+    return /* @__PURE__ */ jsx4(Box4, { paddingLeft: indent, children: /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "\u2022" }),
+      " ",
+      parsed2
+    ] }) }, keyIndex);
+  }
+  const numberedMatch = trimmed.match(/^(\d+)\.\s+(.+)$/);
+  if (numberedMatch) {
+    const num = numberedMatch[1];
+    const itemText = numberedMatch[2];
+    const parsed2 = parseInlineMarkdown(itemText, `ol-${keyIndex}`);
+    return /* @__PURE__ */ jsx4(Box4, { paddingLeft: indent, children: /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsxs4(Text4, { color: "yellow", children: [
+        num,
+        "."
+      ] }),
+      " ",
+      parsed2
+    ] }) }, keyIndex);
+  }
+  const quoteMatch = trimmed.match(/^>\s*(.*)$/);
+  if (quoteMatch) {
+    const quoteText = quoteMatch[1];
+    const parsed2 = parseInlineMarkdown(quoteText, `q-${keyIndex}`);
+    return /* @__PURE__ */ jsx4(Box4, { paddingLeft: 1, children: /* @__PURE__ */ jsxs4(Text4, { children: [
+      /* @__PURE__ */ jsx4(Text4, { color: "gray", children: "\u2502" }),
+      " ",
+      /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: parsed2 })
+    ] }) }, keyIndex);
+  }
+  if (trimmed.length === 0) {
+    return /* @__PURE__ */ jsx4(Text4, { children: " " }, keyIndex);
+  }
+  const parsed = parseInlineMarkdown(line, `p-${keyIndex}`);
+  return /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: parsed }, keyIndex);
+}
+var BOX = {
+  topLeft: "\u250C",
+  topRight: "\u2510",
+  bottomLeft: "\u2514",
+  bottomRight: "\u2518",
+  horizontal: "\u2500",
+  vertical: "\u2502",
+  topMid: "\u252C",
+  bottomMid: "\u2534",
+  leftMid: "\u251C",
+  rightMid: "\u2524",
+  midMid: "\u253C"
+};
+function wrapText(text, maxWidth) {
+  if (text.length <= maxWidth) {
+    return [text];
+  }
+  const words = text.split(" ");
+  const lines = [];
+  let currentLine = "";
+  for (const word of words) {
+    const testLine = currentLine ? `${currentLine} ${word}` : word;
+    if (testLine.length <= maxWidth) {
+      currentLine = testLine;
+    } else {
+      if (currentLine) {
+        lines.push(currentLine);
+      }
+      if (word.length > maxWidth) {
+        let remaining = word;
+        while (remaining.length > maxWidth) {
+          lines.push(remaining.slice(0, maxWidth));
+          remaining = remaining.slice(maxWidth);
+        }
+        currentLine = remaining;
+      } else {
+        currentLine = word;
+      }
+    }
+  }
+  if (currentLine) {
+    lines.push(currentLine);
+  }
+  return lines.length > 0 ? lines : [""];
+}
+function parseTable(lines, startKey, maxWidth) {
+  const headerLine = lines[0];
+  const headers = headerLine.split("|").map((h) => h.trim()).filter((h) => h.length > 0);
+  if (headers.length === 0) {
+    return { node: null, linesConsumed: 0 };
+  }
+  const separatorLine = lines[1];
+  if (!separatorLine || !/^\|?[\s-:|]+\|?$/.test(separatorLine)) {
+    return { node: null, linesConsumed: 0 };
+  }
+  const dataRows = [];
+  let i = 2;
+  while (i < lines.length && lines[i].includes("|")) {
+    const row = lines[i].split("|").map((c) => c.trim()).filter((_, idx, arr) => {
+      if (idx === 0 && arr[idx] === "") return false;
+      if (idx === arr.length - 1 && arr[idx] === "") return false;
+      return true;
+    });
+    if (row.length > 0) {
+      dataRows.push(row);
+    }
+    i++;
+  }
+  const numCols = headers.length;
+  const availableWidth = maxWidth - (numCols + 1) - numCols * 2;
+  const colWidth = Math.max(Math.floor(availableWidth / numCols), 15);
+  const colWidths = headers.map(() => colWidth);
+  const tableRows = [];
+  let keyIdx = startKey;
+  let topBorder = BOX.topLeft;
+  for (let c = 0; c < numCols; c++) {
+    topBorder += BOX.horizontal.repeat(colWidths[c] + 2);
+    topBorder += c < numCols - 1 ? BOX.topMid : BOX.topRight;
+  }
+  tableRows.push(
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: topBorder }) }, `top-${keyIdx++}`)
+  );
+  const wrappedHeaders = headers.map((h, idx) => wrapText(h, colWidths[idx]));
+  const headerLineCount = Math.max(...wrappedHeaders.map((w) => w.length));
+  for (let lineIdx = 0; lineIdx < headerLineCount; lineIdx++) {
+    tableRows.push(
+      /* @__PURE__ */ jsxs4(Box4, { children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: BOX.vertical }),
+        headers.map((_, colIdx) => {
+          const wrappedLines = wrappedHeaders[colIdx];
+          const lineText = wrappedLines[lineIdx] || "";
+          return /* @__PURE__ */ jsxs4(Text4, { children: [
+            /* @__PURE__ */ jsxs4(Text4, { bold: true, color: "yellow", children: [
+              " ",
+              lineText.padEnd(colWidths[colIdx]),
+              " "
+            ] }),
+            /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: BOX.vertical })
+          ] }, `h-${colIdx}-${lineIdx}`);
+        })
+      ] }, `header-${keyIdx++}-${lineIdx}`)
+    );
+  }
+  let headerSep = BOX.leftMid;
+  for (let c = 0; c < numCols; c++) {
+    headerSep += BOX.horizontal.repeat(colWidths[c] + 2);
+    headerSep += c < numCols - 1 ? BOX.midMid : BOX.rightMid;
+  }
+  tableRows.push(
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: headerSep }) }, `sep-${keyIdx++}`)
+  );
+  for (let rowIdx = 0; rowIdx < dataRows.length; rowIdx++) {
+    const row = dataRows[rowIdx];
+    const wrappedCells = headers.map((_, colIdx) => {
+      const cell = row[colIdx] || "";
+      return wrapText(cell, colWidths[colIdx]);
+    });
+    const maxLines = Math.max(...wrappedCells.map((w) => w.length));
+    for (let lineIdx = 0; lineIdx < maxLines; lineIdx++) {
+      tableRows.push(
+        /* @__PURE__ */ jsxs4(Box4, { children: [
+          /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: BOX.vertical }),
+          headers.map((_, colIdx) => {
+            const wrappedLines = wrappedCells[colIdx];
+            const lineText = wrappedLines[lineIdx] || "";
+            const paddedText = lineText.padEnd(colWidths[colIdx]);
+            const parsed = parseInlineMarkdown(
+              paddedText,
+              `cell-${rowIdx}-${colIdx}-${lineIdx}`
+            );
+            return /* @__PURE__ */ jsxs4(Text4, { children: [
+              " ",
+              parsed,
+              " ",
+              /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: BOX.vertical })
+            ] }, `c-${colIdx}-${rowIdx}-${lineIdx}`);
+          })
+        ] }, `row-${keyIdx++}-${rowIdx}-${lineIdx}`)
+      );
+    }
+  }
+  let bottomBorder = BOX.bottomLeft;
+  for (let c = 0; c < numCols; c++) {
+    bottomBorder += BOX.horizontal.repeat(colWidths[c] + 2);
+    bottomBorder += c < numCols - 1 ? BOX.bottomMid : BOX.bottomRight;
+  }
+  tableRows.push(
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: bottomBorder }) }, `bottom-${keyIdx++}`)
+  );
+  return {
+    node: /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", children: tableRows }, startKey),
+    linesConsumed: i
+  };
+}
+function isTableRow(line) {
+  const trimmed = line.trim();
+  return trimmed.startsWith("|") && trimmed.endsWith("|") && trimmed.length > 2;
+}
+function processLines(lines, startKeyIndex, maxWidth) {
+  const parts = [];
+  let keyIndex = startKeyIndex;
+  let i = 0;
+  while (i < lines.length) {
+    const line = lines[i];
+    if (isTableRow(line) && i + 1 < lines.length) {
+      const nextLine = lines[i + 1];
+      if (/^\|?[\s-:|]+\|?$/.test(nextLine.trim())) {
+        const tableLines = lines.slice(i);
+        const { node, linesConsumed } = parseTable(
+          tableLines,
+          keyIndex,
+          maxWidth
+        );
+        if (node && linesConsumed > 0) {
+          parts.push(node);
+          keyIndex++;
+          i += linesConsumed;
+          continue;
+        }
+      }
+    }
+    parts.push(parseLine(line, keyIndex++, maxWidth));
+    i++;
+  }
+  return { parts, keyIndex };
+}
+function parseContent(content, maxWidth) {
+  const parts = [];
+  const codeBlockRegex = /```(\w+)?\n([\s\S]*?)```/g;
+  let lastIndex = 0;
+  let match;
+  let keyIndex = 0;
+  match = codeBlockRegex.exec(content);
+  while (match !== null) {
+    if (match.index > lastIndex) {
+      const text = content.slice(lastIndex, match.index);
+      const lines = text.split("\n");
+      const result = processLines(lines, keyIndex, maxWidth);
+      parts.push(...result.parts);
+      keyIndex = result.keyIndex;
+    }
+    const language = match[1] || "bash";
+    const code = match[2].trim();
+    try {
+      const highlighted = highlight(code, { language, ignoreIllegals: true });
+      parts.push(
+        /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", width: maxWidth - 4, children: /* @__PURE__ */ jsxs4(
+          Box4,
+          {
+            borderStyle: "single",
+            borderColor: "gray",
+            paddingX: 1,
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: language }),
+              /* @__PURE__ */ jsx4(Text4, { children: highlighted })
+            ]
+          }
+        ) }, keyIndex++)
+      );
+    } catch {
+      parts.push(
+        /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", width: maxWidth - 4, children: /* @__PURE__ */ jsxs4(
+          Box4,
+          {
+            borderStyle: "single",
+            borderColor: "gray",
+            paddingX: 1,
+            flexDirection: "column",
+            children: [
+              /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: language }),
+              /* @__PURE__ */ jsx4(Text4, { children: code })
+            ]
+          }
+        ) }, keyIndex++)
+      );
+    }
+    lastIndex = match.index + match[0].length;
+    match = codeBlockRegex.exec(content);
+  }
+  if (lastIndex < content.length) {
+    const text = content.slice(lastIndex);
+    const lines = text.split("\n");
+    const result = processLines(lines, keyIndex, maxWidth);
+    parts.push(...result.parts);
+  }
+  return parts.length > 0 ? parts : [
+    /* @__PURE__ */ jsx4(Text4, { wrap: "wrap", children: content }, 0)
+  ];
+}
+var Message = memo4(function Message2({
+  message,
+  width,
+  messageIndex,
+  accent,
+  onMessageClick
+}) {
+  const isUser = message.role === "user";
+  const messageRef = useRef4(null);
+  const parsedContent = useMemo3(
+    () => parseContent(message.content, width - 4),
+    [message.content, width]
+  );
+  useOnClick3(
+    messageRef,
+    !isUser && onMessageClick ? () => {
+      onMessageClick(messageIndex, message.content);
+    } : null
+  );
+  return /* @__PURE__ */ jsxs4(Box4, { ref: messageRef, flexDirection: "column", marginY: 1, width, children: [
+    /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsxs4(Text4, { bold: true, color: isUser ? accent : "yellow", children: [
+      isUser ? "You" : "Bashio",
+      ":"
+    ] }) }),
+    /* @__PURE__ */ jsx4(Box4, { flexDirection: "column", paddingLeft: 2, children: parsedContent })
+  ] });
+});
+var EmptyState = memo4(function EmptyState2({ height }) {
+  return /* @__PURE__ */ jsxs4(
+    Box4,
+    {
+      flexDirection: "column",
+      height,
+      paddingX: 1,
+      justifyContent: "center",
+      alignItems: "center",
+      children: [
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Start a conversation by typing a message below." }),
+        /* @__PURE__ */ jsx4(Text4, { dimColor: true, children: "Type / for commands or Ctrl+P to switch models." })
+      ]
+    }
+  );
+});
+var MessageList = memo4(
+  forwardRef(function MessageList2({ messages, currentResponse, isLoading, height, width, slashModeRef }, ref) {
+    const theme = useTheme();
+    const scrollRef = useRef4(null);
+    const mouseRef = useRef4(null);
+    const [followOutput, setFollowOutput] = useState3(true);
+    const [contextMenu, setContextMenu] = useState3(null);
+    const handleMessageClick = useCallback(
+      (messageIndex, content) => {
+        setContextMenu({ messageIndex, content });
+      },
+      []
+    );
+    const handleContextMenuSelect = useCallback(
+      async (action) => {
+        if (action === "copy" && contextMenu) {
+          await copyToClipboard(contextMenu.content);
+        }
+        setContextMenu(null);
+      },
+      [contextMenu]
+    );
+    const handleContextMenuClose = useCallback(() => {
+      setContextMenu(null);
+    }, []);
+    const boundedScrollBy = useCallback((delta) => {
+      const sv = scrollRef.current;
+      if (!sv) return;
+      const currentOffset = sv.getScrollOffset();
+      const maxOffset = sv.getBottomOffset();
+      const newOffset = Math.max(0, Math.min(maxOffset, currentOffset + delta));
+      sv.scrollTo(newOffset);
+      setFollowOutput(newOffset >= maxOffset);
+    }, []);
+    const boundedScrollToBottom = useCallback(() => {
+      const sv = scrollRef.current;
+      if (!sv) return;
+      const maxOffset = sv.getBottomOffset();
+      sv.scrollTo(Math.max(0, maxOffset));
+      setFollowOutput(true);
+    }, []);
+    useImperativeHandle(
+      ref,
+      () => ({
+        scrollBy: boundedScrollBy,
+        scrollToBottom: boundedScrollToBottom
+      }),
+      [boundedScrollBy, boundedScrollToBottom]
+    );
+    const messagesCount = messages.length;
+    const hasResponse = Boolean(currentResponse);
+    useEffect(() => {
+      if (!followOutput) return;
+      const timer = setTimeout(() => {
+        boundedScrollToBottom();
+      }, 10);
+      return () => clearTimeout(timer);
+    }, [messagesCount, hasResponse, boundedScrollToBottom, followOutput]);
+    useInput3((input, key) => {
+      if (slashModeRef.current) return;
+      if (input.startsWith("\x1B[<")) {
+        return;
+      }
+      const isUpSequence = input === "\x1B[A";
+      const isDownSequence = input === "\x1B[B";
+      const isPageUpSequence = input === "\x1B[5~";
+      const isPageDownSequence = input === "\x1B[6~";
+      if (key.ctrl && input === "l") {
+        boundedScrollToBottom();
+        return;
+      }
+      if (key.upArrow || isUpSequence) boundedScrollBy(-1);
+      if (key.downArrow || isDownSequence) boundedScrollBy(1);
+      if (key.pageUp || isPageUpSequence) {
+        boundedScrollBy(-Math.floor(height / 2));
+      }
+      if (key.pageDown || isPageDownSequence) {
+        boundedScrollBy(Math.floor(height / 2));
+      }
+      if (input === "k" && key.ctrl) boundedScrollBy(-3);
+      if (input === "k" && key.meta) boundedScrollBy(-3);
+      if (input === "j" && key.meta) boundedScrollBy(3);
+    });
+    useOnWheel(mouseRef, (event) => {
+      if (event.button === "wheel-up") {
+        boundedScrollBy(-3);
+      } else if (event.button === "wheel-down") {
+        boundedScrollBy(3);
+      }
+    });
+    useEffect(() => {
+      if (followOutput) return;
+      const sv = scrollRef.current;
+      if (!sv) return;
+      const currentOffset = sv.getScrollOffset();
+      const maxOffset = sv.getBottomOffset();
+      if (maxOffset === 0 || currentOffset >= maxOffset) {
+        setFollowOutput(true);
+      }
+    }, [followOutput]);
+    const streamingContent = useMemo3(
+      () => currentResponse ? parseContent(currentResponse, width - 4) : null,
+      [currentResponse, width]
+    );
+    if (messages.length === 0 && !currentResponse) {
+      return /* @__PURE__ */ jsx4(EmptyState, { height });
+    }
+    return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", height, width, children: [
+      /* @__PURE__ */ jsx4(Box4, { ref: mouseRef, height, paddingX: 1, overflow: "hidden", children: /* @__PURE__ */ jsxs4(ScrollView, { ref: scrollRef, height, children: [
+        messages.map((msg, i) => /* @__PURE__ */ jsx4(
+          Message,
+          {
+            message: msg,
+            width,
+            messageIndex: i,
+            accent: theme.accent,
+            onMessageClick: contextMenu === null ? handleMessageClick : void 0
+          },
+          `msg-${i}-${msg.role}`
+        )),
+        streamingContent && /* @__PURE__ */ jsxs4(
+          Box4,
+          {
+            flexDirection: "column",
+            marginY: 1,
+            width,
+            children: [
+              /* @__PURE__ */ jsx4(Box4, { children: /* @__PURE__ */ jsx4(Text4, { bold: true, color: "yellow", children: "Bashio:" }) }),
+              /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", paddingLeft: 2, children: [
+                streamingContent,
+                /* @__PURE__ */ jsx4(Text4, { color: "yellow", children: "|" })
+              ] })
+            ]
+          },
+          "streaming"
+        ),
+        isLoading && !currentResponse && /* @__PURE__ */ jsxs4(Box4, { marginY: 1, children: [
+          /* @__PURE__ */ jsx4(Text4, { color: theme.accent, children: /* @__PURE__ */ jsx4(Spinner, { type: "dots" }) }),
+          /* @__PURE__ */ jsx4(Text4, { color: theme.accent, children: " Thinking..." })
+        ] }, "loading")
+      ] }) }),
+      contextMenu !== null && /* @__PURE__ */ jsx4(
+        Box4,
+        {
+          position: "absolute",
+          width,
+          height,
+          justifyContent: "center",
+          alignItems: "center",
+          children: /* @__PURE__ */ jsx4(
+            MessageContextMenu,
+            {
+              onSelect: handleContextMenuSelect,
+              onClose: handleContextMenuClose,
+              width: Math.min(width - 4, 50)
+            }
+          )
+        }
+      )
+    ] });
+  })
+);
+
+// src/chat/components/ModelSwitcher.tsx
+import { useOnClick as useOnClick4, useOnMouseMove as useOnMouseMove3 } from "@ink-tools/ink-mouse";
+import { Box as Box5, Text as Text5, useInput as useInput4, useStdout } from "ink";
+import { memo as memo5, useRef as useRef5, useState as useState4 } from "react";
+import { jsx as jsx5, jsxs as jsxs5 } from "react/jsx-runtime";
+var PROVIDER_LABELS = {
+  "claude-subscription": "Claude Pro/Max",
+  "chatgpt-subscription": "ChatGPT Plus/Pro",
+  copilot: "GitHub Copilot",
+  claude: "Claude API",
+  openai: "OpenAI API",
+  ollama: "Ollama",
+  openrouter: "OpenRouter"
+};
+var ModelRow = memo5(function ModelRow2({
+  option,
+  isSelected,
+  isCurrent,
+  rowWidth,
+  accent,
+  onHover,
+  onClick
+}) {
+  const rowRef = useRef5(null);
+  useOnMouseMove3(rowRef, onHover);
+  useOnClick4(rowRef, onClick);
+  const prefix = isSelected ? ">" : isCurrent ? "\u2713" : " ";
+  const labelWithPrefix = ` ${prefix} ${option.label}`;
+  const padding = Math.max(0, rowWidth - labelWithPrefix.length);
+  const fullLine = labelWithPrefix + " ".repeat(padding);
+  return /* @__PURE__ */ jsx5(Box5, { ref: rowRef, children: /* @__PURE__ */ jsx5(
+    Text5,
+    {
+      backgroundColor: isSelected ? accent : void 0,
+      color: isSelected ? "#000000" : void 0,
+      children: fullLine
+    }
+  ) });
+});
+function getModelsForProvider(provider) {
+  switch (provider) {
+    case "claude":
+      return CLAUDE_MODELS;
+    case "claude-subscription":
+      return CLAUDE_SUBSCRIPTION_MODELS;
+    case "openai":
+      return OPENAI_MODELS;
+    case "chatgpt-subscription":
+      return CHATGPT_SUBSCRIPTION_MODELS;
+    case "copilot":
+      return COPILOT_MODELS;
+    case "ollama":
+      return OLLAMA_RECOMMENDED_MODELS.map((m) => ({ value: m, label: m }));
+    case "openrouter":
+      return OPENROUTER_MODELS;
+    default:
+      return [];
+  }
+}
+function ModelSwitcher({
+  config,
+  onSelect,
+  onClose
+}) {
+  const { stdout } = useStdout();
+  const width = stdout?.columns ?? 80;
+  const height = stdout?.rows ?? 24;
+  const theme = useTheme();
+  const currentProvider = config.activeProvider;
+  const currentModel = config.providers[currentProvider]?.model;
+  const options = [];
+  const providers = Object.keys(config.providers);
+  for (const provider of providers) {
+    const models = getModelsForProvider(provider);
+    const providerLabel = PROVIDER_LABELS[provider] || provider;
+    for (const model of models) {
+      options.push({
+        provider,
+        providerLabel,
+        model: model.value,
+        label: model.label
+      });
+    }
+  }
+  const currentIndex = options.findIndex(
+    (o) => o.provider === currentProvider && o.model === currentModel
+  );
+  const [selectedIndex, setSelectedIndex] = useState4(
+    currentIndex >= 0 ? currentIndex : 0
+  );
+  const handleHover = (index) => {
+    setSelectedIndex(index);
+  };
+  const handleClick = (index) => {
+    const selected = options[index];
+    if (selected) {
+      onSelect(selected.provider, selected.model);
+    }
+  };
+  useInput4((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      const selected = options[selectedIndex];
+      if (selected) {
+        onSelect(selected.provider, selected.model);
+      }
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((i) => Math.min(options.length - 1, i + 1));
+    }
+  });
+  const boxWidth = Math.min(60, width - 4);
+  const maxListHeight = 12;
+  const listHeight = Math.min(options.length, maxListHeight, height - 8);
+  let startIndex = 0;
+  if (selectedIndex >= listHeight) {
+    startIndex = selectedIndex - listHeight + 1;
+  }
+  const visibleOptions = options.slice(startIndex, startIndex + listHeight);
+  let lastProvider = null;
+  return /* @__PURE__ */ jsx5(
+    Box5,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      justifyContent: "center",
+      alignItems: "center",
+      backgroundColor: theme.background,
+      children: /* @__PURE__ */ jsxs5(
+        Box5,
+        {
+          flexDirection: "column",
+          width: boxWidth,
+          borderStyle: "round",
+          borderColor: theme.accent,
+          paddingX: 1,
+          children: [
+            /* @__PURE__ */ jsxs5(Box5, { marginBottom: 1, justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsx5(Text5, { bold: true, color: theme.accent, children: "Model Selector" }),
+              /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "esc to exit" })
+            ] }),
+            /* @__PURE__ */ jsxs5(Box5, { children: [
+              /* @__PURE__ */ jsx5(Text5, { color: theme.accent, children: "Current: " }),
+              /* @__PURE__ */ jsxs5(Text5, { children: [
+                PROVIDER_LABELS[currentProvider],
+                " / ",
+                currentModel
+              ] })
+            ] }),
+            /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500".repeat(boxWidth - 4) }),
+            /* @__PURE__ */ jsx5(Box5, { flexDirection: "column", children: visibleOptions.map((option, i) => {
+              const actualIndex = startIndex + i;
+              const isSelected = actualIndex === selectedIndex;
+              const isCurrent = option.provider === currentProvider && option.model === currentModel;
+              const showProviderHeader = option.provider !== lastProvider;
+              lastProvider = option.provider;
+              return /* @__PURE__ */ jsxs5(
+                Box5,
+                {
+                  flexDirection: "column",
+                  children: [
+                    showProviderHeader && /* @__PURE__ */ jsxs5(Text5, { bold: true, color: theme.accent, children: [
+                      i > 0 ? "\n" : "",
+                      option.providerLabel
+                    ] }),
+                    /* @__PURE__ */ jsx5(
+                      ModelRow,
+                      {
+                        option,
+                        isSelected,
+                        isCurrent,
+                        rowWidth: boxWidth - 4,
+                        accent: theme.accent,
+                        onHover: () => handleHover(actualIndex),
+                        onClick: () => handleClick(actualIndex)
+                      }
+                    )
+                  ]
+                },
+                `${option.provider}-${option.model}`
+              );
+            }) }),
+            /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2500".repeat(boxWidth - 4) }),
+            /* @__PURE__ */ jsxs5(Box5, { justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u2191\u2193 navigate" }),
+              options.length > listHeight && /* @__PURE__ */ jsxs5(Text5, { dimColor: true, children: [
+                startIndex + 1,
+                "-",
+                Math.min(startIndex + listHeight, options.length),
+                "/",
+                options.length
+              ] }),
+              /* @__PURE__ */ jsx5(Text5, { dimColor: true, children: "\u21B5 select" })
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/chat/components/SessionHeader.tsx
+import { Box as Box6, Text as Text6 } from "ink";
+import { memo as memo6 } from "react";
+import { jsx as jsx6, jsxs as jsxs6 } from "react/jsx-runtime";
+var SessionHeader = memo6(function SessionHeader2({
+  sessionTitle,
+  width
+}) {
+  const theme = useTheme();
+  return /* @__PURE__ */ jsxs6(
+    Box6,
+    {
+      borderStyle: "single",
+      borderLeft: true,
+      borderRight: false,
+      borderTop: false,
+      borderBottom: false,
+      borderColor: theme.accent,
+      backgroundColor: theme.secondaryBg,
+      paddingX: 1,
+      paddingY: 1,
+      gap: 1,
+      width,
+      children: [
+        /* @__PURE__ */ jsx6(Text6, { color: theme.accent, children: "#" }),
+        /* @__PURE__ */ jsx6(Text6, { color: theme.textPrimary, children: sessionTitle })
+      ]
+    }
+  );
+});
+
+// src/chat/components/SessionPicker.tsx
+import { useOnClick as useOnClick5, useOnMouseMove as useOnMouseMove4 } from "@ink-tools/ink-mouse";
+import { Box as Box7, Text as Text7, useInput as useInput5, useStdout as useStdout2 } from "ink";
+import { memo as memo7, useRef as useRef6, useState as useState5 } from "react";
+
+// src/chat/utils/sessions.ts
+import {
+  existsSync,
+  mkdirSync,
+  readdirSync,
+  readFileSync,
+  unlinkSync,
+  writeFileSync
+} from "fs";
+import { homedir } from "os";
+import { join } from "path";
+var MAX_SESSIONS = 50;
+function getSessionsDir() {
+  const dir = join(homedir(), ".bashio", "sessions");
+  if (!existsSync(dir)) {
+    mkdirSync(dir, { recursive: true });
+  }
+  return dir;
+}
+function getSessionPath(id) {
+  return join(getSessionsDir(), `${id}.json`);
+}
+function generateId() {
+  return `${Date.now()}-${Math.random().toString(36).slice(2, 8)}`;
+}
+function generateTitle(messages) {
+  const firstUserMsg = messages.find((m) => m.role === "user");
+  if (!firstUserMsg) return "New Chat";
+  const content = firstUserMsg.content.trim();
+  if (content.length <= 50) return content;
+  return `${content.slice(0, 47)}...`;
+}
+function listSessions() {
+  const dir = getSessionsDir();
+  const files = readdirSync(dir).filter((f) => f.endsWith(".json"));
+  const sessions = [];
+  for (const file of files) {
+    try {
+      const content = readFileSync(join(dir, file), "utf-8");
+      const session = JSON.parse(content);
+      sessions.push({
+        id: session.id,
+        title: session.title,
+        createdAt: session.createdAt,
+        updatedAt: session.updatedAt,
+        messageCount: session.messages.length,
+        model: session.model,
+        provider: session.provider
+      });
+    } catch {
+    }
+  }
+  return sessions.sort(
+    (a, b) => new Date(b.updatedAt).getTime() - new Date(a.updatedAt).getTime()
+  );
+}
+function loadSession(id) {
+  const path = getSessionPath(id);
+  if (!existsSync(path)) return null;
+  try {
+    const content = readFileSync(path, "utf-8");
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+function saveSession(session) {
+  const path = getSessionPath(session.id);
+  if (session.messages.length > 0 && session.title === "New Chat") {
+    session.title = generateTitle(session.messages);
+  }
+  session.updatedAt = (/* @__PURE__ */ new Date()).toISOString();
+  session.messageCount = session.messages.length;
+  writeFileSync(path, JSON.stringify(session, null, 2));
+  cleanupOldSessions();
+}
+function createSession(model, provider) {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return {
+    id: generateId(),
+    title: "New Chat",
+    createdAt: now,
+    updatedAt: now,
+    messageCount: 0,
+    model,
+    provider,
+    messages: []
+  };
+}
+function deleteSession(id) {
+  const path = getSessionPath(id);
+  if (!existsSync(path)) return false;
+  try {
+    unlinkSync(path);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function cleanupOldSessions() {
+  const sessions = listSessions();
+  if (sessions.length <= MAX_SESSIONS) return;
+  const toDelete = sessions.slice(MAX_SESSIONS);
+  for (const session of toDelete) {
+    deleteSession(session.id);
+  }
+}
+
+// src/chat/components/SessionPicker.tsx
+import { jsx as jsx7, jsxs as jsxs7 } from "react/jsx-runtime";
+function formatDate(isoString) {
+  const date = new Date(isoString);
+  const now = /* @__PURE__ */ new Date();
+  const diffMs = now.getTime() - date.getTime();
+  const diffMins = Math.floor(diffMs / 6e4);
+  const diffHours = Math.floor(diffMs / 36e5);
+  const diffDays = Math.floor(diffMs / 864e5);
+  if (diffMins < 1) return "just now";
+  if (diffMins < 60) return `${diffMins}m ago`;
+  if (diffHours < 24) return `${diffHours}h ago`;
+  if (diffDays < 7) return `${diffDays}d ago`;
+  return date.toLocaleDateString("en-US", { month: "short", day: "numeric" });
+}
+var SessionRow = memo7(function SessionRow2({
+  isNew,
+  session,
+  isSelected,
+  rowWidth,
+  titleWidth,
+  index,
+  accent,
+  onHover,
+  onClick
+}) {
+  const rowRef = useRef6(null);
+  useOnMouseMove4(rowRef, () => {
+    onHover(index);
+  });
+  useOnClick5(rowRef, () => {
+    onClick(index);
+  });
+  if (isNew) {
+    return /* @__PURE__ */ jsx7(
+      Box7,
+      {
+        ref: rowRef,
+        backgroundColor: isSelected ? accent : void 0,
+        width: rowWidth,
+        paddingX: 1,
+        children: /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "white" : "green", bold: isSelected, children: [
+          isSelected ? " > " : "   ",
+          "+ New Chat"
+        ] })
+      }
+    );
+  }
+  if (!session) return null;
+  const title = session.title.length > titleWidth ? `${session.title.slice(0, titleWidth - 3)}...` : session.title.padEnd(titleWidth);
+  return /* @__PURE__ */ jsxs7(
+    Box7,
+    {
+      ref: rowRef,
+      backgroundColor: isSelected ? accent : void 0,
+      width: rowWidth,
+      paddingX: 1,
+      children: [
+        /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "white" : void 0, bold: isSelected, children: [
+          isSelected ? " > " : "   ",
+          title
+        ] }),
+        /* @__PURE__ */ jsxs7(Text7, { color: isSelected ? "white" : void 0, dimColor: !isSelected, children: [
+          " ",
+          session.messageCount,
+          " msgs | ",
+          formatDate(session.updatedAt)
+        ] })
+      ]
+    }
+  );
+});
+function SessionPicker({ onSelect, onClose }) {
+  const { stdout } = useStdout2();
+  const width = stdout?.columns ?? 80;
+  const height = stdout?.rows ?? 24;
+  const [sessions, setSessions] = useState5(() => listSessions());
+  const [selectedIndex, setSelectedIndex] = useState5(0);
+  const totalItems = sessions.length + 1;
+  const handleSelect = (index) => {
+    if (index === 0) {
+      onSelect(null);
+    } else {
+      const session = sessions[index - 1];
+      if (session) {
+        onSelect(session.id);
+      }
+    }
+  };
+  const handleHover = (index) => {
+    setSelectedIndex(index);
+  };
+  const handleClick = (index) => {
+    handleSelect(index);
+  };
+  useInput5((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      handleSelect(selectedIndex);
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((i) => Math.min(totalItems - 1, i + 1));
+    }
+    if (key.ctrl && input === "d") {
+      if (selectedIndex > 0) {
+        const session = sessions[selectedIndex - 1];
+        if (session) {
+          deleteSession(session.id);
+          setSessions(listSessions());
+          if (selectedIndex >= sessions.length) {
+            setSelectedIndex(Math.max(0, sessions.length - 1));
+          }
+        }
+      }
+    }
+  });
+  const listHeight = height - 8;
+  const visibleCount = Math.max(1, listHeight);
+  let startIndex = 0;
+  if (selectedIndex >= visibleCount) {
+    startIndex = selectedIndex - visibleCount + 1;
+  }
+  const allItems = [
+    { type: "new" },
+    ...sessions.map((session) => ({ type: "session", session }))
+  ];
+  const visibleItems = allItems.slice(startIndex, startIndex + visibleCount);
+  const theme = useTheme();
+  const rowWidth = Math.min(76, width - 6);
+  const titleWidth = Math.min(40, width - 30);
+  return /* @__PURE__ */ jsx7(
+    Box7,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      justifyContent: "center",
+      alignItems: "center",
+      backgroundColor: theme.background,
+      children: /* @__PURE__ */ jsxs7(
+        Box7,
+        {
+          flexDirection: "column",
+          width: Math.min(80, width - 4),
+          borderStyle: "double",
+          borderColor: theme.accent,
+          children: [
+            /* @__PURE__ */ jsxs7(Box7, { paddingX: 2, paddingY: 1, justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsx7(Text7, { bold: true, color: theme.accent, children: "Chat Sessions" }),
+              /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "Esc: close | Enter: select | Ctrl+D: delete" })
+            ] }),
+            /* @__PURE__ */ jsx7(Box7, { paddingX: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "\u2500".repeat(Math.min(76, width - 8)) }) }),
+            /* @__PURE__ */ jsxs7(Box7, { flexDirection: "column", paddingX: 1, paddingY: 1, children: [
+              visibleItems.map((item, i) => {
+                const actualIndex = startIndex + i;
+                const isSelected = actualIndex === selectedIndex;
+                if (item.type === "new") {
+                  return /* @__PURE__ */ jsx7(
+                    SessionRow,
+                    {
+                      isNew: true,
+                      isSelected,
+                      rowWidth,
+                      titleWidth,
+                      index: actualIndex,
+                      accent: theme.accent,
+                      onHover: handleHover,
+                      onClick: handleClick
+                    },
+                    "new-chat"
+                  );
+                }
+                return /* @__PURE__ */ jsx7(
+                  SessionRow,
+                  {
+                    session: item.session,
+                    isSelected,
+                    rowWidth,
+                    titleWidth,
+                    index: actualIndex,
+                    accent: theme.accent,
+                    onHover: handleHover,
+                    onClick: handleClick
+                  },
+                  item.session.id
+                );
+              }),
+              sessions.length === 0 && /* @__PURE__ */ jsx7(Box7, { paddingY: 1, children: /* @__PURE__ */ jsx7(Text7, { dimColor: true, children: "No previous sessions" }) })
+            ] }),
+            totalItems > visibleCount && /* @__PURE__ */ jsx7(Box7, { paddingX: 2, paddingBottom: 1, children: /* @__PURE__ */ jsxs7(Text7, { dimColor: true, children: [
+              "Showing ",
+              startIndex + 1,
+              "-",
+              Math.min(startIndex + visibleCount, totalItems),
+              " of ",
+              totalItems
+            ] }) })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/chat/components/ThemePicker.tsx
+import { useOnClick as useOnClick6, useOnMouseMove as useOnMouseMove5, useOnWheel as useOnWheel2 } from "@ink-tools/ink-mouse";
+import { Box as Box8, Text as Text8, useInput as useInput6, useStdout as useStdout3 } from "ink";
+import { memo as memo8, useRef as useRef7, useState as useState6 } from "react";
+import { jsx as jsx8, jsxs as jsxs8 } from "react/jsx-runtime";
+var MAX_VISIBLE_THEMES = 12;
+var ThemeRow = memo8(function ThemeRow2({
+  theme,
+  isSelected,
+  isCurrent,
+  rowWidth,
+  selectedTheme,
+  onHover,
+  onClick
+}) {
+  const rowRef = useRef7(null);
+  useOnMouseMove5(rowRef, onHover);
+  useOnClick6(rowRef, onClick);
+  return /* @__PURE__ */ jsx8(
+    Box8,
+    {
+      ref: rowRef,
+      backgroundColor: isSelected ? selectedTheme.accent : void 0,
+      width: rowWidth,
+      paddingX: 1,
+      children: /* @__PURE__ */ jsxs8(Text8, { color: isSelected ? "white" : void 0, bold: isSelected, children: [
+        isCurrent && !isSelected && /* @__PURE__ */ jsx8(Text8, { color: selectedTheme.accent, children: "\u25CF " }),
+        isCurrent && isSelected && /* @__PURE__ */ jsx8(Text8, { color: "white", children: "\u25CF " }),
+        !isCurrent && "  ",
+        theme.displayName
+      ] })
+    }
+  );
+});
+function ThemePicker({
+  currentTheme,
+  onSelect,
+  onClose
+}) {
+  const { stdout } = useStdout3();
+  const width = stdout?.columns ?? 80;
+  const height = stdout?.rows ?? 24;
+  const listRef = useRef7(null);
+  const currentIndex = THEMES.findIndex((t) => t.name === currentTheme);
+  const [selectedIndex, setSelectedIndex] = useState6(
+    currentIndex >= 0 ? currentIndex : 0
+  );
+  const visibleCount = Math.min(MAX_VISIBLE_THEMES, height - 10);
+  const handleHover = (actualIndex) => {
+    setSelectedIndex(actualIndex);
+  };
+  const handleClick = (actualIndex) => {
+    const selected = THEMES[actualIndex];
+    if (selected) {
+      onSelect(selected.name);
+    }
+  };
+  useInput6((input, key) => {
+    if (key.escape) {
+      onClose();
+      return;
+    }
+    if (key.return) {
+      const selected = THEMES[selectedIndex];
+      if (selected) {
+        onSelect(selected.name);
+      }
+      return;
+    }
+    if (key.upArrow || input === "k") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    }
+    if (key.downArrow || input === "j") {
+      setSelectedIndex((i) => Math.min(THEMES.length - 1, i + 1));
+    }
+    if (key.pageUp) {
+      setSelectedIndex((i) => Math.max(0, i - visibleCount));
+    }
+    if (key.pageDown) {
+      setSelectedIndex((i) => Math.min(THEMES.length - 1, i + visibleCount));
+    }
+  });
+  useOnWheel2(listRef, (event) => {
+    if (event.button === "wheel-up") {
+      setSelectedIndex((i) => Math.max(0, i - 1));
+    } else if (event.button === "wheel-down") {
+      setSelectedIndex((i) => Math.min(THEMES.length - 1, i + 1));
+    }
+  });
+  let startIndex = 0;
+  if (selectedIndex >= visibleCount) {
+    startIndex = Math.min(
+      selectedIndex - Math.floor(visibleCount / 2),
+      THEMES.length - visibleCount
+    );
+  }
+  startIndex = Math.max(0, startIndex);
+  const visibleThemes = THEMES.slice(startIndex, startIndex + visibleCount);
+  const selectedTheme = THEMES[selectedIndex] ?? THEMES[0];
+  const rowWidth = Math.min(60, width - 8);
+  return /* @__PURE__ */ jsx8(
+    Box8,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      justifyContent: "center",
+      alignItems: "center",
+      backgroundColor: selectedTheme.background,
+      children: /* @__PURE__ */ jsxs8(
+        Box8,
+        {
+          flexDirection: "column",
+          width: Math.min(64, width - 4),
+          borderStyle: "round",
+          borderColor: selectedTheme.accent,
+          children: [
+            /* @__PURE__ */ jsxs8(Box8, { paddingX: 2, paddingTop: 1, justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsx8(Text8, { bold: true, color: selectedTheme.textPrimary, children: "Themes" }),
+              /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "esc" })
+            ] }),
+            /* @__PURE__ */ jsx8(Box8, { paddingX: 1, children: /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "\u2500".repeat(Math.min(60, width - 8)) }) }),
+            /* @__PURE__ */ jsx8(Box8, { ref: listRef, flexDirection: "column", paddingY: 1, children: visibleThemes.map((theme, i) => {
+              const actualIndex = startIndex + i;
+              return /* @__PURE__ */ jsx8(
+                ThemeRow,
+                {
+                  theme,
+                  isSelected: actualIndex === selectedIndex,
+                  isCurrent: theme.name === currentTheme,
+                  rowWidth,
+                  selectedTheme,
+                  onHover: () => handleHover(actualIndex),
+                  onClick: () => handleClick(actualIndex)
+                },
+                theme.name
+              );
+            }) }),
+            /* @__PURE__ */ jsxs8(Box8, { paddingX: 2, paddingBottom: 1, justifyContent: "space-between", children: [
+              /* @__PURE__ */ jsx8(Text8, { dimColor: true, children: "j/k or arrows to navigate" }),
+              THEMES.length > visibleCount && /* @__PURE__ */ jsxs8(Text8, { dimColor: true, children: [
+                startIndex + 1,
+                "-",
+                Math.min(startIndex + visibleCount, THEMES.length),
+                "/",
+                THEMES.length
+              ] })
+            ] })
+          ]
+        }
+      )
+    }
+  );
+}
+
+// src/chat/components/WelcomeScreen.tsx
+import { Box as Box10, Text as Text10 } from "ink";
+import { memo as memo10 } from "react";
+
+// src/chat/components/CatIcon.tsx
+import { Box as Box9, Text as Text9 } from "ink";
+import { memo as memo9, useMemo as useMemo4 } from "react";
+import { jsx as jsx9 } from "react/jsx-runtime";
+var CAT_LINES = [
+  "  \u2588\u2588      \u2588\u2588  ",
+  " \u2588\u2588\u2591\u2591\u2588\u2588\u2588\u2588\u2591\u2591\u2588\u2588 ",
+  "\u2588\u2588\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2591\u2588\u2588",
+  "\u2588\u2588\u2591\u2593\u2591\u2591\u2591\u2591\u2591\u2591\u2593\u2591\u2588\u2588",
+  "\u2588\u2588\u2591\u2591\u2591\u2592\u2592\u2592\u2592\u2591\u2591\u2591\u2588\u2588",
+  "\u2588\u2588\u2591\u2591\u2592\u2592\u2593\u2593\u2592\u2592\u2591\u2591\u2588\u2588",
+  " \u2588\u2588\u2591\u2592\u2592\u2592\u2592\u2592\u2592\u2591\u2588\u2588 ",
+  "  \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2588  "
+];
+var CatIcon = memo9(function CatIcon2() {
+  const theme = useTheme();
+  const colors = useMemo4(
+    () => ({
+      "\u2588": "black",
+      "\u2591": theme.accent,
+      "\u2593": "#33221fff",
+      "\u2592": "#fbfaf7ff"
+    }),
+    [theme.accent]
+  );
+  return /* @__PURE__ */ jsx9(Box9, { flexDirection: "column", alignItems: "center", children: CAT_LINES.map((line, i) => (
+    // biome-ignore lint/suspicious/noArrayIndexKey: Static ASCII art
+    /* @__PURE__ */ jsx9(Text9, { children: line.split("").map((char, j) => {
+      const color = colors[char];
+      if (color) {
+        return (
+          // biome-ignore lint/suspicious/noArrayIndexKey: Static char
+          /* @__PURE__ */ jsx9(Text9, { color, children: "\u2588" }, `char-${i}-${j}`)
+        );
+      }
+      return /* @__PURE__ */ jsx9(Text9, { children: " " }, `char-${i}-${j}`);
+    }) }, `line-${i}`)
+  )) });
+});
+
+// src/chat/components/WelcomeScreen.tsx
+import { jsx as jsx10, jsxs as jsxs9 } from "react/jsx-runtime";
+var BASHIO_ASCII = `
+\u2588\u2588\u2588\u2588\u2588\u2588\u2557  \u2588\u2588\u2588\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2557  \u2588\u2588\u2557\u2588\u2588\u2557 \u2588\u2588\u2588\u2588\u2588\u2588\u2557 
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2550\u2550\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2550\u2588\u2588\u2557
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2557\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551
+\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2557\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u255A\u2550\u2550\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2554\u2550\u2550\u2588\u2588\u2551\u2588\u2588\u2551\u2588\u2588\u2551   \u2588\u2588\u2551
+\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2588\u2588\u2588\u2588\u2588\u2551\u2588\u2588\u2551  \u2588\u2588\u2551\u2588\u2588\u2551\u255A\u2588\u2588\u2588\u2588\u2588\u2588\u2554\u255D
+\u255A\u2550\u2550\u2550\u2550\u2550\u255D \u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u2550\u2550\u2550\u2550\u2550\u255D\u255A\u2550\u255D  \u255A\u2550\u255D\u255A\u2550\u255D \u255A\u2550\u2550\u2550\u2550\u2550\u255D 
+`.trim();
+var WelcomeScreen = memo10(function WelcomeScreen2({
+  width,
+  height,
+  children
+}) {
+  const lines = BASHIO_ASCII.split("\n");
+  const theme = useTheme();
+  return /* @__PURE__ */ jsx10(
+    Box10,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      justifyContent: "center",
+      alignItems: "center",
+      backgroundColor: theme.background,
+      children: /* @__PURE__ */ jsxs9(
+        Box10,
+        {
+          flexDirection: "column",
+          alignItems: "center",
+          backgroundColor: theme.background,
+          children: [
+            /* @__PURE__ */ jsx10(CatIcon, {}),
+            /* @__PURE__ */ jsx10(Box10, { paddingTop: 1, backgroundColor: theme.background }),
+            lines.map((line, i) => (
+              // biome-ignore lint/suspicious/noArrayIndexKey: Static ASCII art lines
+              /* @__PURE__ */ jsx10(Text10, { color: theme.textPrimary, bold: true, children: line }, `ascii-${i}`)
+            )),
+            children && /* @__PURE__ */ jsx10(Box10, { paddingTop: 2, backgroundColor: theme.background, children })
+          ]
+        }
+      )
+    }
+  );
+});
+
+// src/chat/utils/syncOutput.ts
+import { Writable } from "stream";
+var SYNC_START = "\x1B[?2026h";
+var SYNC_END = "\x1B[?2026l";
+function createSyncOutputStream(stdout) {
+  let buffer = "";
+  let flushTimeout = null;
+  const FLUSH_DELAY = 4;
+  const flush = () => {
+    if (buffer.length > 0) {
+      stdout.write(SYNC_START + buffer + SYNC_END);
+      buffer = "";
+    }
+    flushTimeout = null;
+  };
+  const stream = new Writable({
+    write(chunk, _encoding, callback) {
+      const str = typeof chunk === "string" ? chunk : chunk.toString("utf8");
+      buffer += str;
+      if (!flushTimeout) {
+        flushTimeout = setTimeout(flush, FLUSH_DELAY);
+      }
+      callback();
+    },
+    final(callback) {
+      if (flushTimeout) {
+        clearTimeout(flushTimeout);
+        flushTimeout = null;
+      }
+      flush();
+      callback();
+    }
+  });
+  Object.defineProperty(stream, "columns", {
+    get: () => stdout.columns
+  });
+  Object.defineProperty(stream, "rows", {
+    get: () => stdout.rows
+  });
+  Object.defineProperty(stream, "isTTY", {
+    get: () => stdout.isTTY
+  });
+  stdout.on("resize", () => {
+    stream.emit("resize");
+  });
+  const proxy = Object.create(
+    stdout,
+    Object.getOwnPropertyDescriptors(stream)
+  );
+  proxy._flushSyncOutput = flush;
+  return proxy;
+}
+
+// src/chat/App.tsx
+import { jsx as jsx11, jsxs as jsxs10 } from "react/jsx-runtime";
+function ChatApp() {
+  const { exit } = useApp();
+  const { stdout } = useStdout4();
+  const [height, setHeight] = useState7(stdout?.rows ?? 24);
+  const [width, setWidth] = useState7(stdout?.columns ?? 80);
+  const messageListRef = useRef8(null);
+  const slashModeRef = useRef8(false);
+  const [config, setConfig] = useState7(null);
+  const [provider, setProvider] = useState7(null);
+  const [currentSession, setCurrentSession] = useState7(null);
+  const [state, setState] = useState7({
+    messages: [],
+    isLoading: false,
+    currentResponse: "",
+    showModelSwitcher: false,
+    showSessionPicker: false,
+    showThemePicker: false,
+    error: null
+  });
+  useEffect2(() => {
+    const handleResize = () => {
+      if (stdout) {
+        setHeight(stdout.rows);
+        setWidth(stdout.columns);
+      }
+    };
+    stdout?.on("resize", handleResize);
+    return () => {
+      stdout?.off("resize", handleResize);
+    };
+  }, [stdout]);
+  useEffect2(() => {
+    const loadedConfig = loadConfig();
+    if (loadedConfig) {
+      setConfig(loadedConfig);
+      setProvider(createProvider(loadedConfig));
+      const activeProvider2 = loadedConfig.activeProvider;
+      const model = loadedConfig.providers[activeProvider2]?.model ?? "unknown";
+      const session = createSession(model, activeProvider2);
+      setCurrentSession(session);
+    } else {
+      exit();
+    }
+  }, [exit]);
+  const messagesLength = state.messages.length;
+  const isLoading = state.isLoading;
+  useEffect2(() => {
+    if (currentSession && messagesLength > 0 && !isLoading) {
+      const updatedSession = {
+        ...currentSession,
+        messages: state.messages,
+        messageCount: messagesLength
+      };
+      saveSession(updatedSession);
+      setCurrentSession(updatedSession);
+    }
+  }, [messagesLength, isLoading]);
+  const noPickerOpen = !state.showModelSwitcher && !state.showSessionPicker && !state.showThemePicker;
+  const handleGlobalInput = useCallback2(
+    (input, key) => {
+      if (key.ctrl && input === "c") {
+        exit();
+      }
+      if (!slashModeRef.current && noPickerOpen) {
+        if (key.ctrl && input === "m" || key.ctrl && input === "p") {
+          setState((s) => ({ ...s, showModelSwitcher: true }));
+        }
+        if (key.ctrl && input === "o") {
+          setState((s) => ({ ...s, showSessionPicker: true }));
+        }
+        if (key.ctrl && input === "t") {
+          setState((s) => ({ ...s, showThemePicker: true }));
+        }
+      }
+      if (key.escape) {
+        if (state.showModelSwitcher) {
+          setState((s) => ({ ...s, showModelSwitcher: false }));
+        }
+        if (state.showSessionPicker) {
+          setState((s) => ({ ...s, showSessionPicker: false }));
+        }
+        if (state.showThemePicker) {
+          setState((s) => ({ ...s, showThemePicker: false }));
+        }
+      }
+    },
+    [
+      exit,
+      noPickerOpen,
+      state.showModelSwitcher,
+      state.showSessionPicker,
+      state.showThemePicker
+    ]
+  );
+  useInput7(handleGlobalInput);
+  const handleSubmit = useCallback2(
+    async (message) => {
+      if (!provider || !message.trim()) return;
+      const userMessage = {
+        role: "user",
+        content: message.trim()
+      };
+      let messagesWithUser = [];
+      setState((s) => {
+        if (s.isLoading) return s;
+        messagesWithUser = [...s.messages, userMessage];
+        return {
+          ...s,
+          messages: messagesWithUser,
+          isLoading: true,
+          currentResponse: "",
+          error: null
+        };
+      });
+      if (messagesWithUser.length === 0) return;
+      try {
+        if (provider.streamChat) {
+          await provider.streamChat(messagesWithUser, (chunk) => {
+            setState((s) => ({
+              ...s,
+              currentResponse: s.currentResponse + chunk
+            }));
+          });
+          setState((s) => ({
+            ...s,
+            messages: [
+              ...s.messages,
+              { role: "assistant", content: s.currentResponse }
+            ],
+            isLoading: false,
+            currentResponse: ""
+          }));
+        } else {
+          setState((s) => ({
+            ...s,
+            messages: [
+              ...s.messages,
+              {
+                role: "assistant",
+                content: "Streaming not supported for this provider."
+              }
+            ],
+            isLoading: false
+          }));
+        }
+      } catch (err) {
+        setState((s) => ({
+          ...s,
+          isLoading: false,
+          error: err instanceof Error ? err.message : "Unknown error"
+        }));
+      }
+    },
+    [provider]
+  );
+  const handleModelSelect = useCallback2(
+    (providerName, model) => {
+      if (!config) return;
+      const newConfig = { ...config, activeProvider: providerName };
+      const providerSettings = newConfig.providers[providerName];
+      if (providerSettings) {
+        providerSettings.model = model;
+      }
+      setConfig(newConfig);
+      setProvider(createProvider(newConfig));
+      setState((s) => ({ ...s, showModelSwitcher: false }));
+      if (currentSession) {
+        setCurrentSession({
+          ...currentSession,
+          model,
+          provider: providerName
+        });
+      }
+    },
+    [config, currentSession]
+  );
+  const handleModelSwitcherClose = useCallback2(() => {
+    setState((s) => ({ ...s, showModelSwitcher: false }));
+  }, []);
+  const handleSessionSelect = useCallback2(
+    (sessionId) => {
+      if (!config) return;
+      if (sessionId === null) {
+        const activeProvider2 = config.activeProvider;
+        const model = config.providers[activeProvider2]?.model ?? "unknown";
+        const session = createSession(model, activeProvider2);
+        setCurrentSession(session);
+        setState((s) => ({
+          ...s,
+          messages: [],
+          showSessionPicker: false,
+          error: null
+        }));
+      } else {
+        const session = loadSession(sessionId);
+        if (session) {
+          setCurrentSession(session);
+          setState((s) => ({
+            ...s,
+            messages: session.messages,
+            showSessionPicker: false,
+            error: null
+          }));
+        }
+      }
+    },
+    [config]
+  );
+  const handleSessionPickerClose = useCallback2(() => {
+    setState((s) => ({ ...s, showSessionPicker: false }));
+  }, []);
+  const handleThemeSelect = useCallback2(
+    (themeName) => {
+      if (!config) return;
+      const cs = config.settings;
+      const newConfig = {
+        ...config,
+        settings: {
+          confirmBeforeExecute: cs?.confirmBeforeExecute ?? true,
+          historyEnabled: cs?.historyEnabled ?? true,
+          historyRetentionDays: cs?.historyRetentionDays ?? 30,
+          historyMaxEntries: cs?.historyMaxEntries ?? 2e3,
+          autoConfirmShortcuts: cs?.autoConfirmShortcuts ?? false,
+          theme: themeName
+        }
+      };
+      setConfig(newConfig);
+      saveConfig(newConfig);
+      setState((s) => ({ ...s, showThemePicker: false }));
+    },
+    [config]
+  );
+  const handleThemePickerClose = useCallback2(() => {
+    setState((s) => ({ ...s, showThemePicker: false }));
+  }, []);
+  const handleSlashCommand = useCallback2(
+    (action) => {
+      switch (action) {
+        case "openModelSwitcher":
+          setState((s) => ({ ...s, showModelSwitcher: true }));
+          break;
+        case "openSessionPicker":
+          setState((s) => ({ ...s, showSessionPicker: true }));
+          break;
+        case "openThemePicker":
+          setState((s) => ({ ...s, showThemePicker: true }));
+          break;
+        case "newSession":
+          handleSessionSelect(null);
+          break;
+        case "clearChat":
+          setState((s) => ({ ...s, messages: [], error: null }));
+          if (currentSession) {
+            const clearedSession = {
+              ...currentSession,
+              messages: [],
+              messageCount: 0
+            };
+            saveSession(clearedSession);
+            setCurrentSession(clearedSession);
+          }
+          break;
+        case "exitChat":
+          exit();
+          break;
+      }
+    },
+    [handleSessionSelect, currentSession, exit]
+  );
+  const currentThemeName = config?.settings?.theme ?? "bashio";
+  const theme = useMemo5(
+    () => getThemeByName(currentThemeName),
+    [currentThemeName]
+  );
+  if (!config || !provider) {
+    return /* @__PURE__ */ jsx11(
+      Box11,
+      {
+        width,
+        height,
+        justifyContent: "center",
+        alignItems: "center",
+        children: /* @__PURE__ */ jsx11(Text11, { children: "Loading..." })
+      }
+    );
+  }
+  if (state.showThemePicker) {
+    return /* @__PURE__ */ jsx11(
+      ThemePicker,
+      {
+        currentTheme: currentThemeName,
+        onSelect: handleThemeSelect,
+        onClose: handleThemePickerClose
+      }
+    );
+  }
+  if (state.showSessionPicker) {
+    return /* @__PURE__ */ jsx11(ThemeProvider, { value: theme, children: /* @__PURE__ */ jsx11(
+      SessionPicker,
+      {
+        onSelect: handleSessionSelect,
+        onClose: handleSessionPickerClose
+      }
+    ) });
+  }
+  if (state.showModelSwitcher) {
+    return /* @__PURE__ */ jsx11(ThemeProvider, { value: theme, children: /* @__PURE__ */ jsx11(
+      ModelSwitcher,
+      {
+        config,
+        onSelect: handleModelSelect,
+        onClose: handleModelSwitcherClose
+      }
+    ) });
+  }
+  const activeProvider = config.activeProvider;
+  const currentModel = config.providers[activeProvider]?.model ?? "unknown";
+  const isEmptyChat = state.messages.length === 0 && !state.currentResponse;
+  if (isEmptyChat) {
+    return /* @__PURE__ */ jsx11(ThemeProvider, { value: theme, children: /* @__PURE__ */ jsx11(
+      Box11,
+      {
+        flexDirection: "column",
+        width,
+        height,
+        backgroundColor: theme.background,
+        children: /* @__PURE__ */ jsx11(WelcomeScreen, { width, height, children: /* @__PURE__ */ jsx11(
+          InputBox,
+          {
+            onSubmit: handleSubmit,
+            onSlashCommand: handleSlashCommand,
+            slashModeRef,
+            modelName: currentModel,
+            disabled: state.isLoading,
+            width: Math.min(width - 4, 80),
+            placeholder: "Ask anything..."
+          }
+        ) })
+      }
+    ) });
+  }
+  const inputBoxHeight = 6;
+  const sessionHeaderHeight = 4;
+  const messageListHeight = Math.max(
+    5,
+    height - inputBoxHeight - sessionHeaderHeight - 2
+  );
+  return /* @__PURE__ */ jsx11(ThemeProvider, { value: theme, children: /* @__PURE__ */ jsxs10(
+    Box11,
+    {
+      flexDirection: "column",
+      width,
+      height,
+      backgroundColor: theme.background,
+      children: [
+        /* @__PURE__ */ jsx11(Box11, { paddingX: 1, marginTop: 1, children: /* @__PURE__ */ jsx11(
+          SessionHeader,
+          {
+            sessionTitle: currentSession?.title ?? "New Chat",
+            width: width - 2
+          }
+        ) }),
+        /* @__PURE__ */ jsx11(Box11, { flexDirection: "column", height: messageListHeight, children: /* @__PURE__ */ jsx11(
+          MessageList,
+          {
+            ref: messageListRef,
+            messages: state.messages,
+            currentResponse: state.currentResponse,
+            isLoading: state.isLoading,
+            height: messageListHeight,
+            width: width - 2,
+            slashModeRef
+          }
+        ) }),
+        state.error && /* @__PURE__ */ jsx11(Box11, { paddingX: 1, children: /* @__PURE__ */ jsxs10(Text11, { color: "red", children: [
+          "Error: ",
+          state.error
+        ] }) }),
+        /* @__PURE__ */ jsx11(Box11, { paddingX: 1, children: /* @__PURE__ */ jsx11(
+          InputBox,
+          {
+            onSubmit: handleSubmit,
+            onSlashCommand: handleSlashCommand,
+            slashModeRef,
+            modelName: currentModel,
+            disabled: state.isLoading,
+            width: width - 2
+          }
+        ) })
+      ]
+    }
+  ) });
+}
+async function runChat() {
+  if (!configExists()) {
+    const success = await runAuthSetup();
+    if (!success) {
+      return 1;
+    }
+    console.log();
+  }
+  const syncOutput = createSyncOutputStream(process.stdout);
+  process.stdout.write("\x1B[?1049h");
+  process.stdout.write("\x1B[?25l");
+  process.stdout.write("\x1B[2J\x1B[H");
+  const instance = render(
+    /* @__PURE__ */ jsx11(MouseProvider, { children: /* @__PURE__ */ jsx11(ChatApp, {}) }),
+    {
+      exitOnCtrlC: false,
+      stdout: syncOutput
+    }
+  );
+  await instance.waitUntilExit();
+  syncOutput._flushSyncOutput?.();
+  process.stdout.write("\x1B[?25h");
+  process.stdout.write("\x1B[?1049l");
+  return 0;
+}
+export {
+  runChat
+};
+//# sourceMappingURL=App-SRRDMIMW.js.map