archymedes-cli 3.0.0 → 3.2.0

package/dist/editor-screen-jckemg13.mjs

@@ -1,684 +0,0 @@
-import {
-  diffLines,
-  languageOf
-} from "./archymedes-hf7kq83m.mjs";
-import"./archymedes-2emwtckp.mjs";
-import {
-  NO_COLOR_PALETTE,
-  exitTopTermUIApp
-} from "./archymedes-y64yssbc.mjs";
-import {
-  __require
-} from "./archymedes-x67v3n58.mjs";
-
-// packages/archymedes-cli/src/ui/editor-screen.tsx
-import { useEffect, useInput, useRef, useState } from "@termuijs/jsx";
-import { Box, Text } from "@termuijs/widgets";
-
-// packages/archymedes-cli/src/ui/editor.ts
-function initialEditorState(path, content, viewportRows = 20) {
-  const lines = content.split(`
-`);
-  return {
-    path,
-    lines,
-    cursor: { row: 0, col: 0 },
-    mode: "normal",
-    scroll: 0,
-    viewportRows: Math.max(1, viewportRows),
-    dirty: false,
-    history: [],
-    future: [],
-    search: { query: "", typing: false }
-  };
-}
-function editorContent(state) {
-  return state.lines.join(`
-`);
-}
-function clamp(state) {
-  const row = Math.max(0, Math.min(state.lines.length - 1, state.cursor.row));
-  const limit = state.mode === "insert" ? state.lines[row].length : Math.max(0, state.lines[row].length - 1);
-  const col = Math.max(0, Math.min(limit, state.cursor.col));
-  let scroll = state.scroll;
-  if (row < scroll)
-    scroll = row;
-  if (row >= scroll + state.viewportRows)
-    scroll = row - state.viewportRows + 1;
-  scroll = Math.max(0, Math.min(scroll, Math.max(0, state.lines.length - 1)));
-  return { ...state, cursor: { row, col }, scroll };
-}
-function checkpoint(state) {
-  return {
-    ...state,
-    history: [...state.history, { lines: [...state.lines], cursor: { ...state.cursor } }].slice(-200),
-    future: []
-  };
-}
-var WORD = /[A-Za-z0-9_]/;
-function wordForward(line, col) {
-  let index = col;
-  while (index < line.length && WORD.test(line[index]))
-    index += 1;
-  while (index < line.length && !WORD.test(line[index]))
-    index += 1;
-  return index;
-}
-function wordBack(line, col) {
-  let index = Math.max(0, col - 1);
-  while (index > 0 && !WORD.test(line[index]))
-    index -= 1;
-  while (index > 0 && WORD.test(line[index - 1]))
-    index -= 1;
-  return index;
-}
-function keyToEditorAction(key, character, state) {
-  const name = key.name ?? "";
-  const isEnter = name === "return" || name === "enter";
-  const isEscape = name === "escape";
-  if (key.ctrl && name === "s")
-    return { kind: "save" };
-  if (key.ctrl && (name === "q" || name === "c"))
-    return { kind: "quit" };
-  if (state.confirmLeave) {
-    if (character === "y" || character === "Y" || isEnter)
-      return { kind: "save" };
-    if (character === "n" || character === "N")
-      return { kind: "quit" };
-    if (isEscape)
-      return { kind: "cancelLeave" };
-    return { kind: "none" };
-  }
-  if (state.search.typing) {
-    if (isEscape)
-      return { kind: "searchCommit" };
-    if (isEnter)
-      return { kind: "searchNext" };
-    if (name === "backspace")
-      return { kind: "searchBackspace" };
-    if (character && character.length === 1 && character >= " ")
-      return { kind: "searchType", character };
-    return { kind: "none" };
-  }
-  if (state.mode === "insert") {
-    if (isEscape)
-      return { kind: "normal" };
-    if (isEnter)
-      return { kind: "newline" };
-    if (name === "backspace")
-      return { kind: "backspace" };
-    if (name === "up")
-      return { kind: "move", rows: -1 };
-    if (name === "down")
-      return { kind: "move", rows: 1 };
-    if (name === "left")
-      return { kind: "move", cols: -1 };
-    if (name === "right")
-      return { kind: "move", cols: 1 };
-    if (name === "tab")
-      return { kind: "type", character: "  " };
-    if (character && character.length === 1 && character >= " ")
-      return { kind: "type", character };
-    return { kind: "none" };
-  }
-  if (state.pending === "d")
-    return name === "d" || character === "d" ? { kind: "deleteLine" } : { kind: "normal" };
-  if (state.pending === "g")
-    return name === "g" || character === "g" ? { kind: "jump", to: "fileStart" } : { kind: "normal" };
-  if (isEscape)
-    return { kind: "leave" };
-  if (name === "up" || character === "k")
-    return { kind: "move", rows: -1 };
-  if (name === "down" || character === "j")
-    return { kind: "move", rows: 1 };
-  if (name === "left" || character === "h")
-    return { kind: "move", cols: -1 };
-  if (name === "right" || character === "l")
-    return { kind: "move", cols: 1 };
-  if (name === "pageup")
-    return { kind: "move", rows: -state.viewportRows };
-  if (name === "pagedown")
-    return { kind: "move", rows: state.viewportRows };
-  if (character === "0" || name === "home")
-    return { kind: "jump", to: "lineStart" };
-  if (character === "$" || name === "end")
-    return { kind: "jump", to: "lineEnd" };
-  if (character === "G")
-    return { kind: "jump", to: "fileEnd" };
-  if (character === "w")
-    return { kind: "jump", to: "wordForward" };
-  if (character === "b")
-    return { kind: "jump", to: "wordBack" };
-  if (character === "i")
-    return { kind: "insert" };
-  if (character === "a")
-    return { kind: "insert", at: "after" };
-  if (character === "I")
-    return { kind: "insert", at: "lineStart" };
-  if (character === "A")
-    return { kind: "insert", at: "lineEnd" };
-  if (character === "o")
-    return { kind: "insert", at: "below" };
-  if (character === "O")
-    return { kind: "insert", at: "above" };
-  if (character === "x")
-    return { kind: "deleteChar" };
-  if (character === "u")
-    return { kind: "undo" };
-  if (key.ctrl && name === "r")
-    return { kind: "redo" };
-  if (character === "/")
-    return { kind: "search" };
-  if (character === "n")
-    return { kind: "searchNext" };
-  if (character === "d" || character === "g")
-    return { kind: "pending", key: character };
-  return { kind: "none" };
-}
-function applyEditorAction(state, action) {
-  const plain = (next) => ({ state: clamp({ ...next, pending: undefined }), effect: undefined });
-  const line = state.lines[state.cursor.row] ?? "";
-  switch (action.kind) {
-    case "move":
-      return plain({
-        ...state,
-        message: undefined,
-        cursor: { row: state.cursor.row + (action.rows ?? 0), col: state.cursor.col + (action.cols ?? 0) }
-      });
-    case "jump": {
-      const targets = {
-        lineStart: { row: state.cursor.row, col: 0 },
-        lineEnd: { row: state.cursor.row, col: line.length },
-        fileStart: { row: 0, col: 0 },
-        fileEnd: { row: state.lines.length - 1, col: 0 },
-        wordForward: { row: state.cursor.row, col: wordForward(line, state.cursor.col) },
-        wordBack: { row: state.cursor.row, col: wordBack(line, state.cursor.col) }
-      };
-      return plain({ ...state, message: undefined, cursor: targets[action.to] });
-    }
-    case "insert": {
-      if (action.at === "below" || action.at === "above") {
-        const at = action.at === "below" ? state.cursor.row + 1 : state.cursor.row;
-        const next = checkpoint(state);
-        const lines = [...state.lines];
-        lines.splice(at, 0, "");
-        return plain({ ...next, lines, dirty: true, mode: "insert", cursor: { row: at, col: 0 } });
-      }
-      const col = action.at === "after" ? state.cursor.col + 1 : action.at === "lineStart" ? 0 : action.at === "lineEnd" ? line.length : state.cursor.col;
-      return plain({ ...state, mode: "insert", message: undefined, cursor: { row: state.cursor.row, col } });
-    }
-    case "normal":
-      return plain({ ...state, mode: "normal", message: undefined });
-    case "type": {
-      const next = checkpoint(state);
-      const lines = [...state.lines];
-      lines[state.cursor.row] = line.slice(0, state.cursor.col) + action.character + line.slice(state.cursor.col);
-      return plain({ ...next, lines, dirty: true, cursor: { row: state.cursor.row, col: state.cursor.col + action.character.length } });
-    }
-    case "newline": {
-      const next = checkpoint(state);
-      const lines = [...state.lines];
-      lines.splice(state.cursor.row, 1, line.slice(0, state.cursor.col), line.slice(state.cursor.col));
-      return plain({ ...next, lines, dirty: true, cursor: { row: state.cursor.row + 1, col: 0 } });
-    }
-    case "backspace": {
-      if (state.cursor.col === 0 && state.cursor.row === 0)
-        return plain(state);
-      const next = checkpoint(state);
-      const lines = [...state.lines];
-      if (state.cursor.col === 0) {
-        const previous = lines[state.cursor.row - 1];
-        lines.splice(state.cursor.row - 1, 2, previous + line);
-        return plain({ ...next, lines, dirty: true, cursor: { row: state.cursor.row - 1, col: previous.length } });
-      }
-      lines[state.cursor.row] = line.slice(0, state.cursor.col - 1) + line.slice(state.cursor.col);
-      return plain({ ...next, lines, dirty: true, cursor: { row: state.cursor.row, col: state.cursor.col - 1 } });
-    }
-    case "deleteChar": {
-      if (line.length === 0)
-        return plain(state);
-      const next = checkpoint(state);
-      const lines = [...state.lines];
-      lines[state.cursor.row] = line.slice(0, state.cursor.col) + line.slice(state.cursor.col + 1);
-      return plain({ ...next, lines, dirty: true });
-    }
-    case "deleteLine": {
-      const next = checkpoint(state);
-      const lines = [...state.lines];
-      lines.splice(state.cursor.row, 1);
-      return plain({ ...next, lines: lines.length > 0 ? lines : [""], dirty: true, cursor: { row: state.cursor.row, col: 0 } });
-    }
-    case "undo": {
-      const previous = state.history.at(-1);
-      if (!previous)
-        return plain({ ...state, message: "nothing to undo" });
-      return plain({
-        ...state,
-        lines: previous.lines,
-        cursor: previous.cursor,
-        history: state.history.slice(0, -1),
-        future: [...state.future, { lines: [...state.lines], cursor: { ...state.cursor } }],
-        dirty: true,
-        message: undefined
-      });
-    }
-    case "redo": {
-      const next = state.future.at(-1);
-      if (!next)
-        return plain({ ...state, message: "nothing to redo" });
-      return plain({
-        ...state,
-        lines: next.lines,
-        cursor: next.cursor,
-        future: state.future.slice(0, -1),
-        history: [...state.history, { lines: [...state.lines], cursor: { ...state.cursor } }],
-        dirty: true,
-        message: undefined
-      });
-    }
-    case "save":
-      return { state: clamp({ ...state, dirty: false, message: `saved ${state.path}`, pending: undefined }), effect: { kind: "save" } };
-    case "quit":
-      return { state: { ...state, confirmLeave: false }, effect: { kind: "quit" } };
-    case "leave":
-      if (!state.dirty)
-        return { state, effect: { kind: "quit" } };
-      return { state: { ...state, pending: undefined, confirmLeave: true, message: "Save changes? y yes · n discard · Esc keep editing" }, effect: undefined };
-    case "cancelLeave":
-      return plain({ ...state, confirmLeave: false, message: undefined });
-    case "autosaved":
-      return editorContent(state) === action.content ? plain({ ...state, dirty: false, message: "auto-saved" }) : plain(state);
-    case "search":
-      return plain({ ...state, search: { query: "", typing: true }, message: undefined });
-    case "searchType":
-      return plain({ ...state, search: { ...state.search, query: state.search.query + action.character } });
-    case "searchBackspace":
-      return plain({ ...state, search: { ...state.search, query: state.search.query.slice(0, -1) } });
-    case "searchCommit":
-      return plain({ ...state, search: { ...state.search, typing: false } });
-    case "searchNext": {
-      const query = state.search.query;
-      if (!query)
-        return plain({ ...state, search: { ...state.search, typing: false } });
-      const order = [...state.lines.keys()].map((offset) => (state.cursor.row + offset) % state.lines.length);
-      for (const [index, row] of order.entries()) {
-        const from = index === 0 ? state.cursor.col + 1 : 0;
-        const found = state.lines[row].indexOf(query, from);
-        if (found >= 0) {
-          return plain({ ...state, cursor: { row, col: found }, search: { ...state.search, typing: false }, message: undefined });
-        }
-      }
-      return plain({ ...state, search: { ...state.search, typing: false }, message: `no match for "${query}"` });
-    }
-    case "pending":
-      return { state: { ...state, pending: action.key }, effect: undefined };
-    default:
-      return plain(state);
-  }
-}
-function editorKeyBar(state, columns = Number.POSITIVE_INFINITY) {
-  if (state.search.typing)
-    return `/${state.search.query}   enter next   esc done`;
-  if (state.mode === "insert")
-    return "esc normal   ^S save   ^Q quit";
-  const hints = [
-    { text: "i insert" },
-    { text: "o new line" },
-    { text: "x del" },
-    { text: "dd del line" },
-    { text: "u undo" },
-    { text: "/ find" },
-    { text: "^S save", essential: true },
-    { text: "^Q quit", essential: true },
-    { text: "esc back", essential: true }
-  ];
-  const optional = hints.filter((hint) => !hint.essential);
-  for (let dropped = 0;dropped <= optional.length; dropped += 1) {
-    const keep = new Set(optional.slice(0, optional.length - dropped));
-    const bar = hints.filter((hint) => hint.essential || keep.has(hint)).map((hint) => hint.text).join("   ");
-    if (bar.length <= columns)
-      return bar;
-  }
-  return "^S save   ^Q quit";
-}
-function editorStatus(state) {
-  const position = `${state.cursor.row + 1}:${state.cursor.col + 1}`;
-  return `${state.path}${state.dirty ? " [+]" : ""}   ${state.mode}   ${position}   ${state.lines.length} lines`;
-}
-function visibleEditorLines(state) {
-  return state.lines.slice(state.scroll, state.scroll + state.viewportRows).map((text, offset) => ({ number: state.scroll + offset + 1, text }));
-}
-function composeEditorFrame(state, columns, accent) {
-  const gutter = String(state.lines.length).length;
-  const clip = (text) => text.length <= columns ? text : text.slice(0, Math.max(0, columns - 1));
-  return [
-    { text: clip(editorStatus(state)), bold: true, ...accent ? { color: accent } : {} },
-    ...visibleEditorLines(state).map((entry) => ({
-      text: clip(`${String(entry.number).padStart(gutter, " ")} ${caretInto(entry.text, entry.number - 1 === state.cursor.row ? state.cursor.col : undefined)}`)
-    })),
-    { text: clip(state.message ?? editorKeyBar(state, columns)), dim: true }
-  ];
-}
-function caretInto(text, cursorCol) {
-  if (cursorCol === undefined)
-    return text;
-  const padded = text.length > cursorCol ? text : text.padEnd(cursorCol + 1, " ");
-  return `${padded.slice(0, cursorCol)}█${padded.slice(cursorCol + 1)}`;
-}
-
-// packages/archymedes-cli/src/ui/explain-view.ts
-var PATTERNS = {
-  typescript: {
-    imports: /^\s*import\b.*from\s+["'](.+)["']/,
-    exports: /^\s*export\s+(?:default\s+)?(?:const|function|class|interface|type|enum)\s+([\w$]+)/,
-    functions: /^\s*(?:export\s+)?(?:default\s+)?(?:async\s+)?function\s*\*?\s*([\w$]+)/,
-    classes: /^\s*(?:export\s+)?(?:default\s+)?(?:abstract\s+)?class\s+([\w$]+)/
-  },
-  javascript: {},
-  jsx: {},
-  tsx: {},
-  python: {
-    imports: /^\s*(?:import\s+([\w.]+)|from\s+([\w.]+)\s+import\b)/,
-    functions: /^\s*(?:async\s+)?def\s+([\w]+)/,
-    classes: /^\s*class\s+([\w]+)/
-  },
-  go: {
-    imports: /^\s*import\s+["'](.+)["']/,
-    functions: /^\s*func\s+(?:\([^)]*\)\s*)?([\w]+)/
-  },
-  rust: {
-    imports: /^\s*use\s+([\w:]+)/,
-    functions: /^\s*(?:pub\s+)?(?:async\s+)?fn\s+([\w]+)/,
-    classes: /^\s*(?:pub\s+)?struct\s+([\w]+)/
-  },
-  ruby: {
-    imports: /^\s*require\s+["'](.+)["']/,
-    functions: /^\s*def\s+([\w?!]+)/,
-    classes: /^\s*class\s+([\w:]+)/
-  }
-};
-PATTERNS.javascript = PATTERNS.typescript;
-PATTERNS.jsx = PATTERNS.typescript;
-PATTERNS.tsx = PATTERNS.typescript;
-function structuralFacts(content, path) {
-  const language = languageOf(path);
-  const rules = PATTERNS[language] ?? {};
-  const facts = { imports: [], exports: [], functions: [], classes: [] };
-  const lines = content.split(`
-`);
-  lines.forEach((raw, index) => {
-    for (const key of Object.keys(rules)) {
-      const pattern = rules[key];
-      if (!pattern)
-        continue;
-      const match = pattern.exec(raw);
-      if (!match)
-        continue;
-      const name = match.slice(1).find((group) => group !== undefined);
-      facts[key].push({ line: index + 1, text: name ?? raw.trim() });
-    }
-  });
-  return facts;
-}
-var MAX_LINE_LENGTH = 120;
-var MAGIC_NUMBER = /(?<![\w.])(?!0\b|1\b)\d{2,}(?![\w.])/;
-function annotateLines(content) {
-  const lines = content.split(`
-`);
-  const notes = [];
-  lines.forEach((raw, index) => {
-    const line = index + 1;
-    if (/\b(TODO|FIXME|HACK|XXX)\b/.test(raw)) {
-      notes.push({ line, note: "unfinished work flagged here", severity: "warn" });
-    }
-    if (raw.length > MAX_LINE_LENGTH) {
-      notes.push({ line, note: `long line (${raw.length} chars)`, severity: "info" });
-    }
-    if (MAGIC_NUMBER.test(raw) && !/^\s*(?:\/\/|#|\*)/.test(raw)) {
-      notes.push({ line, note: "unexplained numeric literal", severity: "info" });
-    }
-  });
-  return notes;
-}
-var EXPLAIN_TABS = ["facts", "notes", "diff", "ai"];
-function initialExplainPanelState() {
-  return { open: false, tab: "facts", ai: { status: "idle" } };
-}
-function toggleExplainPanel(state) {
-  return { ...state, open: !state.open };
-}
-function cycleExplainTab(state, step = 1) {
-  const index = EXPLAIN_TABS.indexOf(state.tab);
-  const next = ((index + step) % EXPLAIN_TABS.length + EXPLAIN_TABS.length) % EXPLAIN_TABS.length;
-  return { ...state, tab: EXPLAIN_TABS[next] };
-}
-function withAiExplanation(state, ai) {
-  return { ...state, ai };
-}
-var DEFAULT_EXPLAIN_COLORS = { success: "green", warning: "yellow", error: "red" };
-var TAB_LABELS = { facts: "Structure", notes: "Notes", diff: "Diff", ai: "AI" };
-function tabStrip(active) {
-  const text = EXPLAIN_TABS.map((tab) => tab === active ? `[${TAB_LABELS[tab]}]` : ` ${TAB_LABELS[tab]} `).join(" ");
-  return { text, bold: true };
-}
-function hintRow(active) {
-  const ask = active === "ai" ? "   ? ask" : "";
-  return { text: `[ ] tabs   ^E close${ask}`, dim: true };
-}
-function wrap(text, width) {
-  const words = text.split(/\s+/).filter(Boolean);
-  const rows = [];
-  let line = "";
-  for (const word of words) {
-    const candidate = line ? `${line} ${word}` : word;
-    if (candidate.length > width && line) {
-      rows.push(line);
-      line = word;
-    } else {
-      line = candidate;
-    }
-  }
-  if (line)
-    rows.push(line);
-  return rows.length > 0 ? rows : [""];
-}
-function factsRows(facts, width) {
-  const section = (title, entries) => {
-    if (entries.length === 0)
-      return [];
-    return [
-      { text: title, bold: true },
-      ...entries.slice(0, 40).map((entry) => ({ text: `  ${String(entry.line).padStart(4)}  ${entry.text}`.slice(0, width) })),
-      { text: "" }
-    ];
-  };
-  const rows = [
-    ...section("Imports", facts.imports),
-    ...section("Exports", facts.exports),
-    ...section("Classes", facts.classes),
-    ...section("Functions", facts.functions)
-  ];
-  if (rows.length === 0)
-    return [{ text: "No imports, exports, functions or classes recognised.", dim: true }];
-  return rows.slice(0, -1);
-}
-function notesRows(notes, width, colors) {
-  if (notes.length === 0)
-    return [{ text: "Nothing flagged.", dim: true }];
-  return notes.slice(0, 60).map((entry) => ({
-    text: `${String(entry.line).padStart(4)}  ${entry.note}`.slice(0, width),
-    color: entry.severity === "warn" ? colors.warning : undefined
-  }));
-}
-function diffRows(diff, width, colors) {
-  if (diff.length === 0 || diff.every((line) => line.kind === "context")) {
-    return [{ text: "No changes yet.", dim: true }];
-  }
-  return diff.filter((line) => line.kind !== "context").slice(0, 200).map((line) => ({
-    text: `${line.kind === "add" ? "+" : "-"} ${line.text}`.slice(0, width),
-    color: line.kind === "add" ? colors.success : colors.error
-  }));
-}
-function aiRows(ai, width, colors) {
-  switch (ai.status) {
-    case "idle":
-      return [{ text: "Press ? to ask the model to explain this file.", dim: true }];
-    case "loading":
-      return [{ text: "Thinking…", dim: true }];
-    case "error":
-      return [{ text: `Could not get an explanation: ${ai.message}`, color: colors.error }];
-    case "ready":
-      return ai.text.split(`
-`).flatMap((line) => wrap(line, width)).map((text) => ({ text }));
-  }
-}
-function composeExplainPanel(input, width, height, colors = DEFAULT_EXPLAIN_COLORS) {
-  const body = (() => {
-    switch (input.panel.tab) {
-      case "facts":
-        return factsRows(structuralFacts(input.after, input.path), width);
-      case "notes":
-        return notesRows(annotateLines(input.after), width, colors);
-      case "diff":
-        return diffRows(diffLines(input.before, input.after), width, colors);
-      case "ai":
-        return aiRows(input.panel.ai, width, colors);
-    }
-  })();
-  const rows = [tabStrip(input.panel.tab), hintRow(input.panel.tab), { text: "" }, ...body];
-  const padded = rows.length >= height ? rows.slice(0, height) : [...rows, ...Array.from({ length: height - rows.length }, () => ({ text: "" }))];
-  return padded;
-}
-
-// packages/archymedes-cli/src/ui/editor-screen.tsx
-import { jsxDEV } from "@termuijs/jsx/jsx-dev-runtime";
-var Panel = Box;
-var Line = Text;
-var CHROME_ROWS = 2;
-var MIN_CODE_COLUMNS = 30;
-var MAX_PANEL_COLUMNS = 52;
-function panelWidthFor(columns) {
-  if (columns - MIN_CODE_COLUMNS < 20)
-    return 0;
-  return Math.min(MAX_PANEL_COLUMNS, Math.floor(columns * 0.38), columns - MIN_CODE_COLUMNS);
-}
-function EditorScreen({ columns, rows, path, content, onExit, palette = NO_COLOR_PALETTE, explain, autosave, autosaveDelayMs = 1000 }) {
-  const [state, setState] = useState(() => initialEditorState(path, content, Math.max(1, rows - CHROME_ROWS)));
-  const timer = useRef(undefined);
-  const text = editorContent(state);
-  useEffect(() => {
-    if (!autosave || !state.dirty || state.confirmLeave)
-      return;
-    const pending = text;
-    timer.current = setTimeout(() => {
-      autosave(pending).then(() => setState((current) => applyEditorAction(current, { kind: "autosaved", content: pending }).state), () => setState((current) => ({ ...current, message: "auto-save failed — Ctrl+S to retry" })));
-    }, autosaveDelayMs);
-    return () => {
-      if (timer.current)
-        clearTimeout(timer.current);
-    };
-  }, [text, state.dirty, state.confirmLeave]);
-  const [panel, setPanel] = useState(() => initialExplainPanelState());
-  const panelWidth = panel.open ? panelWidthFor(columns) : 0;
-  const codeWidth = panelWidth > 0 ? columns - panelWidth - 1 : columns;
-  const askAi = (currentContent) => {
-    if (!explain) {
-      setPanel((current) => withAiExplanation(current, { status: "error", message: "no model available in this session" }));
-      return;
-    }
-    setPanel((current) => withAiExplanation(current, { status: "loading" }));
-    explain(currentContent, path).then((text2) => setPanel((current) => withAiExplanation(current, { status: "ready", text: text2 })), (error) => setPanel((current) => withAiExplanation(current, { status: "error", message: error instanceof Error ? error.message : String(error) })));
-  };
-  useInput((input, key) => {
-    if (key?.ctrl && key?.key === "e") {
-      setPanel((current) => toggleExplainPanel(current));
-      return;
-    }
-    if (panel.open && state.mode === "normal" && !state.search.typing) {
-      if (input === "]") {
-        setPanel((current) => cycleExplainTab(current, 1));
-        return;
-      }
-      if (input === "[") {
-        setPanel((current) => cycleExplainTab(current, -1));
-        return;
-      }
-      if (input === "?" && panel.tab === "ai" && panel.ai.status !== "loading") {
-        askAi(editorContent(state));
-        return;
-      }
-    }
-    setState((current) => {
-      const action = keyToEditorAction({ name: key?.key, ctrl: key?.ctrl, shift: key?.shift }, input, current);
-      const { state: next, effect } = applyEditorAction(current, action);
-      if (effect?.kind === "save")
-        onExit(editorContent(next));
-      else if (effect?.kind === "quit")
-        onExit(undefined);
-      return next;
-    });
-  });
-  const frame = composeEditorFrame(state, codeWidth, palette.tokens.accent);
-  const lastRow = frame.length - 1;
-  if (!panel.open && lastRow >= 0 && frame[lastRow].text.length + "   ^E explain".length <= codeWidth) {
-    frame[lastRow] = { ...frame[lastRow], text: `${frame[lastRow].text}   ^E explain` };
-  }
-  const panelRows = panelWidth > 0 ? composeExplainPanel({ path, before: content, after: editorContent(state), panel }, panelWidth - 2, rows, palette.tokens) : [];
-  return /* @__PURE__ */ jsxDEV(Panel, {
-    flexDirection: "row",
-    width: columns,
-    height: rows,
-    children: [
-      /* @__PURE__ */ jsxDEV(Panel, {
-        flexDirection: "column",
-        width: codeWidth,
-        height: rows,
-        children: frame.map((line, index) => /* @__PURE__ */ jsxDEV(Line, {
-          bold: line.bold,
-          dimColor: line.dim,
-          color: line.color,
-          children: line.text
-        }, `row-${index}`, false, undefined, this))
-      }, undefined, false, undefined, this),
-      panelWidth > 0 && /* @__PURE__ */ jsxDEV(Panel, {
-        flexDirection: "column",
-        width: panelWidth,
-        height: rows,
-        children: panelRows.map((line, index) => /* @__PURE__ */ jsxDEV(Line, {
-          bold: line.bold,
-          dimColor: line.dim,
-          color: line.color,
-          children: line.text
-        }, `explain-${index}`, false, undefined, this))
-      }, undefined, false, undefined, this)
-    ]
-  }, undefined, true, undefined, this);
-}
-async function runEditorScreen(options) {
-  const { renderApp } = await import("@termuijs/jsx");
-  return new Promise((resolve) => {
-    let settled = false;
-    const finish = (saved) => {
-      if (settled)
-        return;
-      settled = true;
-      exitTopTermUIApp();
-      resolve(saved);
-    };
-    renderApp(EditorScreen, {
-      columns: options.columns,
-      rows: options.rows,
-      path: options.path,
-      content: options.content,
-      palette: options.palette,
-      explain: options.explain,
-      autosave: options.autosave,
-      onExit: finish,
-      fullscreen: true
-    }).catch(() => finish(undefined));
-  });
-}
-export {
-  runEditorScreen,
-  EditorScreen
-};