archymedes-cli 2.1.0 → 2.3.0

package/dist/guide-screen-mfvwkdhb.mjs

@@ -1,565 +0,0 @@
-import {
-  applyViewport,
-  newViewport,
-  visibleLines
-} from "./archymedes-k1bx08z9.mjs";
-import"./archymedes-44c1mqas.mjs";
-import {
-  joinHorizontal,
-  padToWidth,
-  scrollIndicator,
-  scrollPercent,
-  sliceToWidth,
-  visibleWidth
-} from "./archymedes-dwvn4c51.mjs";
-import {
-  NO_COLOR_PALETTE
-} from "./archymedes-jecyxv5c.mjs";
-import {
-  __require
-} from "./archymedes-x67v3n58.mjs";
-
-// packages/archymedes-cli/src/guide-screen.tsx
-import { useInput, useState } from "@termuijs/jsx";
-import { Box, Text } from "@termuijs/widgets";
-
-// packages/archymedes-cli/src/guide.ts
-var GUIDE_TOPICS = [
-  {
-    id: "start",
-    title: "Getting started",
-    summary: "What Archymedes is, and the first thing to type.",
-    body: [
-      "Archymedes is a coding agent that works in a scrolling terminal transcript. You type what you want in plain language; it reads files, runs commands and edits code, and shows you what it did as it goes.",
-      "Everything it prints stays in your terminal's scrollback, so you can scroll up, select text and pipe a session to a file the way you would with any other command.",
-      "Type a request and press Enter. Slash commands do everything else — press / to see them, or open the searchable list."
-    ],
-    examples: [
-      { input: "fix the failing test in cart.ts", effect: "an ordinary request; Archymedes reads, edits and runs the tests" },
-      { input: "/help", effect: "every command, with one line each" },
-      { input: "/palette", effect: "search commands by name or by what they do" },
-      { input: "/guide", effect: "open this guide as a screen — arrows to move, / to search, q to leave" },
-      { input: "/guide tabs", effect: "print one topic into the transcript, to keep or to copy" },
-      { input: "/exit", effect: "leave; the session is saved and can be resumed" }
-    ],
-    covers: ["/help", "/palette", "/exit", "/keys", "/guide"]
-  },
-  {
-    id: "modes",
-    title: "Permission modes",
-    summary: "How much Archymedes may do without asking.",
-    body: [
-      "Four modes, and you can change them at any time. Plan reads and reasons but cannot write or run commands. Build is the default: edits are proposed and you approve them. Auto applies ordinary workspace edits without asking, while anything sensitive or reaching outside the workspace still stops for you. Defender turns Archymedes into a security reviewer — full tool access to actually scan and fix, but never auto-approved, the same posture as Build.",
-      "Defender also looks outward: when web search is configured it checks current advisories against what the project actually depends on, remembers durable findings in project memory so the next review builds on this one, and closes out with concrete, costed remediation resources fitted to how the project actually hosts and deploys — not a generic checklist.",
-      "/scan runs the deterministic half of defender's own secrets playbook directly — no model turn, no mode switch needed. It is the same pattern-matching scan_secrets uses, worst severity first: a private key or a live cloud credential ahead of a merely credential-shaped variable name.",
-      "The mode is per tab, so one piece of work can be on a short leash while another runs freely."
-    ],
-    examples: [
-      { input: "/plan", effect: "read-only: no writes, no commands" },
-      { input: "/build", effect: "edits ask first (the default)" },
-      { input: "/auto", effect: "ordinary edits apply; sensitive actions still ask" },
-      { input: "/defender", effect: "security review — find and fix real issues; every change still asks" },
-      { input: "/mode", effect: "show which mode you are in" },
-      { input: "/scan", effect: "pattern-based secret scan, worst severity first, no model call" },
-      { input: "/scan src/**", effect: "same scan, limited to files matching the glob" }
-    ],
-    covers: ["/mode", "/plan", "/build", "/auto", "/defender", "/scan"]
-  },
-  {
-    id: "tabs",
-    title: "Tabs: several pieces of work, one at a time",
-    summary: "Each tab keeps its own conversation, model, cost and machine — the tab in front is the one that runs.",
-    body: [
-      "A tab is a separate piece of work with its own conversation, its own running total, its own mode — and its own model and location. One tab can be on a large model against your checkout while another runs a cheaper or open model inside a throwaway remote sandbox.",
-      "Only the tab in front runs. Switching away does not leave a turn working in the background — it pauses that piece of work and hands the terminal to another one. That is a deliberate limit rather than a missing feature: a terminal transcript has one bottom, and two agents printing into it at once would interleave into something neither of them said. (Archymedes's desktop window is different — it has a transcript per tab, so its tabs really do run at the same time.)",
-      "When you want work running while you do something else, that is what /detach and /jobs are for: a detached job keeps going after you close the terminal, and /watch streams it into the session without taking the prompt.",
-      "Tabs keep what they printed. Leave one and come back and the last lines reappear, so you can pick up where you were instead of facing a bare prompt.",
-      "The strip above the prompt shows every tab with its model and a mark for where it runs. Closing a tab that started its own sandbox stops that sandbox — and only that one."
-    ],
-    examples: [
-      { input: "/tab new review", effect: "a second tab, same model, same machine" },
-      { input: "/tab new fast --model claude-haiku-4-5-20251001", effect: "a tab on a different model" },
-      { input: "/tab new risky --sandbox e2b", effect: "a tab whose edits land in a remote sandbox, not on your disk" },
-      { input: "/tab 2", effect: "switch to tab 2 and replay where you left off" },
-      { input: "/tab close 2", effect: "close it, stopping its sandbox if it started one" },
-      { input: "/detach run the full test suite", effect: "work that runs while you use another tab" }
-    ],
-    covers: ["/tab"]
-  },
-  {
-    id: "models",
-    title: "Models and providers",
-    summary: "Choosing what runs, and what it costs.",
-    body: [
-      "Archymedes talks to several providers. The picker lists what you can use, with prices, and offers to save a key for anything you cannot use yet. Switching model keeps the conversation — you are changing who answers, not starting over.",
-      "The list is the union of what this build knows the prices of and what each provider says it has today, so a model released last week is still offerable — it is simply shown without a price rather than hidden. The live half is cached for six hours; /models refresh asks again.",
-      "A model switch applies to the tab you are in. Opening a tab with --model is how you compare two models on the same problem."
-    ],
-    examples: [
-      { input: "/models", effect: "the list, with prices" },
-      { input: "/models refresh", effect: "ask every provider what it has right now" },
-      { input: "/model", effect: "the picker" },
-      { input: "/model claude-sonnet-5", effect: "switch straight to one, keeping the transcript" },
-      { input: "/fallback openai:gpt-5.4-mini", effect: "retry transient provider failures on this model, only before any output or tool action" },
-      { input: "/providers", effect: "which providers are configured" }
-    ],
-    covers: ["/models", "/model", "/fallback", "/providers", "/settings"]
-  },
-  {
-    id: "where",
-    title: "Where the work happens",
-    summary: "This machine, a container, or a remote sandbox.",
-    body: [
-      "By default Archymedes edits the directory you started it in. Started with --sandbox e2b it works inside a throwaway remote machine instead, and --sandbox docker uses a local container. Files written there never touch your disk unless you ask for them.",
-      "Sandboxes are per tab, so 'try this somewhere I don't mind breaking' is one command rather than a second terminal.",
-      "One thing worth knowing: background jobs always run on your machine, even when the session that started them is sandboxed. Archymedes says so each time you start one."
-    ],
-    examples: [
-      { input: "archymedes --sandbox e2b", effect: "the whole session runs in a remote sandbox" },
-      { input: "/tab new spike --sandbox docker", effect: "one tab in a local container" },
-      { input: "/where", effect: "which machine the current tab is using" },
-      { input: "/pull", effect: "copy files out of a sandbox and onto your disk" }
-    ],
-    covers: ["/where", "/pull"]
-  },
-  {
-    id: "reading",
-    title: "Reading what Archymedes did",
-    summary: "Code, diffs, test results, and folded detail.",
-    body: [
-      "When Archymedes writes or edits a file it shows the code, numbered, under the tool line. When it runs tests it re-lays the output into sections with the failures pulled out. When output is long it is folded rather than truncated, and the whole of it is one command away.",
-      "The diff shows the actual patch since the last checkpoint — the lines, not a count of them."
-    ],
-    examples: [
-      { input: "/diff", effect: "the real patch, file by file" },
-      { input: "/diff stat", effect: "just the summary of how much changed" },
-      { input: "/expand", effect: "unfold the last folded block" },
-      { input: "/expand list", effect: "everything that has been folded this session" },
-      { input: "/undo", effect: "revert the last turn — files, conversation, or both" },
-      { input: "/retry", effect: "repeat a failed request when nothing had run or changed" },
-      { input: "/continue", effect: "finish an interrupted task without repeating completed work" },
-      { input: "/todos", effect: "the agent's current plan" },
-      { input: "/task", effect: "the whole task at a glance: request, plan, changes, verification, blockers" },
-      { input: "/route", effect: "the hosted exchange's routing decision for the last turn — chosen model, alternatives, cost vs estimate" }
-    ],
-    covers: ["/diff", "/expand", "/undo", "/retry", "/continue", "/todos", "/task", "/route"]
-  },
-  {
-    id: "memory",
-    title: "Memory",
-    summary: "Facts worth keeping between sessions.",
-    body: [
-      "Telling Archymedes the same thing every session costs you tokens and patience. A remembered fact is prepended to the conversation instead.",
-      "Memory is a plain markdown file you can open, edit, commit or delete. Project memory belongs to the repository; personal memory follows you across projects. Nothing is remembered unless you say so."
-    ],
-    examples: [
-      { input: "# we use bun, not npm", effect: "remember a fact about this project" },
-      { input: "/memory", effect: "list what is remembered" },
-      { input: "/memory add --user I prefer terse explanations", effect: "remember something about you, everywhere" },
-      { input: "/memory forget 2", effect: "drop one" }
-    ],
-    covers: ["/memory"]
-  },
-  {
-    id: "history",
-    title: "History",
-    summary: "Past conversations, searchable and resumable.",
-    body: [
-      "Every session is saved. You can list them, search the ones you half-remember, read one back, or pick one up and keep going with its whole context intact."
-    ],
-    examples: [
-      { input: "/history", effect: "recent sessions, newest first" },
-      { input: "/history search failing tests", effect: "find one by what you typed" },
-      { input: "/history resume", effect: "pick up where a past session left off" },
-      { input: "/export support", effect: "write a compact redacted artifact safe to attach to a support request" },
-      { input: "/clear", effect: "start a fresh thread in this tab" }
-    ],
-    covers: ["/history", "/sessions", "/export", "/clear"]
-  },
-  {
-    id: "cost",
-    title: "Cost and pace",
-    summary: "Knowing what you are spending, and spending it slower.",
-    body: [
-      "Every turn is priced in your own currency, and the running total is always on screen. Start with --budget N to approve a cap that is then enforced rather than merely reported.",
-      "Slow mode is the other half: it limits how many model rounds and tool calls a turn may use, shortens replies, and pauses between turns. It caps the rate, not the total, and asks before an unusually expensive turn."
-    ],
-    examples: [
-      { input: "/cost", effect: "the breakdown for this session" },
-      { input: "archymedes --budget 20", effect: "approve and enforce a cap" },
-      { input: "/slow", effect: "spend at a gentler pace" },
-      { input: "/slow strict", effect: "slower still, with a pause between turns" },
-      { input: "/slow off", effect: "back to full speed" }
-    ],
-    covers: ["/cost", "/slow"]
-  },
-  {
-    id: "balance",
-    title: "Tracking a spend balance",
-    summary: "A local budget the prompt draws down as you work.",
-    body: [
-      "Archymedes has no hosted wallet. /balance sets a figure — the amount you have decided this project can spend — and after every completed turn Archymedes subtracts that turn's measured cost from it. It is an estimate you own, not a provider statement.",
-      "The balance is kept in whatever currency your session shows costs in. /balance 5000 uses that currency; /balance 50 usd or /balance 5000 inr sets it explicitly. /balance on its own shows what remains and what this session has used so far. /balance clear stops tracking.",
-      "Once a balance is being tracked, Archymedes warns calmly when it gets low, drops below the critical threshold, or falls unusually fast between turns. Before a demanding task it compares its token-based estimate with the balance and stops before contacting the model when even the conservative estimate cannot fit.",
-      "The thresholds default to small USD amounts converted to your currency; ARCHYMEDES_LOW_BALANCE and ARCHYMEDES_CRITICAL_BALANCE override them in /settings."
-    ],
-    examples: [
-      { input: "/balance 5000", effect: "track a 5,000 balance in the display currency" },
-      { input: "/balance 50 usd", effect: "track a balance in a specific currency" },
-      { input: "/balance", effect: "what remains, and what this session has used" },
-      { input: "/balance clear", effect: "stop tracking a balance" }
-    ],
-    covers: ["/balance", "/cost"]
-  },
-  {
-    id: "updating",
-    title: "Keeping Archymedes current",
-    summary: "Automatic updates by default, with explicit check-only and off controls.",
-    body: [
-      "Archymedes looks for a new version once a day, at the moment a session starts and never in the middle of one. The check is bounded at three seconds and its failure is silent: an unreachable registry costs one attempt a day, not a slow prompt.",
-      "By default Archymedes installs a newer release automatically through whichever package manager installed it; it does not wait for another acceptance prompt. /update check changes that to notification-only behavior, and /update off stops it looking at all.",
-      "Automatic installs never happen in a piped or headless run, or in CI, because automation may depend on an exact installed version. A version that fails to install is remembered and not retried, because an update mechanism that fails loudly every launch is one people uninstall.",
-      "An install replaces the program on disk; the session you are in keeps running the version it started with until you restart it."
-    ],
-    examples: [
-      { input: "/update", effect: "install the newest version now" },
-      { input: "/update check", effect: "tell you about updates without installing" },
-      { input: "/update off", effect: "stop looking for updates" }
-    ],
-    covers: ["/update"]
-  },
-  {
-    id: "background",
-    title: "Background work",
-    summary: "Jobs that outlive the prompt, and research that runs itself.",
-    body: [
-      "Work can be sent to the background and keeps running after you close the terminal. A watched job streams its output into the session without taking the prompt, so you can read it when you want to and carry on meanwhile.",
-      "This — not tabs — is how two things run at once in the terminal. A tab you switch away from is paused; a detached job keeps working.",
-      "Wander runs a bounded research lab on a topic, gathers evidence first, and grades its own claims. It can run once or on a schedule.",
-      "A job that needs approval says so and waits — attach to it to answer."
-    ],
-    examples: [
-      { input: "/detach update the changelog", effect: "start it in the background" },
-      { input: "/jobs", effect: "what is running, queued or finished" },
-      { input: "/watch 20260814T0132Z-ab12cd", effect: "follow its output without giving up the prompt" },
-      { input: "/watch show <id>", effect: "read what it has said so far" },
-      { input: "/attach <id>", effect: "take the prompt to answer an approval" },
-      { input: "/wander daily coral reefs", effect: "a research lab, every day" }
-    ],
-    covers: ["/detach", "/jobs", "/attach", "/watch", "/wander"]
-  },
-  {
-    id: "panel",
-    title: "The control panel",
-    summary: "Every tab and job, live, on one screen.",
-    body: [
-      "The workspace is a full-screen view of everything at once: each tab as a pane showing its live output, what model it is running and where, and each watched job alongside them.",
-      "It is a view — it reads the session and changes nothing — so leaving it puts you back exactly where you were.",
-      "Inside it: 1-9 select a pane, arrows or Tab move between them, arrows or j/k scroll, g and G jump to the ends, q leaves."
-    ],
-    examples: [
-      { input: "/workspace", effect: "open the panel" },
-      { input: "q", effect: "leave it and return to the prompt" }
-    ],
-    covers: ["/workspace"]
-  },
-  {
-    id: "look",
-    title: "How it looks",
-    summary: "Themes, symbols, and terminals that need help.",
-    body: [
-      "Archymedes ships a blueprint theme and three others, and reads themes you write yourself as .tss files in .archymedes/themes — the same format TermUI apps use, so a palette written once works in both.",
-      "If your terminal draws question marks instead of symbols, --ascii switches to characters every terminal has. If you would rather have a status line pinned to the bottom row, --pin does that, at the cost of your terminal's scrollback."
-    ],
-    examples: [
-      { input: "/theme list", effect: "every theme available, including your own" },
-      { input: "/theme chalkboard", effect: "change the colours immediately" },
-      { input: "/theme where", effect: "where to put a theme file of your own" },
-      { input: "archymedes --ascii", effect: "plain characters for terminals that mangle symbols" }
-    ],
-    covers: ["/theme"]
-  },
-  {
-    id: "extend",
-    title: "Tools and voice",
-    summary: "What the agent can call, and talking to it.",
-    body: [
-      "Archymedes has a fixed set of built-in tools, and a project can add more through skills, plugins, MCP servers and hooks. The tools command shows exactly what is available in this project.",
-      "Voice input records or transcribes a prompt you can edit before sending.",
-      "The file picker is the project as a tree rather than a flat completion list: expand a folder, preview a file's contents, and pick one to drop an @mention into the line you're writing.",
-      "`/edit <path>` opens a file in the built-in editor. It reads and writes through the workspace like every tool does, so it edits the sandbox's copy in a sandboxed session rather than a same-named file on this machine, and it only writes when you save — quitting really is a discard."
-    ],
-    examples: [
-      { input: "/tools", effect: "every tool, skill, plugin, MCP server and hook" },
-      { input: "/voice", effect: "record a prompt, then edit it before sending" },
-      { input: "/files", effect: "browse the project tree and @mention a file" },
-      { input: "/edit src/app.ts", effect: "open a file in the built-in editor" }
-    ],
-    covers: ["/tools", "/voice", "/files", "/edit"]
-  }
-];
-function wrapText(text, width) {
-  const measure = Math.max(1, width);
-  const lines = [];
-  let current = "";
-  for (const word of text.split(/\s+/).filter(Boolean)) {
-    if (current === "") {
-      current = word;
-      continue;
-    }
-    if (visibleWidth(current) + 1 + visibleWidth(word) <= measure)
-      current = `${current} ${word}`;
-    else {
-      lines.push(current);
-      current = word;
-    }
-  }
-  if (current !== "")
-    lines.push(current);
-  return lines;
-}
-
-// packages/archymedes-cli/src/guide-browser.ts
-function initialGuideState(columns, rows, palette = NO_COLOR_PALETTE) {
-  return { topics: GUIDE_TOPICS, selected: 0, scroll: 0, query: "", searching: false, columns, rows, palette };
-}
-function visibleTopics(state) {
-  const needle = state.query.trim().toLowerCase();
-  if (!needle)
-    return [...state.topics];
-  return state.topics.filter((topic) => [topic.title, topic.summary, topic.id, ...topic.body, ...(topic.examples ?? []).flatMap((example) => [example.input, example.effect])].some((text) => text.toLowerCase().includes(needle)));
-}
-function currentTopic(state) {
-  const topics = visibleTopics(state);
-  if (topics.length === 0)
-    return;
-  return topics[Math.max(0, Math.min(state.selected, topics.length - 1))];
-}
-function sidebarWidth(columns) {
-  const width = Math.max(1, Math.floor(columns));
-  return Math.min(width, Math.max(14, Math.min(26, Math.floor(width * 0.28))));
-}
-function bodyHeight(rows) {
-  return Math.max(0, Math.floor(rows) - 2);
-}
-function keyToGuideAction(key, character, searching) {
-  const name = key.name ?? "";
-  if (key.ctrl && name === "c")
-    return { kind: "exit" };
-  const isEnter = name === "return" || name === "enter" || name === "\r" || name === `
-`;
-  const isEscape = name === "escape" || name === "\x1B";
-  if (searching) {
-    if (isEscape || isEnter)
-      return { kind: "commit" };
-    if (name === "backspace")
-      return { kind: "backspace" };
-    if (name === "up")
-      return { kind: "move", step: -1 };
-    if (name === "down")
-      return { kind: "move", step: 1 };
-    if (character && character.length === 1 && character >= " ")
-      return { kind: "type", character };
-    return { kind: "none" };
-  }
-  if (isEscape || name === "q")
-    return { kind: "exit" };
-  if (character === "/" || name === "f3")
-    return { kind: "search" };
-  if (name === "up" || name === "k")
-    return { kind: "move", step: -1 };
-  if (name === "down" || name === "j")
-    return { kind: "move", step: 1 };
-  if (name === "tab")
-    return { kind: "move", step: key.shift ? -1 : 1 };
-  if (name === "pagedown" || character === " ")
-    return { kind: "page", step: 1 };
-  if (name === "pageup")
-    return { kind: "page", step: -1 };
-  if (name === "right")
-    return { kind: "scroll", rows: 1 };
-  if (name === "left")
-    return { kind: "scroll", rows: -1 };
-  return { kind: "none" };
-}
-function applyGuideAction(state, action) {
-  const topics = visibleTopics(state);
-  switch (action.kind) {
-    case "move": {
-      if (topics.length === 0)
-        return state;
-      const next = ((state.selected + action.step) % topics.length + topics.length) % topics.length;
-      return { ...state, selected: next, scroll: 0 };
-    }
-    case "scroll":
-    case "page": {
-      const topic = currentTopic(state);
-      if (!topic)
-        return state;
-      const lines = topicLines(topic, bodyWidth(state.columns)).map((line) => line.text);
-      const viewport = { ...newViewport(lines, bodyHeight(state.rows)), top: state.scroll };
-      const moved = action.kind === "page" ? applyViewport(viewport, { kind: action.step === 1 ? "pageDown" : "pageUp" }) : applyViewport(viewport, action.rows > 0 ? { kind: "down", rows: action.rows } : { kind: "up", rows: -action.rows });
-      return { ...state, scroll: moved.top };
-    }
-    case "search":
-      return { ...state, searching: true };
-    case "commit":
-      return { ...state, searching: false };
-    case "backspace":
-      return { ...state, query: state.query.slice(0, -1), selected: 0, scroll: 0 };
-    case "type":
-      return { ...state, query: state.query + action.character, selected: 0, scroll: 0 };
-    default:
-      return state;
-  }
-}
-function bodyWidth(columns) {
-  const width = Math.max(1, Math.floor(columns));
-  return width < 40 ? width : Math.max(1, width - sidebarWidth(width) - 3);
-}
-function topicLines(topic, width) {
-  const measure = Math.max(1, Math.floor(width));
-  const wrap = (text, available = measure) => wrapText(text, Math.max(1, available)).flatMap((line) => hardWrap(line, Math.max(1, available)));
-  const rows = [
-    ...wrap(topic.title).map((line) => ({ text: line, bold: true })),
-    { text: "" }
-  ];
-  for (const paragraph of topic.body) {
-    for (const line of wrap(paragraph))
-      rows.push({ text: line });
-    rows.push({ text: "" });
-  }
-  if (topic.examples && topic.examples.length > 0) {
-    rows.push({ text: "try", bold: true });
-    for (const example of topic.examples) {
-      const commandIndent = " ".repeat(Math.min(2, Math.max(0, measure - 1)));
-      const detailIndent = " ".repeat(Math.min(4, Math.max(0, measure - 1)));
-      const [head, ...rest] = wrap(example.input, measure - visibleWidth(detailIndent));
-      rows.push({ text: `${commandIndent}${head ?? ""}`, bold: true });
-      for (const line of rest)
-        rows.push({ text: `${detailIndent}${line}`, bold: true });
-      for (const line of wrap(example.effect, measure - visibleWidth(detailIndent)))
-        rows.push({ text: `${detailIndent}${line}`, dim: true });
-    }
-  }
-  return rows;
-}
-function hardWrap(text, width) {
-  if (visibleWidth(text) <= width)
-    return [text];
-  const lines = [];
-  let line = "";
-  const segments = typeof Intl.Segmenter === "function" ? [...new Intl.Segmenter(undefined, { granularity: "grapheme" }).segment(text)].map((entry) => entry.segment) : [...text];
-  for (const segment of segments) {
-    if (line && visibleWidth(line + segment) > width) {
-      lines.push(line);
-      line = "";
-    }
-    if (visibleWidth(segment) > width) {
-      lines.push("…");
-      continue;
-    }
-    line += segment;
-  }
-  if (line)
-    lines.push(line);
-  return lines;
-}
-function composeGuideFrame(state) {
-  const columns = Math.max(1, Math.floor(state.columns));
-  const rowCount = Math.max(1, Math.floor(state.rows));
-  const compact = columns < 40;
-  const sidebar = compact ? 0 : sidebarWidth(columns);
-  const body = bodyWidth(columns);
-  const height = bodyHeight(rowCount);
-  const topics = visibleTopics(state);
-  const selectedIndex = topics.length === 0 ? -1 : Math.max(0, Math.min(state.selected, topics.length - 1));
-  const topic = selectedIndex === -1 ? undefined : topics[selectedIndex];
-  const theme = state.palette.tokens;
-  const rows = [];
-  rows.push({
-    text: padToWidth(compact ? ` archymedes guide · ${topic?.title ?? "no matches"}` : " archymedes guide", columns),
-    bold: true,
-    color: theme.primary
-  });
-  if (rowCount === 1)
-    return rows;
-  const lines = topic ? topicLines(topic, body) : [{ text: "Nothing matches that." }];
-  const indices = visibleLines({ ...newViewport(lines.map((_, index) => `${index}`), height), top: state.scroll });
-  const start = indices.length > 0 ? Number(indices[0]) : 0;
-  const window = lines.slice(start, start + height);
-  const listStart = Math.max(0, Math.min(selectedIndex - Math.floor(height / 2), Math.max(0, topics.length - height)));
-  for (let offset = 0;offset < height; offset += 1) {
-    const listed = topics[listStart + offset];
-    const chosen = listed !== undefined && listStart + offset === selectedIndex;
-    const cell = listed ? `${chosen ? "›" : " "} ${listed.title}` : "";
-    const line = window[offset];
-    rows.push({
-      text: compact ? padToWidth(line?.text ?? "", columns) : joinHorizontal(sliceToWidth(cell, sidebar), line?.text ?? "", { leftWidth: sidebar, rightWidth: body, separator: " │ " }),
-      bold: chosen || line?.bold,
-      dim: line?.dim && !chosen,
-      ...chosen ? { color: theme.accent } : line?.bold ? { color: theme.primary } : {}
-    });
-  }
-  const position = lines.length > height ? `  ${scrollIndicator(scrollPercent(start, lines.length, height))}` : "";
-  const footer = state.searching ? `search: ${state.query}▏  Enter done · Esc done` : `↑↓ topic · ←→ scroll · space page · / search · q leave${state.query ? `   filter: ${state.query}` : ""}${position}`;
-  rows.push({ text: padToWidth(` ${footer}`, columns), dim: true, color: theme.textMuted });
-  return rows;
-}
-
-// packages/archymedes-cli/src/guide-screen.tsx
-import { jsxDEV } from "@termuijs/jsx/jsx-dev-runtime";
-var Panel = Box;
-var Line = Text;
-function GuideScreen({ columns, rows, onExit, startAt, palette = NO_COLOR_PALETTE }) {
-  const [state, setState] = useState(() => {
-    const initial = initialGuideState(columns, rows, palette);
-    const index = startAt ? initial.topics.findIndex((topic) => topic.id === startAt) : -1;
-    return index >= 0 ? { ...initial, selected: index } : initial;
-  });
-  useInput((input, key) => {
-    const action = keyToGuideAction({ name: key?.key, ctrl: key?.ctrl, shift: key?.shift }, input, state.searching);
-    if (action.kind === "exit") {
-      onExit();
-      return;
-    }
-    setState((current) => applyGuideAction(current, action));
-  });
-  const frame = composeGuideFrame(state);
-  return /* @__PURE__ */ jsxDEV(Panel, {
-    flexDirection: "column",
-    width: state.columns,
-    height: state.rows,
-    children: frame.map((row, index) => /* @__PURE__ */ jsxDEV(Line, {
-      bold: row.bold,
-      dimColor: row.dim,
-      inverse: row.inverse,
-      color: row.color,
-      children: row.text
-    }, `row-${index}`, false, undefined, this))
-  }, undefined, false, undefined, this);
-}
-async function runGuideScreen(options) {
-  const { renderApp } = await import("@termuijs/jsx");
-  await new Promise((resolve) => {
-    let settled = false;
-    const finish = () => {
-      if (settled)
-        return;
-      settled = true;
-      resolve();
-    };
-    renderApp(GuideScreen, {
-      columns: options.columns,
-      rows: options.rows,
-      startAt: options.startAt,
-      palette: options.palette,
-      onExit: finish,
-      fullscreen: true
-    }).catch(finish);
-  });
-}
-export {
-  runGuideScreen,
-  GuideScreen
-};