@dmrlzz/davecode 0.0.0-stage → 0.3.0

package/dist/ChatApp-FO5SABXB.js

@@ -0,0 +1,893 @@
+import {
+  Spinner
+} from "./chunk-BOLFK3BH.js";
+import {
+  ThemeProvider,
+  useTheme
+} from "./chunk-OXRMGR72.js";
+import {
+  formatTaskTree,
+  summaryLine
+} from "./chunk-23KTE7IK.js";
+import {
+  emptyUsage,
+  renderAccounts
+} from "./chunk-MSLLH5XP.js";
+import {
+  bar,
+  formatDuration,
+  formatTokens,
+  levelStyle,
+  padEnd,
+  percent,
+  visibleWidth
+} from "./chunk-SF5ZEAP4.js";
+import "./chunk-DYQ56FBT.js";
+import "./chunk-VVCXGQMY.js";
+import "./chunk-PIIJ3RSI.js";
+import "./chunk-7XVXEO7U.js";
+import "./chunk-C7FDRA3U.js";
+
+// src/tui/ChatApp.tsx
+import { Box as Box4, Static, useApp, useInput, usePaste, useStdout, useWindowSize } from "ink";
+import { useCallback, useEffect, useReducer, useRef, useState } from "react";
+
+// src/tui/chat-state.ts
+function initialChatState(model) {
+  return {
+    entries: [],
+    conversation: [],
+    model,
+    connection: "connecting",
+    lastFailovers: 0,
+    totalFailovers: 0,
+    tokens: { prompt: 0, completion: 0 },
+    epoch: 0,
+    history: [],
+    nextId: 1
+  };
+}
+function estimateTokens(text) {
+  return Math.ceil(text.length / 4);
+}
+function push(state, kind, text, meta) {
+  const entry = { id: state.nextId, kind, text };
+  if (meta) entry.meta = meta;
+  return { ...state, entries: [...state.entries, entry], nextId: state.nextId + 1 };
+}
+function chatReducer(state, action) {
+  switch (action.type) {
+    case "banner":
+      return push(state, "banner", action.text);
+    case "info":
+      return push(state, "info", action.text);
+    case "error":
+      return push(state, "error", action.text);
+    case "user": {
+      const next = push(state, "user", action.text);
+      const history = state.history[state.history.length - 1] === action.text ? state.history : [...state.history, action.text].slice(-200);
+      return {
+        ...next,
+        history,
+        conversation: [...state.conversation, { role: "user", content: action.text }]
+      };
+    }
+    case "stream-start":
+      return {
+        ...state,
+        streaming: { id: state.nextId, text: "", startedAt: action.now, model: state.model },
+        nextId: state.nextId + 1
+      };
+    case "stream-meta": {
+      if (!state.streaming) return state;
+      const streaming = { ...state.streaming };
+      if (action.accountId) streaming.accountId = action.accountId;
+      if (action.provider) streaming.provider = action.provider;
+      if (action.failovers !== void 0) streaming.failovers = action.failovers;
+      const lastAccount = action.accountId ? {
+        id: action.accountId,
+        ...action.accountLabel ? { label: action.accountLabel } : {},
+        ...action.provider ? { provider: action.provider } : {}
+      } : state.lastAccount;
+      return {
+        ...state,
+        streaming,
+        ...lastAccount ? { lastAccount } : {},
+        ...action.failovers !== void 0 ? {
+          lastFailovers: action.failovers,
+          totalFailovers: state.totalFailovers + action.failovers
+        } : {}
+      };
+    }
+    case "stream-delta":
+      if (!state.streaming) return state;
+      return {
+        ...state,
+        streaming: { ...state.streaming, text: state.streaming.text + action.text }
+      };
+    case "stream-end": {
+      const live = state.streaming;
+      if (!live) return state;
+      const prompt = action.usage?.prompt_tokens ?? estimateTokens(
+        state.conversation.map((m) => typeof m.content === "string" ? m.content : "").join("\n")
+      );
+      const completion = action.usage?.completion_tokens ?? estimateTokens(live.text);
+      const meta = {
+        model: live.model,
+        latencyMs: action.now - live.startedAt,
+        tokens: prompt + completion,
+        ...action.usage ? {} : { estimated: true },
+        ...live.accountId ? { accountId: live.accountId } : {},
+        ...state.lastAccount?.id === live.accountId && state.lastAccount?.label ? { accountLabel: state.lastAccount.label } : {},
+        ...live.provider ? { provider: live.provider } : {},
+        ...live.failovers ? { failovers: live.failovers } : {},
+        ...action.cancelled ? { cancelled: true } : {}
+      };
+      let next = { ...state };
+      delete next.streaming;
+      const answered = live.text.length > 0;
+      if (answered || action.cancelled) next = push(next, "assistant", live.text, meta);
+      if (action.error) next = push(next, "error", action.error);
+      if (answered && !action.cancelled && !action.error) {
+        next.conversation = [...next.conversation, { role: "assistant", content: live.text }];
+      } else if (next.conversation[next.conversation.length - 1]?.role === "user") {
+        next.conversation = next.conversation.slice(0, -1);
+      }
+      if (answered || action.usage) {
+        next.tokens = {
+          prompt: state.tokens.prompt + prompt,
+          completion: state.tokens.completion + completion
+        };
+      }
+      return next;
+    }
+    case "set-model":
+      return { ...state, model: action.model };
+    case "connection":
+      return state.connection === action.connection ? state : { ...state, connection: action.connection };
+    case "quota": {
+      if (state.lastAccount?.id !== action.accountId) return state;
+      const next = { ...state };
+      if (action.utilization === void 0) delete next.quota5h;
+      else next.quota5h = action.utilization;
+      return next;
+    }
+    case "clear": {
+      const next = {
+        ...state,
+        entries: [],
+        conversation: [],
+        epoch: state.epoch + 1
+      };
+      delete next.streaming;
+      return next;
+    }
+    default:
+      return state;
+  }
+}
+
+// src/tui/components/InputBox.tsx
+import { Box, Text } from "ink";
+
+// src/tui/editor.ts
+var emptyEditor = { chars: [], cursor: 0 };
+function fromText(text) {
+  const chars = [...text];
+  return { chars, cursor: chars.length };
+}
+function textOf(state) {
+  return state.chars.join("");
+}
+function normalizeInput(text) {
+  return text.replace(/\r\n?/g, "\n").replace(/\t/g, "  ").replace(/[\u0000-\u0009\u000b-\u001f\u007f]/g, "");
+}
+function insert(state, text) {
+  const add = [...normalizeInput(text)];
+  if (add.length === 0) return state;
+  const chars = [...state.chars.slice(0, state.cursor), ...add, ...state.chars.slice(state.cursor)];
+  return { chars, cursor: state.cursor + add.length };
+}
+function backspace(state) {
+  if (state.cursor === 0) return state;
+  const chars = [...state.chars.slice(0, state.cursor - 1), ...state.chars.slice(state.cursor)];
+  return { chars, cursor: state.cursor - 1 };
+}
+function deleteForward(state) {
+  if (state.cursor >= state.chars.length) return state;
+  const chars = [...state.chars.slice(0, state.cursor), ...state.chars.slice(state.cursor + 1)];
+  return { chars, cursor: state.cursor };
+}
+function left(state) {
+  return { ...state, cursor: Math.max(0, state.cursor - 1) };
+}
+function right(state) {
+  return { ...state, cursor: Math.min(state.chars.length, state.cursor + 1) };
+}
+function position(state) {
+  let line = 0;
+  let column = 0;
+  for (let i = 0; i < state.cursor; i++) {
+    if (state.chars[i] === "\n") {
+      line++;
+      column = 0;
+    } else {
+      column++;
+    }
+  }
+  return { line, column };
+}
+function lines(state) {
+  const out = [[]];
+  for (const ch of state.chars) {
+    if (ch === "\n") out.push([]);
+    else out[out.length - 1].push(ch);
+  }
+  return out;
+}
+function offsetOf(all, line, column) {
+  let offset = 0;
+  for (let i = 0; i < line; i++) offset += all[i].length + 1;
+  return offset + Math.min(column, all[line].length);
+}
+function up(state) {
+  const { line, column } = position(state);
+  if (line === 0) return void 0;
+  return { ...state, cursor: offsetOf(lines(state), line - 1, column) };
+}
+function down(state) {
+  const all = lines(state);
+  const { line, column } = position(state);
+  if (line >= all.length - 1) return void 0;
+  return { ...state, cursor: offsetOf(all, line + 1, column) };
+}
+function lineStart(state) {
+  const { line } = position(state);
+  return { ...state, cursor: offsetOf(lines(state), line, 0) };
+}
+function lineEnd(state) {
+  const all = lines(state);
+  const { line } = position(state);
+  return { ...state, cursor: offsetOf(all, line, all[line].length) };
+}
+function killToLineStart(state) {
+  const start = lineStart(state).cursor;
+  if (start === state.cursor) return state;
+  return {
+    chars: [...state.chars.slice(0, start), ...state.chars.slice(state.cursor)],
+    cursor: start
+  };
+}
+function killToLineEnd(state) {
+  const end = lineEnd(state).cursor;
+  return {
+    chars: [...state.chars.slice(0, state.cursor), ...state.chars.slice(end)],
+    cursor: state.cursor
+  };
+}
+function deleteWordBack(state) {
+  let i = state.cursor;
+  while (i > 0 && /[ \t]/.test(state.chars[i - 1])) i--;
+  while (i > 0 && !/[\s]/.test(state.chars[i - 1])) i--;
+  if (i === state.cursor) return backspace(state);
+  return { chars: [...state.chars.slice(0, i), ...state.chars.slice(state.cursor)], cursor: i };
+}
+function continuesLine(state) {
+  return state.cursor > 0 && state.chars[state.cursor - 1] === "\\";
+}
+function newlineAfterBackslash(state) {
+  return insert(backspace(state), "\n");
+}
+
+// src/tui/components/InputBox.tsx
+import { jsx, jsxs } from "react/jsx-runtime";
+function cursorParts(line, column) {
+  if (column === void 0) return { before: line.join(""), at: "", after: "" };
+  return {
+    before: line.slice(0, column).join(""),
+    at: line[column] ?? " ",
+    after: line.slice(column + 1).join("")
+  };
+}
+function InputBox({
+  editor,
+  width,
+  placeholder,
+  disabled
+}) {
+  const theme = useTheme();
+  const all = lines(editor);
+  const cursor = position(editor);
+  const empty = editor.chars.length === 0;
+  return /* @__PURE__ */ jsx(
+    Box,
+    {
+      borderStyle: theme.unicode ? "round" : "classic",
+      borderDimColor: theme.ink.dim,
+      flexDirection: "column",
+      paddingX: 1,
+      width,
+      children: all.map((line, i) => {
+        const parts = cursorParts(line, !disabled && i === cursor.line ? cursor.column : void 0);
+        return (
+          // biome-ignore lint/suspicious/noArrayIndexKey: lines have no identity beyond position
+          /* @__PURE__ */ jsxs(Box, { children: [
+            /* @__PURE__ */ jsx(Box, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx(Text, { color: i === 0 ? theme.ink.accent : void 0, children: i === 0 ? theme.glyph.prompt : "" }) }),
+            empty && i === 0 ? /* @__PURE__ */ jsxs(Text, { children: [
+              disabled ? null : /* @__PURE__ */ jsx(Text, { inverse: true, children: " " }),
+              /* @__PURE__ */ jsx(Text, { dimColor: theme.ink.dim, children: placeholder })
+            ] }) : /* @__PURE__ */ jsxs(Text, { children: [
+              parts.before,
+              parts.at ? /* @__PURE__ */ jsx(Text, { inverse: true, children: parts.at }) : null,
+              parts.after
+            ] })
+          ] }, i)
+        );
+      })
+    }
+  );
+}
+function SlashHints({ commands, width }) {
+  const theme = useTheme();
+  if (commands.length === 0) return null;
+  const nameWidth = Math.max(...commands.map((c) => c.name.length + (c.args ? c.args.length + 1 : 0))) + 3;
+  return /* @__PURE__ */ jsx(Box, { flexDirection: "column", paddingX: 2, width, children: commands.map((c, i) => /* @__PURE__ */ jsxs(Text, { wrap: "truncate-end", children: [
+    /* @__PURE__ */ jsx(Text, { color: i === 0 ? theme.ink.accent : void 0, children: `/${c.name}${c.args ? ` ${c.args}` : ""}`.padEnd(nameWidth) }),
+    /* @__PURE__ */ jsx(Text, { dimColor: theme.ink.dim, children: c.description })
+  ] }, c.name)) });
+}
+
+// src/tui/components/StatusLine.tsx
+import { Box as Box2, Text as Text2 } from "ink";
+import { jsx as jsx2, jsxs as jsxs2 } from "react/jsx-runtime";
+function statusSegments(theme, state, info, width) {
+  const sep = theme.dim(" \xB7 ");
+  const left2 = [theme.accent(state.model)];
+  if (state.lastAccount) {
+    const name = state.lastAccount.label ?? state.lastAccount.id;
+    left2.push(
+      `${name}${state.lastAccount.provider ? theme.dim(` (${state.lastAccount.provider})`) : ""}`
+    );
+  }
+  const failovers = state.totalFailovers > 0 ? theme.warn(`${state.lastFailovers}/${state.totalFailovers} failovers`) : theme.dim("0 failovers");
+  left2.push(failovers);
+  const arrows = theme.unicode ? ["\u2191", "\u2193"] : ["in", "out"];
+  left2.push(
+    theme.dim(
+      `${formatTokens(state.tokens.prompt)}${arrows[0]} ${formatTokens(state.tokens.completion)}${arrows[1]}`
+    )
+  );
+  if (state.quota5h !== void 0) {
+    left2.push(
+      `${theme.dim("5h")} ${bar(theme, state.quota5h, 6)} ${levelStyle(theme, state.quota5h)(percent(state.quota5h))}`
+    );
+  }
+  const dot = theme.glyph.dot;
+  let right2;
+  if (info.notice) right2 = theme.warn(info.notice);
+  else if (state.connection === "online") {
+    right2 = `${theme.ok(dot)} ${theme.dim(info.inProcess ? `${info.where}` : "connected")}`;
+  } else if (state.connection === "connecting") right2 = theme.dim(`${dot} connecting`);
+  else right2 = theme.error(`${dot} offline`);
+  const priorities = [0, 1, 2, 4, 3];
+  let kept = left2.map((_, i) => i);
+  const render = () => kept.map((i) => left2[i]).join(sep);
+  while (kept.length > 1 && visibleWidth(render()) + visibleWidth(right2) + 2 > width) {
+    const drop = [...priorities].reverse().find((p) => kept.includes(p) && p !== 0);
+    if (drop === void 0) break;
+    kept = kept.filter((i) => i !== drop);
+  }
+  return { left: render(), right: right2 };
+}
+function StatusLine({
+  state,
+  info,
+  width
+}) {
+  const theme = useTheme();
+  const { left: left2, right: right2 } = statusSegments(theme, state, info, width - 2);
+  return /* @__PURE__ */ jsxs2(Box2, { width, justifyContent: "space-between", paddingX: 1, children: [
+    /* @__PURE__ */ jsx2(Text2, { wrap: "truncate-end", children: left2 }),
+    /* @__PURE__ */ jsx2(Text2, { wrap: "truncate-start", children: right2 })
+  ] });
+}
+
+// src/tui/components/Transcript.tsx
+import { Box as Box3, Text as Text3 } from "ink";
+import { jsx as jsx3, jsxs as jsxs3 } from "react/jsx-runtime";
+function metaLine(meta) {
+  const parts = [];
+  if (meta.accountLabel ?? meta.accountId) {
+    parts.push([meta.provider, meta.accountLabel ?? meta.accountId].filter(Boolean).join(" \xB7 "));
+  }
+  if (meta.model) parts.push(meta.model);
+  if (meta.tokens !== void 0)
+    parts.push(`${meta.estimated ? "~" : ""}${formatTokens(meta.tokens)} tok`);
+  if (meta.latencyMs !== void 0) parts.push(`${(meta.latencyMs / 1e3).toFixed(1)}s`);
+  if (meta.failovers) parts.push(`${meta.failovers} failover${meta.failovers === 1 ? "" : "s"}`);
+  if (meta.cancelled) parts.push("cancelled");
+  return parts.join(" \xB7 ");
+}
+function Marker({ color, glyph }) {
+  return /* @__PURE__ */ jsx3(Box3, { width: 2, flexShrink: 0, children: /* @__PURE__ */ jsx3(Text3, { color, children: glyph }) });
+}
+function EntryView({ entry }) {
+  const theme = useTheme();
+  switch (entry.kind) {
+    case "banner":
+      return /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, children: /* @__PURE__ */ jsx3(Text3, { children: entry.text }) });
+    case "user":
+      return /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx3(Marker, { color: theme.ink.accent, glyph: theme.glyph.prompt }),
+        /* @__PURE__ */ jsx3(Text3, { dimColor: theme.ink.dim, children: entry.text })
+      ] });
+    case "assistant":
+      return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom: 1, children: [
+        /* @__PURE__ */ jsxs3(Box3, { children: [
+          /* @__PURE__ */ jsx3(Marker, { color: theme.ink.accent, glyph: theme.glyph.dot }),
+          /* @__PURE__ */ jsx3(Text3, { children: entry.text || (entry.meta?.cancelled ? "(cancelled before any output)" : "") })
+        ] }),
+        entry.meta ? /* @__PURE__ */ jsx3(Box3, { paddingLeft: 2, children: /* @__PURE__ */ jsx3(Text3, { dimColor: theme.ink.dim, children: metaLine(entry.meta) }) }) : null
+      ] });
+    case "error":
+      return /* @__PURE__ */ jsxs3(Box3, { marginBottom: 1, children: [
+        /* @__PURE__ */ jsx3(Marker, { color: theme.ink.error, glyph: theme.glyph.fail }),
+        /* @__PURE__ */ jsx3(Text3, { color: theme.ink.error, children: entry.text })
+      ] });
+    default:
+      return /* @__PURE__ */ jsx3(Box3, { marginBottom: 1, paddingLeft: 2, children: /* @__PURE__ */ jsx3(Text3, { children: entry.text }) });
+  }
+}
+function StreamingView({ streaming, now }) {
+  const theme = useTheme();
+  const seconds = Math.max(0, (now - streaming.startedAt) / 1e3).toFixed(0);
+  return /* @__PURE__ */ jsxs3(Box3, { flexDirection: "column", marginBottom: 1, children: [
+    streaming.text ? /* @__PURE__ */ jsxs3(Box3, { children: [
+      /* @__PURE__ */ jsx3(Marker, { color: theme.ink.accent, glyph: theme.glyph.dot }),
+      /* @__PURE__ */ jsx3(Text3, { children: streaming.text })
+    ] }) : null,
+    /* @__PURE__ */ jsxs3(Box3, { paddingLeft: streaming.text ? 2 : 0, children: [
+      /* @__PURE__ */ jsx3(Spinner, {}),
+      /* @__PURE__ */ jsxs3(Text3, { dimColor: theme.ink.dim, children: [
+        " ",
+        streaming.text ? "streaming" : "thinking",
+        " ",
+        seconds,
+        "s \xB7 esc to cancel"
+      ] })
+    ] })
+  ] });
+}
+
+// src/tui/slash.ts
+var SLASH_COMMANDS = [
+  { name: "model", args: "[id]", description: "show models or switch, e.g. /model davecode/auto" },
+  { name: "route", description: "routes and their failover targets" },
+  { name: "accounts", description: "accounts with 5h quota usage" },
+  { name: "tasks", description: "the project task graph" },
+  { name: "status", description: "gateway health and runner state" },
+  { name: "clear", description: "clear the transcript and start a new conversation" },
+  { name: "help", description: "commands and keyboard shortcuts", aliases: ["?"] },
+  { name: "exit", description: "quit DaveCode", aliases: ["quit", "q"] }
+];
+function parseSlash(input) {
+  const text = input.trim();
+  if (!text.startsWith("/") || text.startsWith("//")) return { kind: "none" };
+  const [head = "", ...rest] = text.slice(1).split(/\s+/);
+  const name = head.toLowerCase();
+  if (!name) return { kind: "unknown", name: "" };
+  const command = SLASH_COMMANDS.find((c) => c.name === name || c.aliases?.includes(name));
+  if (!command) return { kind: "unknown", name };
+  return { kind: "command", command, args: rest.join(" ").trim() };
+}
+function slashSuggestions(input) {
+  if (!input.startsWith("/") || /\s/.test(input)) return [];
+  const prefix = input.slice(1).toLowerCase();
+  return SLASH_COMMANDS.filter(
+    (c) => c.name.startsWith(prefix) || c.aliases?.some((a) => a.startsWith(prefix) && prefix)
+  );
+}
+function completeSlash(input) {
+  const [first] = slashSuggestions(input);
+  if (!first) return void 0;
+  return `/${first.name}${first.args ? " " : ""}`;
+}
+var KEY_HINTS = [
+  ["Enter", "send"],
+  ["Shift+Enter, Ctrl+J or \\ Enter", "new line"],
+  ["\u2191 / \u2193", "move between lines, then through history"],
+  ["Tab", "complete a slash command"],
+  ["Esc", "cancel the response in flight"],
+  ["Ctrl+U / Ctrl+K / Ctrl+W", "delete to line start / line end / previous word"],
+  ["Ctrl+C twice", "exit"]
+];
+
+// src/tui/slash-actions.ts
+function helpText(theme) {
+  const width = Math.max(...SLASH_COMMANDS.map((c) => c.name.length + (c.args?.length ?? 0))) + 4;
+  const commands = SLASH_COMMANDS.map(
+    (c) => `${theme.accent(padEnd(`/${c.name}${c.args ? ` ${c.args}` : ""}`, width))}${theme.dim(c.description)}`
+  );
+  const keyWidth = Math.max(...KEY_HINTS.map(([k]) => k.length)) + 2;
+  const keys = KEY_HINTS.map(([k, v]) => `${padEnd(k, keyWidth)}${theme.dim(v)}`);
+  return [theme.bold("Commands"), ...commands, "", theme.bold("Keys"), ...keys].join("\n");
+}
+async function modelsText(theme, backend, current) {
+  const models = await backend.models();
+  const ids = models.map((m) => m.id).sort((a, b) => {
+    const da = a.startsWith("davecode/") ? 0 : 1;
+    const db = b.startsWith("davecode/") ? 0 : 1;
+    return da - db || a.localeCompare(b);
+  });
+  if (ids.length === 0)
+    return theme.dim("No models yet. Add an account with `davecode accounts add`.");
+  const shown = ids.slice(0, 40);
+  const lines2 = shown.map(
+    (id) => id === current ? `${theme.accent(theme.glyph.dot)} ${theme.accent(id)}` : `  ${id}`
+  );
+  if (ids.length > shown.length) lines2.push(theme.dim(`  \u2026 and ${ids.length - shown.length} more`));
+  lines2.push("", theme.dim("Switch with /model <id>"));
+  return lines2.join("\n");
+}
+async function routesText(theme, backend) {
+  const { defaultRoute, routes } = await backend.routes();
+  if (routes.length === 0) {
+    return [
+      `${theme.dim("No routes configured.")} davecode/${defaultRoute} uses every account with a default model.`,
+      theme.dim("Define routes under routing.routes in ~/.davecode/config.json.")
+    ].join("\n");
+  }
+  const lines2 = [];
+  for (const route of routes) {
+    const mark = route.name === defaultRoute ? theme.dim(" (default)") : "";
+    lines2.push(
+      `${theme.accent(`davecode/${route.name}`)}${mark}${route.description ? theme.dim(`  ${route.description}`) : ""}`
+    );
+    route.targets.forEach((t, i) => {
+      lines2.push(
+        `  ${theme.dim(`${i + 1}.`)} ${t.provider}/${t.model}${t.accountId ? theme.dim(` @${t.accountId}`) : ""}`
+      );
+    });
+  }
+  return lines2.join("\n");
+}
+async function accountsText(theme, backend, columns) {
+  const [accounts, usage] = await Promise.all([backend.accounts(), backend.usage()]);
+  if (accounts.length === 0)
+    return theme.dim("No accounts yet. Add one with `davecode accounts add`.");
+  const byId = new Map(usage.map((u) => [u.accountId, u]));
+  return renderAccounts(
+    theme,
+    accounts.map((account) => ({ account, usage: byId.get(account.id) ?? emptyUsage(account.id) })),
+    columns
+  ).join("\n");
+}
+async function tasksText(theme, backend, columns) {
+  const { project, graph } = await backend.tasks();
+  if (!project)
+    return theme.dim("No project brain is being served. Start DaveCode inside a repository.");
+  if (graph.tasks.length === 0) {
+    return theme.dim(`${project.name}: no tasks yet. Add one with \`davecode tasks add\`.`);
+  }
+  return [
+    `${theme.bold(project.name)}  ${summaryLine(theme, graph)}`,
+    "",
+    ...formatTaskTree(theme, graph, { width: columns })
+  ].join("\n");
+}
+async function statusText(theme, backend) {
+  const health = await backend.health();
+  if (!health) return theme.error(`Gateway at ${backend.url} is not answering.`);
+  const runner = await backend.runner().catch(() => void 0);
+  const flags = Object.entries(health.experimental).filter(([, on]) => on).map(([k]) => k);
+  return [
+    `${theme.ok(theme.glyph.dot)} ${backend.url}${backend.inProcess ? theme.dim(" (in-process)") : ""}  ${theme.dim(`v${health.version} \xB7 up ${formatDuration(health.uptimeSec)}`)}`,
+    `${theme.dim("runner")}       ${runner ? runner.state : "unknown"}${runner?.taskId ? theme.dim(` \xB7 ${runner.taskId}`) : ""}`,
+    `${theme.dim("experimental")} ${flags.length > 0 ? theme.warn(flags.join(", ")) : "none"}`
+  ].join("\n");
+}
+
+// src/tui/ChatApp.tsx
+import { jsx as jsx4, jsxs as jsxs4 } from "react/jsx-runtime";
+var PLACEHOLDER = "Ask anything \xB7 / for commands \xB7 Shift+Enter or Ctrl+J for a new line";
+var EXIT_WINDOW_MS = 2e3;
+function errorText(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function Chat({ backend, model, version, pollMs = 1e4, now = Date.now }) {
+  const theme = useTheme();
+  const { exit } = useApp();
+  const { write } = useStdout();
+  const { columns } = useWindowSize();
+  const width = Math.max(20, columns);
+  const [state, dispatch] = useReducer(chatReducer, model, initialChatState);
+  const [editor, setEditor] = useState(emptyEditor);
+  const [historyIndex, setHistoryIndex] = useState();
+  const [notice, setNotice] = useState();
+  const [clock, setClock] = useState(now());
+  const abortRef = useRef(void 0);
+  const exitArmedAt = useRef(void 0);
+  const labels = useRef(/* @__PURE__ */ new Map());
+  const stateRef = useRef(state);
+  stateRef.current = state;
+  useEffect(() => {
+    const where = backend.inProcess ? `${backend.url} (in-process)` : backend.url;
+    dispatch({
+      type: "banner",
+      text: `${theme.bold(theme.accent("DaveCode"))} ${theme.dim(`v${version}`)}
+${theme.dim(
+        `model ${model} \xB7 gateway ${where} \xB7 /help for commands`
+      )}`
+    });
+    let alive = true;
+    const check = async () => {
+      const health = await backend.health();
+      if (alive) dispatch({ type: "connection", connection: health ? "online" : "offline" });
+    };
+    void check();
+    backend.accounts().then((accounts) => {
+      for (const a of accounts) labels.current.set(a.id, a.label);
+    }).catch(() => {
+    });
+    const timer = setInterval(() => void check(), pollMs);
+    return () => {
+      alive = false;
+      clearInterval(timer);
+      abortRef.current?.abort();
+    };
+  }, [backend, model, pollMs, theme, version]);
+  useEffect(() => {
+    if (!state.streaming) return;
+    const timer = setInterval(() => setClock(now()), 250);
+    return () => clearInterval(timer);
+  }, [state.streaming, now]);
+  useEffect(() => {
+    if (!notice) return;
+    const timer = setTimeout(() => setNotice(void 0), EXIT_WINDOW_MS);
+    return () => clearTimeout(timer);
+  }, [notice]);
+  const refreshQuota = useCallback(
+    async (accountId) => {
+      try {
+        const usage = (await backend.usage()).find((u) => u.accountId === accountId);
+        const window = usage?.windows["5h"];
+        const limited = window && (window.tokenLimit !== void 0 || window.requestLimit !== void 0);
+        dispatch({
+          type: "quota",
+          accountId,
+          utilization: limited ? window.utilization : void 0
+        });
+      } catch {
+      }
+    },
+    [backend]
+  );
+  const send = useCallback(
+    async (text) => {
+      dispatch({ type: "user", text });
+      const conversation = [
+        ...stateRef.current.conversation,
+        { role: "user", content: text }
+      ];
+      const controller = new AbortController();
+      abortRef.current = controller;
+      dispatch({ type: "stream-start", now: now() });
+      let usage;
+      let accountId;
+      try {
+        const { meta, chunks } = await backend.stream(
+          { model: stateRef.current.model, messages: conversation },
+          controller.signal
+        );
+        accountId = meta.accountId;
+        dispatch({
+          type: "stream-meta",
+          failovers: meta.failovers,
+          ...meta.accountId ? { accountId: meta.accountId } : {},
+          ...meta.provider ? { provider: meta.provider } : {},
+          ...meta.accountId && labels.current.has(meta.accountId) ? { accountLabel: labels.current.get(meta.accountId) } : {}
+        });
+        dispatch({ type: "connection", connection: "online" });
+        for await (const chunk of chunks) {
+          if (controller.signal.aborted) break;
+          const delta = chunk.choices[0]?.delta?.content;
+          if (typeof delta === "string" && delta) dispatch({ type: "stream-delta", text: delta });
+          if (chunk.usage) usage = chunk.usage;
+        }
+        dispatch({
+          type: "stream-end",
+          now: now(),
+          ...usage ? { usage } : {},
+          ...controller.signal.aborted ? { cancelled: true } : {}
+        });
+      } catch (err) {
+        if (controller.signal.aborted) {
+          dispatch({ type: "stream-end", now: now(), cancelled: true });
+        } else {
+          const status = err.status;
+          if (status === 0) dispatch({ type: "connection", connection: "offline" });
+          dispatch({ type: "stream-end", now: now(), error: errorText(err) });
+        }
+      } finally {
+        if (abortRef.current === controller) abortRef.current = void 0;
+      }
+      if (accountId) void refreshQuota(accountId);
+    },
+    [backend, now, refreshQuota]
+  );
+  const runSlash = useCallback(
+    async (input) => {
+      const parsed = parseSlash(input);
+      if (parsed.kind === "unknown") {
+        dispatch({
+          type: "error",
+          text: `Unknown command /${parsed.name}. Type /help for the list.`
+        });
+        return;
+      }
+      if (parsed.kind !== "command") return;
+      const { command, args } = parsed;
+      try {
+        switch (command.name) {
+          case "help":
+            dispatch({ type: "info", text: helpText(theme) });
+            break;
+          case "exit":
+            abortRef.current?.abort();
+            exit();
+            break;
+          case "clear":
+            abortRef.current?.abort();
+            write("\x1B[2J\x1B[3J\x1B[H");
+            dispatch({ type: "clear" });
+            break;
+          case "model":
+            if (args) {
+              dispatch({ type: "set-model", model: args });
+              dispatch({ type: "info", text: `Model set to ${theme.accent(args)}` });
+            } else {
+              dispatch({
+                type: "info",
+                text: await modelsText(theme, backend, stateRef.current.model)
+              });
+            }
+            break;
+          case "route":
+            dispatch({ type: "info", text: await routesText(theme, backend) });
+            break;
+          case "accounts": {
+            const accounts = await backend.accounts();
+            for (const a of accounts) labels.current.set(a.id, a.label);
+            dispatch({ type: "info", text: await accountsText(theme, backend, width - 4) });
+            break;
+          }
+          case "tasks":
+            dispatch({ type: "info", text: await tasksText(theme, backend, width - 4) });
+            break;
+          case "status":
+            dispatch({ type: "info", text: await statusText(theme, backend) });
+            break;
+        }
+      } catch (err) {
+        dispatch({ type: "error", text: `/${command.name} failed: ${errorText(err)}` });
+      }
+    },
+    [backend, exit, theme, width, write]
+  );
+  const submit = useCallback(() => {
+    const text = textOf(editor).trim();
+    if (!text) return;
+    if (parseSlash(text).kind !== "none") {
+      setEditor(emptyEditor);
+      setHistoryIndex(void 0);
+      void runSlash(text);
+      return;
+    }
+    if (stateRef.current.streaming) {
+      setNotice("Wait for the reply, or press Esc to cancel it");
+      return;
+    }
+    setEditor(emptyEditor);
+    setHistoryIndex(void 0);
+    void send(text);
+  }, [editor, runSlash, send]);
+  const recall = (direction) => {
+    const { history } = stateRef.current;
+    if (history.length === 0) return;
+    const current = historyIndex ?? history.length;
+    const next = Math.min(history.length, Math.max(0, current + direction));
+    setHistoryIndex(next === history.length ? void 0 : next);
+    setEditor(next === history.length ? emptyEditor : fromText(history[next]));
+  };
+  useInput((input, key) => {
+    if (key.ctrl && input === "c") {
+      const armed = exitArmedAt.current !== void 0 && now() - exitArmedAt.current < EXIT_WINDOW_MS;
+      if (armed) {
+        abortRef.current?.abort();
+        exit();
+        return;
+      }
+      exitArmedAt.current = now();
+      if (stateRef.current.streaming) abortRef.current?.abort();
+      else if (editor.chars.length > 0) setEditor(emptyEditor);
+      setNotice("Press Ctrl+C again to exit");
+      return;
+    }
+    exitArmedAt.current = void 0;
+    if (key.escape) {
+      if (stateRef.current.streaming) abortRef.current?.abort();
+      return;
+    }
+    if (input === "\n" && !key.return || key.ctrl && input === "j") {
+      setEditor((e) => insert(e, "\n"));
+      return;
+    }
+    if (key.return) {
+      if (key.shift || key.meta) setEditor((e) => insert(e, "\n"));
+      else if (continuesLine(editor)) setEditor((e) => newlineAfterBackslash(e));
+      else submit();
+      return;
+    }
+    if (key.tab) {
+      const completed = completeSlash(textOf(editor));
+      if (completed) setEditor(fromText(completed));
+      return;
+    }
+    if (key.upArrow) {
+      const moved = up(editor);
+      if (moved) setEditor(moved);
+      else recall(-1);
+      return;
+    }
+    if (key.downArrow) {
+      const moved = down(editor);
+      if (moved) setEditor(moved);
+      else if (historyIndex !== void 0) recall(1);
+      return;
+    }
+    if (key.leftArrow) return setEditor(left);
+    if (key.rightArrow) return setEditor(right);
+    if (key.home || key.ctrl && input === "a") return setEditor(lineStart);
+    if (key.end || key.ctrl && input === "e") return setEditor(lineEnd);
+    if (key.backspace) return setEditor(backspace);
+    if (key.delete) return setEditor(deleteForward);
+    if (key.ctrl && input === "u") return setEditor(killToLineStart);
+    if (key.ctrl && input === "k") return setEditor(killToLineEnd);
+    if (key.ctrl && input === "w") return setEditor(deleteWordBack);
+    if (key.ctrl && input === "l") {
+      write("\x1B[2J\x1B[H");
+      return;
+    }
+    if (key.ctrl || key.meta || !input) return;
+    setEditor((e) => insert(e, input));
+  });
+  usePaste((text) => {
+    setEditor((e) => insert(e, text));
+  });
+  const suggestions = slashSuggestions(textOf(editor));
+  return /* @__PURE__ */ jsxs4(Box4, { flexDirection: "column", width, children: [
+    /* @__PURE__ */ jsx4(Static, { items: state.entries, children: (entry) => /* @__PURE__ */ jsx4(EntryView, { entry }, entry.id) }, state.epoch),
+    state.streaming ? /* @__PURE__ */ jsx4(StreamingView, { streaming: state.streaming, now: clock }) : null,
+    /* @__PURE__ */ jsx4(InputBox, { editor, width, placeholder: PLACEHOLDER }),
+    /* @__PURE__ */ jsx4(SlashHints, { commands: suggestions, width }),
+    /* @__PURE__ */ jsx4(
+      StatusLine,
+      {
+        state,
+        width,
+        info: {
+          where: backend.inProcess ? `in-process ${new URL(backend.url).port}` : backend.url,
+          inProcess: backend.inProcess,
+          ...notice ? { notice } : {}
+        }
+      }
+    )
+  ] });
+}
+function ChatApp(props) {
+  return /* @__PURE__ */ jsx4(ThemeProvider, { theme: props.theme, children: /* @__PURE__ */ jsx4(Chat, { ...props }) });
+}
+export {
+  ChatApp
+};
+//# sourceMappingURL=ChatApp-FO5SABXB.js.map