jaitus 0.3.21 → 0.3.23

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "jaitus",
-  "version": "0.3.21",
+  "version": "0.3.23",
   "description": "Jaitus — a coding agent in your terminal.",
   "type": "module",
   "bin": {
@@ -16,7 +16,7 @@
     "node": ">=20"
   },
   "scripts": {
-    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/service-notices.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js && node tests/compaction.js && node tests/copy-clean.js && node tests/parallel-tools.js && node tests/plan-percent.js && node tests/project-identity.js",
+    "test": "node tests/source-sanity.js && node tests/react-build.js && node tests/stalls.js && node tests/clipboard-write.js && node tests/rewind-images.js && node tests/rules.js && node tests/run.js && node tests/commands.js && node tests/login.js && node tests/session.js && node tests/openUrl.js && node tests/ink-tui.js && node tests/tui-render.js && node tests/mouse-e2e.js && node tests/environment.js && node tests/update.js && node tests/service-notices.js && node tests/continuation.js && node tests/steps.js && node tests/files.js && node tests/processes.js && node tests/security.js && node tests/context-budget.js && node tests/context-trim.js && node tests/compaction.js && node tests/copy-clean.js && node tests/parallel-tools.js && node tests/plan-percent.js && node tests/orb.js && node tests/update-required.js && node tests/select-scroll.js && node tests/project-identity.js",
     "preview": "node scripts/tui-preview.js",
     "prepublishOnly": "npm test"
   },

package/src/api.js

@@ -94,7 +94,7 @@ export function createClient() {
 
   // x-jaitus-features: what this build understands, so the gateway can use newer error
   // codes (a used-up usage window) without an older CLI reading them as "went wrong".
-  const base = { 'Content-Type': 'application/json', 'user-agent': `jaitus-cli/${version()}`, 'x-jaitus-features': 'usage-window plan-expired' };
+  const base = { 'Content-Type': 'application/json', 'user-agent': `jaitus-cli/${version()}`, 'x-jaitus-features': 'usage-window plan-expired update-required' };
   // x-jaitus-device: this computer's hashed identifiers (machine.js), which the free
   // tier is limited by. Built once per process.
   const headers = (token) => ({ ...base, 'x-jaitus-device': machineHeader(), authorization: `Bearer ${token}` });

package/src/errors.js

@@ -16,6 +16,8 @@ const CATALOG = {
   free_machine_limit: { title: 'No free prompts on this account', hint: 'Subscribe at jaitus.com/billing to keep using Jaitus on this account.' },
   free_needs_check: { title: 'Unlock your free prompts', hint: 'A one-time ₹1 UPI check at jaitus.com/billing (refunded). Or subscribe.' },
   free_needs_cli: { title: 'Update Jaitus for free prompts', hint: 'Run npm i -g jaitus, then try again.' },
+  // This version is below what Jaitus now requires; the message names both versions.
+  update_required: { title: 'Update Jaitus to continue', hint: 'Run npm i -g jaitus@latest, then start jaitus again.' },
   free_request_too_large: { title: 'Too large for the free plan', hint: 'Run /compact or start a new session, or subscribe at jaitus.com/billing.' },
   plan_limit_reached: { title: 'Monthly usage used up', hint: 'To keep going now, switch plans at jaitus.com/billing — what is left of this plan carries over. Buying another 30 days of the same plan adds days but does not refill this month. /usage shows where you are.' },
   rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },

package/src/serviceNotice.js

@@ -75,6 +75,15 @@ export function lineFor(item, where = statusAddress()) {
     if (until) return `Jaitus is down for maintenance until ${until}. Updates: ${where}`;
     return `Jaitus is down for maintenance. Updates: ${where}`;
   }
+  if (item.kind === 'offer') {
+    // An offer from Admin → Offers: its headline, the short line under it, the code if it
+    // has one, and where to take it.
+    if (!title) return null;
+    const details = dropStop(clean(item.details, 90));
+    const code = clean(item.code, 30);
+    const billing = where.replace(/\/status$/, '/billing');
+    return `${title}${details ? ` — ${details}` : ''}.${code ? ` Code ${code}.` : ''} ${billing}`;
+  }
   if (item.kind === 'maintenance' && item.phase === 'upcoming') {
     const when = clean(item.window, 60);
     if (!when) return null;

package/src/tui/orb.js

@@ -0,0 +1,41 @@
+// ─── The orb ────────────────────────────────────────────────────────────────────
+//
+// The power source the website draws its energy from, in two terminal cells: a ring of
+// braille dots spinning round a core that crackles, flaring white every couple of
+// seconds. It replaces the one-cell spinner wherever work is running, so the terminal
+// shows the same thing the site does — the work is being powered by the orb.
+//
+// Two cells are a 4×4 grid of dots. The ring is the eight dots on the edge; a two-dot
+// gap travels round it, which is what reads as spin. The four centre dots are the core.
+// Pure function of the tick, so it costs nothing beyond the shared animation timer, and
+// frame 0 is a sensible still for reduced motion.
+
+// Braille bit for column c (0..1) and row r (0..3) inside one cell.
+const BIT = [[0x01, 0x02, 0x04, 0x40], [0x08, 0x10, 0x20, 0x80]];
+
+// The ring, clockwise from the top: [column 0..3, row 0..3] on the 4×4 grid.
+const RING = [[1, 0], [2, 0], [3, 1], [3, 2], [2, 3], [1, 3], [0, 2], [0, 1]];
+const CORE = [[1, 1], [2, 1], [1, 2], [2, 2]];
+
+function cells(dots) {
+  const bits = [0, 0];
+  for (const [x, y] of dots) bits[x >> 1] |= BIT[x & 1][y];
+  return String.fromCharCode(0x2800 + bits[0], 0x2800 + bits[1]);
+}
+
+/**
+ * The orb at a given tick. `level` is 0 (steady), 1 (the core crackling) or 2 (a surge:
+ * every dot lit) so the caller can colour it — brand, lighter, near-white.
+ */
+export function orbFrame(tick) {
+  const n = Math.max(0, Math.floor(tick));
+  if (n % 30 < 2 && n >= 30) return { text: cells([...RING, ...CORE]), level: 2 };
+  const gap = n % RING.length;
+  const ring = RING.filter((_, i) => i !== gap && i !== (gap + 1) % RING.length);
+  // The core crackles on an irregular beat — a fixed pattern of primes rather than
+  // random, so a frame is reproducible in tests and previews.
+  const crackle = n % 11 === 3 || n % 11 === 4 || n % 7 === 0;
+  return { text: cells(crackle ? [...ring, ...CORE] : ring), level: crackle ? 1 : 0 };
+}
+
+export const ORB_STILL = orbFrame(0).text;

package/src/tui/widgets.js

@@ -13,6 +13,7 @@
 import React from 'react';
 import { Box, Text, useAnimation } from 'ink';
 import { palette, mix, ramp } from './theme.js';
+import { orbFrame } from './orb.js';
 
 const h = React.createElement;
 
@@ -59,6 +60,19 @@ export function Spinner({ kind = 'braille', color, interval = 80 }) {
   return h(Text, { color: color || p.brand }, active ? frames[frame % frames.length] : frames[0]);
 }
 
+/**
+ * The orb (tui/orb.js) as the working indicator: two cells, a spinning ring round a
+ * crackling core that surges white. Same shared timer as every other widget.
+ */
+export function OrbSpinner({ interval = 90 }) {
+  const p = palette();
+  const active = motionOn();
+  const { frame } = useAnimation({ interval, isActive: active });
+  const f = orbFrame(active ? frame : 0);
+  const color = f.level === 2 ? mix(p.brand, p.text, 0.75) : f.level === 1 ? p.brandSoft : p.brand;
+  return h(Text, { color }, f.text);
+}
+
 /**
  * Text with a highlight travelling through it.
  *

package/src/tui-ink.js

@@ -28,7 +28,7 @@ import { Box, Spacer, Text, render, useAnimation, useApp, useCursor, useInput, u
 import { palette, resetPalette, mix, ramp } from './tui/theme.js';
 import { makeEntry, rowsFor, invalidate, expandable } from './tui/entries.js';
 import { plain, stringWidth, truncateRow, wrapRow, rowText, inverseRange, copyText, softJoin, isDecorationRow } from './tui/ansi.js';
-import { Spinner, Shimmer, GradientText, FlowingRule, Meter, Elapsed, CursorRow, Rows, Row, Reveal, motionOn, publishSettings } from './tui/widgets.js';
+import { Spinner, OrbSpinner, Shimmer, GradientText, FlowingRule, Meter, Elapsed, CursorRow, Rows, Row, Reveal, motionOn, publishSettings } from './tui/widgets.js';
 import { wordRows, wordSize } from './tui/wordmark.js';
 import { enableMouse, disableMouse, parseMouse, isMouse, isMouseFragment, createHitMap } from './tui/mouse.js';
 import { openUrl } from './open.js';
@@ -39,6 +39,7 @@ import { badgeText, badgeTop, turnShareText } from './planView.js';
 
 const h = React.createElement;
 const clamp = (value, min, max) => Math.max(min, Math.min(max, value));
+
 const ascii = () => process.env.JAITUS_ASCII === '1';
 const g = (uni, plainText) => (ascii() ? plainText : uni);
 
@@ -419,8 +420,9 @@ function layoutTranscript(state, width, height, top) {
 
   // The drag handler needs the text under the pointer, and it must be the text actually
   // on screen rather than the transcript's idea of it.
-  state.screen = { top: screenTop, left: 2, rows: visible };
+  state.screen = { top: screenTop, left: 2, rows: visible, first, all: rows, height };
   state.totalRows = rows.length;
+  anchorSelection(state);
 
   // The sticky header names the prompt whose answer you are looking at — the last one
   // that has scrolled off the top. Scroll far enough that the prompt itself is back on
@@ -554,6 +556,41 @@ const URL_IN_TEXT = /https?:\/\/[^\s<>"'`]+/g;
 // background colour, then CSI ? … c device attributes — alone or run together.
 export const TERMINAL_REPLY = /^(?=[\x1b\][])(?:\x1b?\]11;rgb:[0-9a-f]{1,4}\/[0-9a-f]{1,4}\/[0-9a-f]{1,4}(?:\x07|\x1b\\)?)?(?:\x1b?\[\?[0-9;]*c)?$/i;
 
+/**
+ * Keep a drag selection on the TEXT while the view scrolls.
+ *
+ * A selection that starts in the transcript records the row of the whole transcript it
+ * started on, so scrolling (the wheel, or holding the pointer past an edge) moves the
+ * highlight with the text instead of leaving it on the same screen cells over different
+ * text. While the button is held the other end follows the pointer: whichever row is under
+ * it now, clamped to what is on screen — so with the pointer above the conversation it is
+ * the top row, and the selection grows as more scrolls in. Screen positions are derived
+ * from rows here, every frame, so painting and copying read the same thing.
+ */
+function selectionFirstRow(state) {
+  const s = state.screen;
+  if (!s?.all) return 0;
+  const total = s.all.length;
+  const offset = state.viewingTranscript ? clamp(state.transcriptOffset || 0, 0, Math.max(0, total - s.height)) : 0;
+  return Math.max(0, total - offset - s.height);
+}
+
+function anchorSelection(state) {
+  const sel = state.selection;
+  const s = state.screen;
+  if (!sel?.anchor || !sel.focus || sel.anchor.row == null || !s?.all) return;
+  const first = selectionFirstRow(state);
+  const shown = Math.min(s.height, s.all.length - first);
+  if (sel.dragging && sel.pointer) {
+    const lastRow = first + Math.max(0, shown - 1);
+    const row = clamp(first + (sel.pointer.y - s.top), first, lastRow);
+    const x = sel.pointer.y < s.top ? s.left : sel.pointer.y > s.top + shown - 1 ? 1e4 : sel.pointer.x;
+    sel.focus = { x, row };
+  }
+  sel.anchor.y = s.top + sel.anchor.row - first;
+  if (sel.focus.row != null) sel.focus.y = s.top + sel.focus.row - first;
+}
+
 /**
  * Draw the drag selection.
  *
@@ -590,7 +627,7 @@ function WorkBar({ state, width }) {
   const label = plain(state.status) || 'Working';
   const narrow = width < 70;
   return h(Box, { flexDirection: 'row', paddingX: 1 },
-    h(Spinner, { kind: ascii() ? 'ascii' : 'braille' }),
+    ascii() ? h(Spinner, { kind: 'ascii' }) : h(OrbSpinner),
     h(Text, null, ' '),
     h(Shimmer, { from: p.brand, to: p.brandSoft }, truncatePlain(label, Math.max(12, width - (narrow ? 22 : 46)))),
     h(Spacer),
@@ -1772,6 +1809,43 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     notifyNow();
   }
 
+  /** The row of the whole transcript at screen line `y`, or null off the transcript. */
+  function transcriptRowAt(y) {
+    const s = state.screen;
+    if (!s?.all || state.dialog || state.panel) return null;
+    if (y < s.top || y > s.top + s.rows.length - 1) return null;
+    return selectionFirstRow(state) + (y - s.top);
+  }
+
+  // Holding a drag past the top or bottom of the conversation scrolls it, faster the
+  // further out the pointer is, until the button is released or the pointer comes back —
+  // what every terminal does. Terminals only report the mouse when it moves, so a pointer
+  // held still past the edge needs this timer to keep going.
+  let edgeTimer = null;
+  function stopEdgeScroll() { if (edgeTimer) { clearInterval(edgeTimer); edgeTimer = null; } }
+  function edgeOut() {
+    const sel = state.selection;
+    const s = state.screen;
+    if (!sel?.dragging || !sel.pointer || !s?.rows?.length) return 0;
+    const bottom = s.top + s.rows.length - 1;
+    if (sel.pointer.y < s.top) return s.top - sel.pointer.y;          // above: positive = back into history
+    if (sel.pointer.y > bottom) return -(sel.pointer.y - bottom);     // below: towards the newest
+    return 0;
+  }
+  function edgeScroll() {
+    if (!edgeOut()) return stopEdgeScroll();
+    if (edgeTimer) return;
+    edgeTimer = setInterval(() => {
+      const out = edgeOut();
+      if (!out) return stopEdgeScroll();
+      const step = Math.min(4, Math.abs(out));
+      scroll(out > 0 ? step : -step);
+      anchorSelection(state);
+      notifyNow();
+    }, 60);
+    edgeTimer.unref?.();
+  }
+
   // ── selecting text in the composer ──
   //
   // The composer is a text field, so it selects like one: drag with the mouse (copied on
@@ -1857,15 +1931,28 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
     // out or replaced by what it stands for, and a wrapped line rejoins the line it was
     // wrapped from (tui/ansi.js copyText / softJoin).
     const pieces = [];
-    screen.rows.forEach((row, index) => {
-      const y = screen.top + index;
-      if (y < from.y || y > to.y) return;
+    // `startX` / `endX` are screen columns of the first and last selected row (or null for
+    // "the whole row").
+    const take = (row, startX, endX) => {
       if (isDecorationRow(row)) return;
       const len = rowText(row).length;
-      const start = y === from.y ? Math.max(0, from.x - screen.left) : 0;
-      const end = y === to.y ? Math.max(0, to.x - screen.left + 1) : len;
+      const start = startX == null ? 0 : Math.max(0, startX - screen.left);
+      const end = endX == null ? len : Math.min(len, Math.max(0, endX - screen.left + 1));
       pieces.push({ text: copyText(row, start, end), join: pieces.length ? softJoin(row) : null });
-    });
+    };
+    if (a.row != null && b.row != null && screen.all) {
+      // Anchored to the text: everything selected, including what has scrolled off screen.
+      const [f, t] = (a.row < b.row || (a.row === b.row && a.x <= b.x)) ? [a, b] : [b, a];
+      for (let r = f.row; r <= t.row; r++) {
+        if (screen.all[r]) take(screen.all[r], r === f.row ? f.x : null, r === t.row ? t.x : null);
+      }
+    } else {
+      screen.rows.forEach((row, index) => {
+        const y = screen.top + index;
+        if (y < from.y || y > to.y) return;
+        take(row, y === from.y ? from.x : null, y === to.y ? to.x : null);
+      });
+    }
     let out = '';
     pieces.forEach((piece, i) => {
       // A word cut mid-way (join '') keeps every character on both sides; anywhere else
@@ -1912,6 +1999,7 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
   }
 
   function clearSelection() {
+    stopEdgeScroll();
     if (!state.selection) return;
     state.selection = null;
     notifyNow();
@@ -2141,20 +2229,33 @@ export function createTui({ slashCommands = [], fileProvider = null, meta = {},
         // A press starts a possible drag AND a possible click. Which it was is only
         // known on release, so nothing is dispatched yet — dispatching here made every
         // attempt to select text also press whatever was under the cursor.
-        pressedAt = { x: event.x, y: event.y };
+        pressedAt = { x: event.x, y: event.y, row: transcriptRowAt(event.y) };
         dragged = false;
         clearSelection();
         return;
       }
       if (event.kind === 'drag' && pressedAt) {
         if (event.x !== pressedAt.x || event.y !== pressedAt.y) dragged = true;
-        state.selection = { anchor: pressedAt, focus: { x: event.x, y: event.y } };
+        if (pressedAt.row == null) {
+          state.selection = { anchor: { x: pressedAt.x, y: pressedAt.y }, focus: { x: event.x, y: event.y } };
+          return notifyNow();
+        }
+        // Anchored to the text, the other end on the pointer (anchorSelection), and the
+        // view scrolls on its own while the pointer is held past either edge.
+        const sel = state.selection?.dragging ? state.selection
+          : { anchor: { x: pressedAt.x, y: pressedAt.y, row: pressedAt.row }, focus: { x: event.x, y: event.y }, dragging: true };
+        sel.pointer = { x: event.x, y: event.y };
+        state.selection = sel;
+        anchorSelection(state);
+        edgeScroll();
         return notifyNow();
       }
       if (event.kind === 'up') {
         const start = pressedAt;
         pressedAt = null;
+        stopEdgeScroll();
         if (!start) return;
+        if (state.selection?.dragging) { anchorSelection(state); state.selection.dragging = false; }
         if (dragged) { dragged = false; void finishSelection(); return; }
         const now = Date.now();
         const again = lastClick && now - lastClick.at < 450 && lastClick.y === start.y && Math.abs(lastClick.x - start.x) <= 1;

package/src/ui.js

@@ -18,6 +18,7 @@ import path from 'node:path';
 import os from 'node:os';
 import { loadSettings, HOME } from './config.js';
 import { terminalBackground } from './terminal.js';
+import { orbFrame } from './tui/orb.js';
 
 // Read without re-entering config's write paths; failures mean defaults.
 function loadSettingsFile() { return loadSettings(); }
@@ -266,9 +267,8 @@ export function spinner(text) {
     out(`${c.dim(glyph('…', '...'))} ${text}`);
     return { stop: () => {}, update: () => {} };
   }
-  const frames = unicode()
-    ? ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏']
-    : ['|', '/', '-', '\\'];
+  // The orb (tui/orb.js) where the terminal can draw braille; a plain bar where it can't.
+  const frames = unicode() ? null : ['|', '/', '-', '\\'];
   let i = 0;
   let label = text;
   // stop() is called more than once per spinner: runAgent stops it when the first
@@ -285,7 +285,11 @@ export function spinner(text) {
   const tick = () => {
     if (stopped) return;
     const n = i++;
-    write(`\r\x1b[2K${c.brand(frames[n % frames.length])} ${sweep(label, n)}`);
+    const glyphNow = frames ? c.brand(frames[n % frames.length]) : (() => {
+      const f = orbFrame(n);
+      return f.level ? c.shimmer(f.text) : c.brand(f.text);
+    })();
+    write(`\r\x1b[2K${glyphNow} ${sweep(label, n)}`);
   };
   tick();
   const timer = setInterval(tick, 80);