flint-agent 1.14.0

package/src/ui/header.js

@@ -0,0 +1,140 @@
+import chalk from "chalk";
+import { readFileSync } from "node:fs";
+import { store } from "../store/index.js";
+import { config } from "../config.js";
+import { app } from "../app-state.js";
+import { printSplash } from "./splash.js";
+import { apiUrl } from "../api/address.js";
+
+const _version = (() => { try { return JSON.parse(readFileSync(new URL("../../package.json", import.meta.url), "utf-8")).version; } catch { return "?"; } })();
+
+
+// -- Formatting constants --
+export const INDENT = " ";
+export const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+export function formatToolArgs(args) {
+  if (!args || typeof args !== "object") return String(args || "");
+  return Object.entries(args)
+    .map(([k, v]) => {
+      const val = typeof v === "string" ? v : JSON.stringify(v);
+      return val.length > 60 ? `${k}="${val.slice(0, 60)}..."` : `${k}=${val}`;
+    })
+    .join(" ");
+}
+
+/**
+ * Arguments for an approval prompt: nothing cut. formatToolArgs above cuts
+ * every value at 60 characters, which is fine for a log line and wrong for a
+ * question: the operator approved a command they could only partly see
+ * (owner, 2026-10-01). A command comes first and bare; the rest as key=value.
+ */
+export function formatToolArgsFull(args) {
+  if (!args || typeof args !== "object") return String(args || "");
+  const parts = [];
+  if (typeof args.command === "string") parts.push(args.command);
+  for (const [k, v] of Object.entries(args)) {
+    if (k === "command" && typeof v === "string") continue;
+    parts.push(`${k}=${typeof v === "string" ? v : JSON.stringify(v)}`);
+  }
+  return parts.join("  ");
+}
+
+export function addIndented(indent, text) {
+  store.getState().addLine(indent + text);
+}
+
+export function userMsgLine(text, sender, { trailingBlank = true } = {}) {
+  const cols = process.stdout.columns || 80;
+  const bg = chalk.bgHex("#333333").whiteBright;
+  const maxWidth = cols - 2;
+  const prefix = sender ? `${sender} > ` : "> ";
+  const wrapPad = " ".repeat(prefix.length);
+
+  function emitLine(content, indent) {
+    const plain = content.replace(ANSI_RE, "");
+    if (indent.length + plain.length <= maxWidth) {
+      const pad = Math.max(0, maxWidth - indent.length - plain.length);
+      store.getState().addLine(bg(` ${indent}${content}${" ".repeat(pad)} `));
+    } else {
+      // Word-wrap
+      const wrapIndent = " ".repeat(indent.length);
+      const words = content.split(" ");
+      let line = "";
+      let lineLen = 0;
+      let first = true;
+      for (const word of words) {
+        const wordLen = word.replace(ANSI_RE, "").length;
+        const limit = maxWidth - indent.length;
+        if (lineLen > 0 && lineLen + 1 + wordLen > limit) {
+          const pad = Math.max(0, maxWidth - indent.length - lineLen);
+          store.getState().addLine(bg(` ${first ? indent : wrapIndent}${line}${" ".repeat(pad)} `));
+          first = false;
+          line = word;
+          lineLen = wordLen;
+        } else {
+          line = lineLen > 0 ? line + " " + word : word;
+          lineLen = lineLen > 0 ? lineLen + 1 + wordLen : wordLen;
+        }
+      }
+      if (line) {
+        const pad = Math.max(0, maxWidth - indent.length - lineLen);
+        store.getState().addLine(bg(` ${first ? indent : wrapIndent}${line}${" ".repeat(pad)} `));
+      }
+    }
+  }
+
+  store.getState().addLine("");
+  const lines = text.split("\n");
+  for (let i = 0; i < lines.length; i++) {
+    emitLine(lines[i], i === 0 ? prefix : wrapPad);
+  }
+  // Without it, a note can sit right under the message ("✓ read").
+  if (trailingBlank) store.getState().addLine("");
+}
+
+export function printHeader() {
+  const s = store.getState();
+  if (s.headerPrinted) return;
+  s.clearScreen();
+  // Mark header as printed AFTER clearScreen (which resets headerPrinted to false)
+  store.setState({ headerPrinted: true });
+  // Splash: the two-row FLiNT mark with vX.Y.Z (src/ui/splash.js)
+  s.addLine("");
+  s.addLine(printSplash(_version, true));
+  s.addLine("");
+  const modeLabel = app.profileConfig.contextMode === "window"
+    ? `window(${app.profileConfig.windowSize})`
+    : app.profileConfig.contextMode;
+  s.addLine(chalk.gray(` model:   ${config.model}  |  provider: ${config.provider}  |  profile: ${app.activeProfile}  |  context: ${modeLabel}`));
+  if (s.pricing) {
+    let priceLine = ` price:   $${(s.pricing.prompt * 1e6).toFixed(2)} / $${(s.pricing.completion * 1e6).toFixed(2)} per 1M tokens (in/out)`;
+    if (s.contextLimit) {
+      priceLine += `  |  context: ${(s.contextLimit / 1000).toFixed(0)}k tokens`;
+    }
+    s.addLine(chalk.gray(priceLine));
+  }
+  s.addLine(chalk.gray(` session: ${s.sessionId}${s.messages.length > 1 ? ` (${s.messages.length - 1} msgs)` : " (new)"}`));
+  s.addLine(chalk.gray(` api:     ${apiUrl(app.actualPort)}`));
+  if (app.securityApi && app.securityApi.token) {
+    s.addLine(chalk.gray(` token:   ${app.securityApi.token.slice(0, 8)}...  (${app.securityApi.policy?.name || "?"} policy)`));
+  } else if (app.securityApi && !app.securityApi.disabled) {
+    s.addLine(chalk.gray(` access:  programs pair with a PIN shown here; /paired lists them  (${app.securityApi.policy?.name || "?"} policy)`));
+  }
+  if (app.mcpStatusList.length) {
+    for (const mc of app.mcpStatusList) {
+      if (mc.connecting) {
+        s.addLine(chalk.yellow(` mcp:     ${mc.name} -- connecting...`));
+      } else if (mc.ok) {
+        s.addLine(chalk.gray(` mcp:     ${mc.name} -- ${mc.tools} tools`));
+      } else {
+        s.addLine(chalk.yellow(` mcp:     ${mc.name} -- offline`));
+      }
+    }
+  }
+  // Ctrl+V is the terminal's own paste and sends nothing for a picture, so
+  // the key that does is named where it will be seen (owner, 2026-10-02:
+  // "I can't paste a picture").
+  s.addLine(chalk.gray(' type /help for commands, "exit" to quit · Alt+V pastes a picture'));
+  s.addLine("");
+}

package/src/ui/input-cursor.js

@@ -0,0 +1,23 @@
+// The real terminal cursor: a thin bar, placed by LineInput (cursorCell in
+// ui/line-edit.js) at the edit position.
+//
+// Owner, 2026-10-01: the drawn inverse block showed up in random places, so it
+// was turned off; with it gone there was no caret at all. A real terminal
+// cursor is what every other console shows, and it is also where IME and
+// dictation tools put their text.
+
+// DECSCUSR: 5 = blinking bar, 0 = the terminal's own default.
+export const CURSOR_BAR = "\x1b[5 q";
+export const CURSOR_DEFAULT = "\x1b[0 q";
+
+/** Row of an Ink DOM node within the live output, the way Ink's layout.js sums it. */
+export function absoluteTop(node) {
+  let y = 0;
+  let current = node;
+  while (current?.parentNode) {
+    if (!current.yogaNode) return null;
+    y += current.yogaNode.getComputedTop();
+    current = current.parentNode;
+  }
+  return current ? y : null;
+}

package/src/ui/last-line.js

@@ -0,0 +1,25 @@
+// The last thing a command printed, as one readable line.
+//
+// Owner, 2026-10-01: a long foreground run_command (a scan, a build) showed
+// only its command and a clock until it finished. Its latest output line is
+// shown on the activity row instead (see run_command in tools/process-tools.js).
+
+// eslint-disable-next-line no-control-regex
+const ANSI = /\x1b\[[0-9;?]*[ -/]*[@-~]|\x1b\][^\x07]*(\x07|\x1b\\)/g;
+
+/**
+ * Last non-empty line of a chunk of output, or null.
+ * Progress bars redraw with \r, so only the text after the last \r counts.
+ */
+export function lastOutputLine(chunk) {
+  const text = String(chunk ?? "").replace(ANSI, "");
+  const lines = text.split("\n");
+  for (let i = lines.length - 1; i >= 0; i--) {
+    const parts = lines[i].split("\r");
+    const shown = parts[parts.length - 1] || parts.filter((p) => p.trim()).pop() || "";
+    // eslint-disable-next-line no-control-regex
+    const clean = shown.replace(/[\x00-\x1f\x7f]/g, "").replace(/\s+/g, " ").trim();
+    if (clean) return clean;
+  }
+  return null;
+}

package/src/ui/line-edit.js

@@ -0,0 +1,135 @@
+// Editing one input line with a cursor (owner, 2026-10-01: the cursor was
+// stuck at the end; arrows, Ctrl+arrows, Home/End did nothing).
+//
+// Pure functions over { value, cursor }. The cursor is a UTF-16 offset that
+// always sits on a code point boundary and never inside a paste/image token:
+// a token moves and deletes as one character.
+
+import stringWidth from "string-width";
+
+const TOKEN_RE = /\[(?:Pasted text #\d+[^\]]*|Image #\d+)\]/g;
+
+/** [start, end) of every token in the value. */
+export function tokenRanges(value) {
+  const out = [];
+  for (const m of String(value || "").matchAll(TOKEN_RE)) out.push([m.index, m.index + m[0].length]);
+  return out;
+}
+
+const isLow = (c) => c >= 0xdc00 && c <= 0xdfff;
+
+function prevPoint(value, i) {
+  if (i <= 0) return 0;
+  let j = i - 1;
+  if (j > 0 && isLow(value.charCodeAt(j))) j--;
+  return j;
+}
+
+function nextPoint(value, i) {
+  if (i >= value.length) return value.length;
+  let j = i + 1;
+  if (j < value.length && isLow(value.charCodeAt(j))) j++;
+  return j;
+}
+
+/** One step left: over a whole token if one ends here. */
+export function moveLeft({ value, cursor }) {
+  const t = tokenRanges(value).find(([s, e]) => e === cursor);
+  return { value, cursor: t ? t[0] : prevPoint(value, cursor) };
+}
+
+/** One step right: over a whole token if one starts here. */
+export function moveRight({ value, cursor }) {
+  const t = tokenRanges(value).find(([s]) => s === cursor);
+  return { value, cursor: t ? t[1] : nextPoint(value, cursor) };
+}
+
+const isWordChar = (ch) => /[\p{L}\p{N}_]/u.test(ch);
+
+/** Ctrl+Left: to the start of the previous word. */
+export function wordLeft({ value, cursor }) {
+  let i = cursor;
+  while (i > 0 && !isWordChar(value[i - 1])) i = moveLeft({ value, cursor: i }).cursor;
+  while (i > 0 && isWordChar(value[i - 1])) i = prevPoint(value, i);
+  return { value, cursor: i };
+}
+
+/** Ctrl+Right: to the end of the next word. */
+export function wordRight({ value, cursor }) {
+  let i = cursor;
+  while (i < value.length && !isWordChar(value[i])) i = moveRight({ value, cursor: i }).cursor;
+  while (i < value.length && isWordChar(value[i])) i = nextPoint(value, i);
+  return { value, cursor: i };
+}
+
+/** Text typed or pasted at the cursor. */
+export function insertAt({ value, cursor }, text) {
+  return { value: value.slice(0, cursor) + text + value.slice(cursor), cursor: cursor + text.length };
+}
+
+/** Backspace: the character, or the whole token, before the cursor. */
+export function backspace({ value, cursor }) {
+  if (cursor <= 0) return { value, cursor };
+  const t = tokenRanges(value).find(([, e]) => e === cursor);
+  const from = t ? t[0] : prevPoint(value, cursor);
+  return { value: value.slice(0, from) + value.slice(cursor), cursor: from };
+}
+
+/** Delete: the character, or the whole token, after the cursor. */
+export function deleteForward({ value, cursor }) {
+  if (cursor >= value.length) return { value, cursor };
+  const t = tokenRanges(value).find(([s]) => s === cursor);
+  const to = t ? t[1] : nextPoint(value, cursor);
+  return { value: value.slice(0, cursor) + value.slice(to), cursor };
+}
+
+/** Ctrl+W: the word before the cursor and the space after it. */
+export function deleteWordBack(state) {
+  const { cursor: to } = state;
+  const { cursor: from } = wordLeft(state);
+  return { value: state.value.slice(0, from) + state.value.slice(to), cursor: from };
+}
+
+/** Snap a cursor out of a token and onto a code point boundary. */
+export function clampCursor(value, cursor) {
+  let c = Math.max(0, Math.min(cursor, value.length));
+  const t = tokenRanges(value).find(([s, e]) => c > s && c < e);
+  if (t) c = t[1];
+  if (c > 0 && c < value.length && isLow(value.charCodeAt(c))) c--;
+  return c;
+}
+
+/**
+ * The value broken into rows of `width` columns, character by character (no
+ * word wrap), with explicit line breaks kept. The input draws exactly these
+ * rows, so the cursor position computed from them is exact.
+ */
+export function wrapRows(value, width) {
+  const w = Math.max(1, width);
+  const rows = [];
+  for (const line of String(value).split("\n")) {
+    let row = "";
+    let cols = 0;
+    for (const ch of line) {
+      const cw = stringWidth(ch);
+      if (cols + cw > w) { rows.push(row); row = ""; cols = 0; }
+      row += ch;
+      cols += cw;
+    }
+    rows.push(row);
+  }
+  return rows;
+}
+
+/**
+ * Where the cursor is drawn, relative to the input's first row: the column
+ * after `promptWidth`, and the row.
+ */
+export function cursorCell(value, cursor, width) {
+  const before = wrapRows(String(value).slice(0, cursor), width);
+  let row = before.length - 1;
+  let col = stringWidth(before[row]);
+  // At the very edge the next character starts a new row.
+  if (col >= width) { row++; col = 0; }
+  return { row, col };
+}