@causyne/agent 0.0.0-stage → 1.10.0

package/src/tui/ask.js

@@ -0,0 +1,164 @@
+// One question, asked properly, outside the chat surface.
+//
+// `causyne config` and `causyne pair` run with no chat session behind them, so
+// there is no live region for a dialog to draw into. That is why they were the
+// last two surfaces still on inquirer — and inquirer is a different design
+// system: its own colours, its own glyphs, no NO_COLOR handling, and a list
+// widget that looks nothing like the picker the same user sees inside `causyne`.
+//
+// The fix is NOT a second app shell. That was tried once: screen.js, layout.js,
+// transcript.js and appShell.js existed, took over the terminal, and were
+// deleted under UX-01 when it turned out there is no way to detect a terminal
+// that ignores the alternate buffer. Rebuilding a host would walk straight back
+// into that.
+//
+// Instead this borrows the host that already works. ChatPrompt owns raw mode,
+// key decoding, the bounded live region and the layer stack, and `attach()` —
+// the part that wires it to a chat renderer — is optional. So a standalone
+// question is just a ChatPrompt started for the lifetime of one dialog and
+// stopped again: same keys, same panel, same width clamping, same normal-buffer
+// discipline, no second implementation to drift.
+//
+// Every helper degrades. If stdin is not a terminal, or raw mode cannot be
+// taken, they fall back to a plain readline question — a better editor must
+// never be the reason a command refuses to run.
+
+import readline from 'readline';
+import { ChatPrompt, isInteractive } from './prompt.js';
+import { SelectLayer, InputLayer, ConfirmLayer } from './dialogs.js';
+
+/**
+ * Run one layer on a temporary prompt host.
+ *
+ * `build(resolve)` returns the Layer to show and calls `resolve` with the
+ * answer. The host is torn down before this settles, so whatever the caller
+ * prints next lands in a clean terminal.
+ */
+function hostOneLayer(build) {
+  return new Promise((resolve) => {
+    let prompt;
+    let settled = false;
+
+    const finish = (value) => {
+      if (settled) return;
+      settled = true;
+      try { if (prompt) prompt.stop(); } catch (e) { /* already stopped */ }
+      // Let the terminal settle before the caller writes over the same rows.
+      setImmediate(() => resolve(value));
+    };
+
+    try {
+      prompt = new ChatPrompt({
+        commands: [],
+        // ctrl+c during a question is a cancel, not an exit: the caller decides
+        // what "no answer" means for it. An exit here would kill the process
+        // mid-configuration and leave a half-written config.json.
+        onInterrupt: () => finish(null),
+        onExit: () => finish(null)
+      });
+      prompt.start();
+    } catch (e) {
+      resolve(undefined); // signals "no TTY host" — caller falls back
+      return;
+    }
+
+    prompt.openLayer(build(finish));
+  });
+}
+
+/** True when a panel-based question can be asked at all. */
+export function canAskInPanel() {
+  return isInteractive();
+}
+
+/** Plain readline, for pipes, CI and any terminal that refuses raw mode. */
+function fallbackQuestion(question, { mask = false } = {}) {
+  return new Promise((resolve) => {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(`${question} `, (answer) => { rl.close(); resolve(answer); });
+    if (mask) {
+      // Suppress the echo of what is typed. `_writeToOutput` is readline's own
+      // hook for exactly this; the prompt itself still has to be drawn or the
+      // user sees nothing at all.
+      rl._writeToOutput = function (text) {
+        if (text.includes(question)) rl.output.write(text);
+      };
+    }
+  });
+}
+
+/**
+ * Pick one of a list.
+ *
+ * @param {object} options
+ * @param {string} options.title
+ * @param {Array}  options.items  `{ id, label, description }`
+ * @returns {Promise<object|null>} the chosen item, or null if dismissed
+ */
+export async function askSelect({ title = '', items = [] } = {}) {
+  if (items.length === 0) return null;
+
+  if (canAskInPanel()) {
+    const answer = await hostOneLayer((resolve) => new SelectLayer({
+      title,
+      items: items.map((item) => ({ ...item, value: item })),
+      onPick: (picked) => resolve(picked ? picked.value : null)
+    }));
+    if (answer !== undefined) return answer;
+  }
+
+  // Numbered list is the honest fallback: it needs no cursor control at all.
+  console.log(`\n${title}`);
+  items.forEach((item, index) => {
+    console.log(`  ${String(index + 1).padStart(2)}. ${item.label}${item.description ? `  — ${item.description}` : ''}`);
+  });
+  const raw = await fallbackQuestion(`Choose 1-${items.length}:`);
+  const choice = Number(String(raw).trim());
+  return Number.isInteger(choice) && choice >= 1 && choice <= items.length ? items[choice - 1] : null;
+}
+
+/**
+ * Ask for a line of text.
+ *
+ * @returns {Promise<string|null>} the answer, or null if dismissed
+ */
+export async function askText({ title = '', lines = [], value = '', placeholder = '', mask = false, validate = null } = {}) {
+  while (true) {
+    let answer;
+
+    if (canAskInPanel()) {
+      answer = await hostOneLayer((resolve) => new InputLayer({
+        title, lines, value, placeholder, mask,
+        onSubmit: (text) => resolve(text),
+        onCancel: () => resolve(null)
+      }));
+      if (answer === undefined) answer = await fallbackQuestion(`${title}:`, { mask });
+    } else {
+      if (lines.length) console.log('\n' + lines.join('\n'));
+      answer = await fallbackQuestion(`${title}:`, { mask });
+    }
+
+    if (answer === null) return null;
+
+    // Re-ask rather than accept something the caller has said is wrong. This is
+    
+    
+    const problem = validate ? validate(answer) : null;
+    if (!problem) return answer;
+    console.log(`  ${problem}`);
+    value = answer;
+  }
+}
+
+/** A yes/no, defaulting to no on dismissal. */
+export async function askConfirm(message) {
+  if (canAskInPanel()) {
+    const answer = await hostOneLayer((resolve) => new ConfirmLayer({
+      message,
+      onAnswer: (yes) => resolve(Boolean(yes))
+    }));
+    if (answer !== undefined) return Boolean(answer);
+  }
+  const raw = await fallbackQuestion(`${message} [y/N]`);
+  return /^y(es)?$/i.test(String(raw).trim());
+}

package/src/tui/banner.js

@@ -0,0 +1,158 @@
+// The banner: the wordmark, and the first thing a new user is invited to ask.
+//
+// This lives in its own module because it is written ONCE, straight into the
+// user's real terminal history, before anything else runs — the same shape
+// openclaw uses (src/cli/banner.ts emitCliBanner: art first, metadata line
+// underneath) and opencode's entry splash, whose own comment calls these
+// "scrollback snapshots ... immutable terminal history once committed".
+//
+// Nothing here repaints. Nothing here clears. See UX-01 in .agents/rules.json.
+//
+// Pure Node over theme.js and text.js. No dependency, no shell.
+
+import { paint, bold, dim, GLYPHS, HAS_UNICODE } from './theme.js';
+import { visibleWidth, truncate, padEnd, shortenHome } from './text.js';
+
+// Painted through the theme rather than with a hardcoded \x1b[1m\x1b[36m, so it
+// still obeys NO_COLOR and still degrades on a terminal without box-drawing.
+const WORDMARK = [
+  ' ████   ███  █   █  ████ █   █ █   █ █████',
+  '█      █   █ █   █ █      █ █  ██  █ █    ',
+  '█      █████ █   █  ███    █   █ █ █ ████ ',
+  '█      █   █ █   █     █   █   █  ██ █    ',
+  ' ████  █   █  ███  ████    █   █   █ █████'
+];
+
+// A terminal without box-drawing support would render the art as mojibake, so
+// it gets the wordmark spelled out instead of a field of question marks.
+const WORDMARK_PLAIN = ['C A U S Y N E'];
+
+/**
+ * The banner rows.
+ *
+ * `unicode` is overridable so both branches can actually be tested — under
+ * `node --test` there is no TTY, so HAS_UNICODE is false and the block art would
+ * never be exercised at all.
+ */
+export function wordmark(width = 80, { unicode = HAS_UNICODE } = {}) {
+  const art = (unicode && width >= 54) ? WORDMARK : WORDMARK_PLAIN;
+  const rows = art.map((line) => paint('accent', line));
+  rows.push('');
+  rows.push(dim('Causyne AI Agent'));
+  return rows;
+}
+
+/**
+ * The session header: the wordmark and the session facts, SIDE BY SIDE.
+ *
+ * This used to be three stacked blocks — six rows of art, then a blank, then a
+ * bordered panel of four label/value rows, then two separate hint lines. Nineteen
+ * rows of chrome before the user could type a character, on a surface whose whole
+ * job is to get out of the way.
+ *
+ * Neither reference does that. claude-code sets its art in the left column with
+ * the version, model, plan and directory stacked beside it — three rows, one
+ * block. opencode puts the logo alone and the facts in the prompt box. The
+ * common property is that the identity and the facts are ONE object, not a
+ * sequence of them.
+ *
+ * Falls back to stacking when the terminal cannot hold both columns, because a
+ * header that wraps is worse than a header that is tall.
+ */
+export function sessionBanner(info = {}, width = 80, { unicode = HAS_UNICODE } = {}) {
+  const art = (unicode && width >= 54) ? WORDMARK : WORDMARK_PLAIN;
+  const artWidth = Math.max(...art.map(visibleWidth));
+
+  const facts = [];
+  if (info.version) facts.push([bold(paint('accent', 'Causyne')), dim(info.version)]);
+  const model = info.model || 'no model configured';
+  facts.push([paint('ink', model), info.provider ? dim(providerLabel(info.provider)) : '']);
+  const mode = [info.autonomyMode ? `mode ${info.autonomyMode}` : '', info.tier ? `tier ${info.tier}` : '']
+    .filter(Boolean).join(`  ${GLYPHS.dot}  `);
+  if (mode) facts.push([dim(mode), '']);
+  if (info.workspace) facts.push([dim(shortenHome(info.workspace)), '']);
+
+  const GAP = 4;
+  // The spare column is the same one the stacked branch below already reserves
+  // (`width - 1`). Without it a full-width fact row lands in the terminal's
+  // deferred-wrap state: the cursor sits past the last column, and the next
+  // write decides whether that becomes a wrap. Measured on an 80-column pty,
+  // the workspace row came back at exactly 80 while every other row was 79.
+  const room = width - artWidth - GAP - 1;
+
+  // Not enough width for two columns: stack, rather than wrap either one.
+  if (room < 24) {
+    return art.map((line) => paint('accent', line))
+      .concat([''], facts.map(([left, right]) =>
+        truncate(right ? `${left}  ${right}` : left, width - 1, GLYPHS.ellipsis)));
+  }
+
+  const rows = [];
+  const height = Math.max(art.length, facts.length);
+  for (let index = 0; index < height; index++) {
+    const artLine = art[index] === undefined ? '' : paint('accent', art[index]);
+    const fact = facts[index];
+    const left = padEnd(artLine, artWidth) + ' '.repeat(GAP);
+    if (!fact) { rows.push(artLine); continue; }
+    const [primary, secondary] = fact;
+    const text = secondary ? `${primary}  ${secondary}` : primary;
+    rows.push(left + truncate(text, room, GLYPHS.ellipsis));
+  }
+  return rows;
+}
+
+/**
+ * Display the provider the way the user wrote it, normalised for casing only.
+ *
+ * Causyne is BYOK: the provider is whatever the user configured, and nothing here
+ * may assume or default to one. A config saying `Gemini` and one saying `gemini`
+ * are the same provider and must read the same.
+ */
+export function providerLabel(provider) {
+  const raw = String(provider || '').trim();
+  if (!raw) return '';
+  const KNOWN = {
+    openai: 'OpenAI', anthropic: 'Anthropic', gemini: 'Gemini', ollama: 'Ollama',
+    deepseek: 'DeepSeek', dashscope: 'DashScope', 'dashscope-byok': 'DashScope',
+    qwen: 'Qwen', xai: 'xAI', grok: 'xAI', moonshot: 'Moonshot', kimi: 'Moonshot',
+    muse: 'Meta', meta: 'Meta',
+    'openai-compatible': 'OpenAI-compatible'
+  };
+  return KNOWN[raw.toLowerCase()] || raw;
+}
+
+// What to ask, for the person who has just opened this for the first time.
+//
+// `ask anything` is an invitation, not an example — it tells a new user nothing
+// about what this agent can actually be asked to do. Both references show a
+// concrete prompt instead (opencode seeds a random one per launch from
+// routes/home.tsx). One is picked per session so the hint does not churn while
+// the user is reading it.
+export const EXAMPLES = [
+  'summarise what changed in this repo today',
+  'find every TODO left in src/ and group them by file',
+  'explain what this project does and how it is wired',
+  'run the tests and tell me what broke',
+  'review my last commit for anything risky'
+];
+
+/** One example, chosen per session rather than per keystroke. */
+export function pickExample() {
+  return EXAMPLES[Math.floor(Math.random() * EXAMPLES.length)];
+}
+
+/**
+ * Join hint fragments, dropping the least important until the line fits.
+ *
+ * Same policy as the footer: a hint clipped mid-word reads as a bug, so drop
+ * whole fragments rather than truncate one, and fall back entirely when even a
+ * single fragment will not fit.
+ */
+export function fitHints(parts, width, fallback) {
+  const separator = `  ${GLYPHS.dot}  `;
+  const kept = parts.slice();
+  while (kept.length > 1 && visibleWidth(kept.join(separator)) > width) kept.pop();
+  const line = kept.join(separator);
+  // A narrow terminal must not get `try "review my last commit for anything r`.
+  return visibleWidth(line) <= width ? line : fallback;
+}

package/src/tui/block.js

@@ -0,0 +1,152 @@
+// Blocks: a left accent bar and a filled surface, the shape that makes a run of
+// terminal rows read as ONE thing.
+//
+// Causyne's chat printed every kind of row the same way — the user's message, the
+// agent's reply, an aside from the loop and the prompt itself were all just
+// lines in the scrollback, distinguishable only by a leading glyph. On a busy
+// turn there was no visual seam anywhere, which is the difference the reference
+// tools actually make. opencode gives each of those a left border in the agent's
+// colour and a background one step off the terminal's own
+// (component/prompt/index.tsx:1353 — `border={["left"]}` + `borderColor` +
+// `backgroundColor={theme.backgroundElement}` + `paddingLeft={2}`).
+//
+// Two properties make it work, and both are easy to get wrong:
+//
+//  * EVERY ROW IS PADDED TO THE SAME WIDTH. A background only reads as a surface
+//    if it runs past the last character; ragged rows read as highlighted text.
+//  * THE PADDING IS MEASURED, NOT COUNTED. padEnd() on a coloured string pads by
+//    byte length, so the escape sequences count toward the column and the right
+//    edge of the block frays. text.js padEnd() measures visible width.
+//
+// It degrades in two steps rather than one: without truecolor/256 there is no
+// fill and the bar alone carries the block; without colour at all the bar is an
+// ASCII `|`. A transcript piped to a file stays clean either way.
+//
+// Pure Node over ./theme.js and ./text.js. No dependency, no shell.
+
+import { paint, fill, dim, GLYPHS, HAS_COLOR } from './theme.js';
+import { visibleWidth, padEnd, truncate, wrap } from './text.js';
+
+// Columns between the bar and the text. opencode uses paddingLeft={2} inside its
+// bordered box; one column belongs to the bar, so the gutter is one more.
+const GUTTER = 1;
+
+/**
+ * Render `lines` as one block with a left accent bar.
+ *
+ * @param {string[]} lines    already-styled rows; NOT re-wrapped (see blockOf)
+ * @param {object}   options
+ * @param {number}   options.width   total columns the block may occupy
+ * @param {string}   options.role    accent role for the bar (user, agent, accent…)
+ * @param {boolean}  options.filled  paint the surface behind the text
+ * @param {string}   options.surface which surface role to fill with
+ * @returns {string[]} rows, each exactly `width` columns wide
+ */
+export function barBlock(lines, {
+  width = 80,
+  role = 'accent',
+  filled = true,
+  surface = 'surface',
+  punctuate = false
+} = {}) {
+  // The input box asks for a continuous heavy rule with a dot at its middle —
+  // long line, dot, long line. Everything else keeps the half-block bar, because
+  // a message block is content and the input box is chrome you type INTO; the
+  // reference draws that distinction too, giving its prompt box custom border
+  // characters no message uses (component/prompt/index.tsx:1354-1358).
+  //
+  // Punctuation needs three rows to read as "middle": below that it would land
+  // on the only row there is, and a dot alone is not a rule.
+  const glyph = punctuate ? GLYPHS.barHeavy : GLYPHS.bar;
+  const middle = punctuate && lines.length >= 3 ? Math.floor(lines.length / 2) : -1;
+
+  const barWidth = visibleWidth(glyph);
+  const body = Math.max(1, width - barWidth - GUTTER);
+  const bar = paint(role, glyph);
+  const marked = paint(role, GLYPHS.bullet);
+  const gutter = ' '.repeat(GUTTER);
+
+  return lines.map((line, index) => {
+    // Clip first, then pad: a line longer than the block would otherwise push
+    // the fill past the right edge and wrap, which is the failure ChatPrompt
+    // clampRows() exists to prevent one layer up.
+    const clipped = visibleWidth(line) > body ? truncate(line, body, GLYPHS.ellipsis) : line;
+    const padded = padEnd(clipped, body);
+    const inner = filled ? fill(surface, gutter + padded) : gutter + padded;
+    return (index === middle ? marked : bar) + inner;
+  });
+}
+
+/**
+ * Wrap `text` to the block's inner width, then render it as a block.
+ *
+ * The convenience form for plain prose. Callers that have already styled their
+ * rows individually (the prompt editor, a status row) use barBlock directly.
+ */
+export function blockOf(text, options = {}) {
+  const width = options.width || 80;
+  const inner = Math.max(1, width - visibleWidth(GLYPHS.bar) - GUTTER);
+  const lines = wrap(String(text == null ? '' : text), inner);
+  return barBlock(lines.length ? lines : [''], options);
+}
+
+/**
+ * A bordered panel with its title inset into the top border.
+ *
+ * The session header used to be two horizontal rules with label/value rows
+ * between them, which reads as a table of settings rather than as a greeting.
+ * Both references open with a bordered panel instead — claude-code insets the
+ * product name and version into the top rule exactly this way.
+ *
+ * `rows` are already-styled strings. Returns rows of exactly `width` columns.
+ */
+export function panel(rows, { width = 80, title = '', role = 'rule' } = {}) {
+  const inner = Math.max(4, width - 2);
+  const h = GLYPHS.hLine;
+  const label = title ? ` ${title} ` : '';
+  const clippedLabel = visibleWidth(label) > inner - 2 ? '' : label;
+  const lead = clippedLabel ? h : '';
+  const trail = h.repeat(Math.max(0, inner - visibleWidth(clippedLabel) - visibleWidth(lead)));
+
+  const top = paint(role, GLYPHS.topLeft + lead)
+    + (clippedLabel ? paint('accent', clippedLabel) : '')
+    + paint(role, trail + GLYPHS.topRight);
+  const bottom = paint(role, GLYPHS.bottomLeft + h.repeat(inner) + GLYPHS.bottomRight);
+
+  const side = paint(role, GLYPHS.vLine);
+  const middle = rows.map((row) => {
+    const clipped = visibleWidth(row) > inner ? truncate(row, inner, GLYPHS.ellipsis) : row;
+    return side + padEnd(clipped, inner) + side;
+  });
+
+  return [top, ...middle, bottom];
+}
+
+/**
+ * `9.2K (5%)` — what the context window has left, at a glance.
+ *
+ * Returns '' rather than a misleading 0% when no limit is known: an invented
+ * denominator is worse than a missing number.
+ *
+ * BOTH ARGUMENTS MUST BE IN THE SAME UNIT. The caller was passing a cumulative
+ * TOKEN count and a CHARACTER pool, which is how a quarter-full window came to
+ * report 99%.
+ */
+export function contextMeter(usedTokens, limitTokens) {
+  const used = Number(usedTokens) || 0;
+  const limit = Number(limitTokens) || 0;
+  if (used <= 0) return '';
+  const compact = used < 1000
+    ? String(Math.round(used))
+    : used < 1000000
+      ? `${(used / 1000).toFixed(used < 10000 ? 1 : 0)}K`
+      : `${(used / 1000000).toFixed(1)}M`;
+  if (limit <= 0) return compact;
+  // NOT clamped to 99. The clamp was there to keep the meter from looking like
+  // a hard stop, and its real effect was to hide a 242% reading behind a
+  // plausible-looking one for a whole session. A meter that cannot report
+  // "over" is a meter that cannot report the only thing worth acting on.
+  return `${compact} (${Math.round((used / limit) * 100)}%)`;
+}
+
+export { GUTTER };