jaitus 0.3.0

package/src/skills.js

@@ -0,0 +1,62 @@
+// ─── Project skills ────────────────────────────────────────────────────────────
+//
+// A skill is a small, discoverable workflow stored as SKILL.md — the open Agent Skills
+// format: a short YAML frontmatter description plus markdown instructions. Skills
+// already written for other agents (in .claude/skills) are picked up too; they are
+// instructions only and never run anything by themselves.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const MAX_SKILL = 32_000;
+
+function parse(file, scope) {
+  try {
+    const raw = fs.readFileSync(file, 'utf8');
+    const match = raw.match(/^---\s*\n([\s\S]*?)\n---\s*\n([\s\S]*)$/);
+    const frontmatter = match?.[1] || '';
+    const content = (match?.[2] || raw).trim();
+    const description = frontmatter.match(/^description:\s*(.+)$/mi)?.[1]?.trim()
+      || `Run the ${path.basename(path.dirname(file))} workflow.`;
+    return {
+      name: path.basename(path.dirname(file)),
+      description: description.replace(/^['"]|['"]$/g, ''),
+      content: content.slice(0, MAX_SKILL),
+      file,
+      scope,
+    };
+  } catch {
+    return null;
+  }
+}
+
+function fromRoot(root, scope) {
+  if (!fs.existsSync(root)) return [];
+  let dirs;
+  try { dirs = fs.readdirSync(root, { withFileTypes: true }); } catch { return []; }
+  return dirs.filter((entry) => entry.isDirectory())
+    .map((entry) => parse(path.join(root, entry.name, 'SKILL.md'), scope))
+    .filter(Boolean);
+}
+
+/** Project skills win over personal skills with the same name. */
+export function discoverSkills(cwd) {
+  const roots = [
+    [path.join(cwd, '.jaitus', 'skills'), 'project'],
+    [path.join(cwd, '.claude', 'skills'), 'project'],
+    [path.join(os.homedir(), '.jaitus', 'skills'), 'user'],
+    [path.join(os.homedir(), '.claude', 'skills'), 'user'],
+  ];
+  const skills = new Map();
+  for (const [root, scope] of roots) {
+    for (const skill of fromRoot(root, scope)) if (!skills.has(skill.name)) skills.set(skill.name, skill);
+  }
+  return Object.fromEntries([...skills.entries()].sort(([a], [b]) => a.localeCompare(b)));
+}
+
+export function skillCatalog(skills) {
+  const entries = Object.values(skills || {});
+  if (!entries.length) return '';
+  return `\n\nAvailable project workflows (invoke with /<name>):\n${entries.map((s) => `- /${s.name}: ${s.description}`).join('\n')}`;
+}

package/src/term-sim.js

@@ -0,0 +1,103 @@
+// ─── A tiny ANSI terminal simulator (dev/test aid, not part of the CLI runtime) ───
+//
+// It maintains a real character grid and a real cursor, and interprets the subset of
+// ANSI that tui.js uses: CUP (\x1b[r;cH), EL (\x1b[0K), ED (\x1b[2J), DECAWM (?7l/?7h),
+// and \n / \r. Anything else is stripped. The point: tests can assert that after any
+// sequence of writes, the cursor sits exactly where the layout says it should, and
+// that content never drifts — the exact class of bug that shipped twice.
+
+export function createTerminalSim({ cols = 80, rows = 24 } = {}) {
+  const state = { cols, rows, autowrap: true };
+  const grid = () => state.grid;
+
+  function reset() {
+    state.grid = Array.from({ length: rows }, () => Array.from({ length: cols }, () => ' '));
+    state.cx = 0; state.cy = 0;
+  }
+  reset();
+
+  function scrollUp() {
+    state.grid.shift();
+    state.grid.push(Array.from({ length: cols }, () => ' '));
+  }
+
+  function putChar(ch) {
+    if (ch === '\n') {
+      state.cx = 0;
+      if (state.cy >= rows - 1) { if (state.autowrap) scrollUp(); }
+      else state.cy += 1;
+      return;
+    }
+    if (ch === '\r') { state.cx = 0; return; }
+    if (state.cx >= cols) {
+      // DECAWM off: characters past the last column are dropped in place.
+      if (!state.autowrap) return;
+      if (state.cy >= rows - 1) { scrollUp(); state.cx = 0; }
+      else { state.cy += 1; state.cx = 0; }
+    }
+    state.grid[state.cy][state.cx] = ch;
+    state.cx += 1;
+  }
+
+  return {
+    get cx() { return state.cx; },
+    get cy() { return state.cy; },
+    get cols() { return state.cols; },
+    get rows() { return state.rows; },
+    get grid() { return grid(); },
+    reset,
+
+    /** Physical resize: the grid itself changes shape, like real terminal memory. */
+    resize({ cols: nextCols = cols, rows: nextRows = rows } = {}) {
+      state.cols = nextCols;
+      state.rows = nextRows;
+      state.grid = state.grid.map((r) => {
+        if (nextCols >= cols) return [...r, ...Array.from({ length: nextCols - cols }, () => ' ')];
+        return r.slice(0, nextCols);
+      });
+      while (state.grid.length > nextRows) state.grid.shift();
+      while (state.grid.length < nextRows) state.grid.unshift(Array.from({ length: nextCols }, () => ' '));
+      state.cx = Math.min(state.cx, nextCols - 1);
+      state.cy = Math.min(state.cy, nextRows - 1);
+    },
+
+    /** Feed a chunk of ANSI output. */
+    write(data) {
+      let i = 0;
+      const s = String(data);
+      while (i < s.length) {
+        const ch = s[i];
+        if (ch === '\x1b' && s[i + 1] === '[') {
+          const m = /^\x1b\[([0-9;?]*)([A-Za-z])/.exec(s.slice(i));
+          if (m) {
+            const [, params, cmd] = m;
+            i += m[0].length;
+            const nums = params.replace('?', '').split(';').filter(Boolean).map(Number);
+            if (cmd === 'H' || cmd === 'f') {
+              state.cy = Math.min(rows, Math.max(1, nums[0] || 1)) - 1;
+              state.cx = Math.min(cols, Math.max(1, nums[1] || 1)) - 1;
+            } else if (cmd === 'J') {
+              const mode = nums[0] || 0;
+              if (mode === 2) reset();
+            } else if (cmd === 'K') {
+              for (let x = state.cx; x < cols; x++) state.grid[state.cy][x] = ' ';
+            } else if (cmd === 'h' || cmd === 'l') {
+              if (params.includes('7')) state.autowrap = cmd === 'h';
+            }
+            continue;
+          }
+        }
+        putChar(ch);
+        i += 1;
+      }
+    },
+
+    /** Plain text of one row (1-based), trailing whitespace trimmed. */
+    rowText(r) { return state.grid[r - 1].join('').trimEnd(); },
+
+    /** Visible text with ANSI stripped, for "does X appear on screen" checks. */
+    text() { return state.grid.map((r) => r.join('')).join('\n').replace(/\n+$/, ''); },
+
+    screen() { return state.grid.map((r) => r.join('').trimEnd()); },
+  };
+}

package/src/terminal.js

@@ -0,0 +1,90 @@
+// ─── Talking to the terminal itself ─────────────────────────────────────────────
+//
+// The only portable way to know what a terminal can do is to ASK it: send the
+// Primary Device Attributes request (`CSI c`) and read the reply that the
+// terminal types back on stdin. ANY well-formed DA reply proves escape
+// processing works (colors, alt-screen, mouse); silence means a legacy
+// console, and the CLI degrades honestly (plain text, classic renderer)
+// instead of painting codes that render as nothing. Sixel capability is
+// attribute 4 (";4" in the report).
+//
+// Done inline as a subprocess-style handshake: raw mode for the duration so
+// the reply doesn't echo, restored on the way out. Cached per process;
+// `probeDevice` does the work once.
+
+import fs from 'node:fs';
+
+const state = { done: false, vt: false, sixel: false };
+let pending = null;
+
+/** A device-attributes reply: CSI [? params c. */
+const DA_REPLY = /\x1b\[[?0-9;]*c/;
+/** The replies that mean "yes, images": xterm's CSI ? 6 2 ; ... c and kin. */
+const SIXEL_ATTR = /;4[;c]/;
+
+// 300ms was too tight. A terminal over SSH, one under a multiplexer, or one whose reply
+// queues behind anything else on stdin misses it — and a missed reply used to be read as
+// "this console cannot do escape sequences", which turned the whole UI to ASCII twins.
+// Startup does not wait on this: the probe runs concurrently with the model lookup.
+export function probeDevice({ timeoutMs = 900 } = {}) {
+  if (state.done) return Promise.resolve({ vt: state.vt, sixel: state.sixel });
+  if (pending) return pending;
+  if (!process.stdout.isTTY || !process.stdin.isTTY) {
+    state.done = true;
+    return Promise.resolve({ vt: false, sixel: false });
+  }
+
+  pending = new Promise((resolve) => {
+    let finished = false;
+    let buffer = '';
+    let wasRaw = false;
+    try { wasRaw = !!process.stdin.isRaw; } catch { /* not a TTY */ }
+    const finish = () => {
+      if (finished) return;
+      finished = true;
+      clearTimeout(timer);
+      try { process.stdin.setRawMode(wasRaw); } catch { /* already gone */ }
+      try { process.stdin.pause(); } catch { /* already gone */ }
+      process.stdin.removeListener('data', onData);
+      const vt = DA_REPLY.test(buffer);
+      state.done = true;
+      state.vt = vt;
+      state.sixel = vt && SIXEL_ATTR.test(buffer);
+      pending = null;
+      resolve({ vt: state.vt, sixel: state.sixel });
+    };
+
+    const onData = (chunk) => {
+      buffer += String(chunk);
+      if (DA_REPLY.test(buffer)) finish();
+    };
+
+    const timer = setTimeout(finish, timeoutMs);
+
+    try {
+      process.stdin.setRawMode(true);
+      process.stdin.resume();
+      process.stdin.on('data', onData);
+      // Ask on stdout. The reply comes back through stdin as if typed.
+      fs.writeSync(1, '\x1b[c');
+    } catch {
+      finish();
+    }
+  });
+  return pending;
+}
+
+/** Legacy wrapper: true when this terminal shows sixel images. */
+export async function probeAsync({ timeoutMs = 400 } = {}) {
+  const { sixel } = await probeDevice({ timeoutMs });
+  return sixel;
+}
+
+/** Cached result; call once at startup (await probeDevice()) before first banner. */
+export function sixelSupported() {
+  return state.sixel;
+}
+
+export function probeDone() {
+  return state.done;
+}

package/src/tui/ansi.js

@@ -0,0 +1,287 @@
+// ─── ANSI in, styled spans out ──────────────────────────────────────────────────
+//
+// Half the CLI predates the app view and prints strings that already carry colour —
+// the tool marks, the red ✗, the dim timings. The previous renderer stripped all of it
+// and drew the result in one flat foreground, which is why a correct, carefully
+// coloured line arrived on screen as grey text.
+//
+// Rather than rewrite every call site, this parses the escape codes back into the
+// style objects Ink understands. Nothing loses its colour on the way in, and code that
+// wants richer output can emit structured rows directly instead.
+//
+// A span is `{ t, color, backgroundColor, bold, dim, italic, underline, inverse,
+// strikethrough }`. A row is an array of spans. Everything downstream — wrapping,
+// measuring, the transcript — works in rows of spans.
+
+const SGR = /\x1B\[([0-9;]*)m/g;
+// Anything that is NOT SGR: cursor moves, erases, OSC. Dropped outright — the app view
+// owns the cursor and a stray escape would corrupt the frame.
+//
+// The final-byte class is split around `m` on purpose. A CSI matcher written as the
+// obvious `[@-~]` also matches SGR, so stripping "other" escapes first silently removes
+// every colour in the string and the whole parser below then finds nothing to style.
+const OTHER_ESC = /\x1B(?:\[[0-?]*[ -/]*[@-l]|\[[0-?]*[ -/]*[n-~]|\][^\x07\x1B]*(?:\x07|\x1B\\)|[@-Z\\-_])/g;
+
+const BASIC = [
+  '#0b0f14', '#ff6b6b', '#3fb950', '#d9a441', '#5aa9ff', '#b392f0', '#56d4dd', '#c9d1d9',
+  '#5d6e82', '#ff8f8f', '#6fd47c', '#e8c06f', '#85c2ff', '#cbb0f7', '#87e6ec', '#ffffff',
+];
+
+/** xterm-256 index → hex. The 6×6×6 cube and the 24-step grey ramp, computed. */
+export function xterm256(n) {
+  const i = Number(n);
+  if (!Number.isFinite(i) || i < 0 || i > 255) return null;
+  if (i < 16) return BASIC[i];
+  if (i < 232) {
+    const c = i - 16;
+    const steps = [0, 95, 135, 175, 215, 255];
+    const r = steps[Math.floor(c / 36) % 6];
+    const g = steps[Math.floor(c / 6) % 6];
+    const b = steps[c % 6];
+    return `#${[r, g, b].map((v) => v.toString(16).padStart(2, '0')).join('')}`;
+  }
+  const v = 8 + (i - 232) * 10;
+  return `#${v.toString(16).padStart(2, '0').repeat(3)}`;
+}
+
+const EMPTY = Object.freeze({});
+
+function applyCodes(style, codes) {
+  const next = { ...style };
+  for (let i = 0; i < codes.length; i++) {
+    const n = Number(codes[i]);
+    if (Number.isNaN(n)) continue;
+    if (n === 0) { for (const k of Object.keys(next)) delete next[k]; continue; }
+    if (n === 1) { next.bold = true; continue; }
+    if (n === 2) { next.dimColor = true; continue; }
+    if (n === 3) { next.italic = true; continue; }
+    if (n === 4) { next.underline = true; continue; }
+    if (n === 7) { next.inverse = true; continue; }
+    if (n === 9) { next.strikethrough = true; continue; }
+    if (n === 22) { delete next.bold; delete next.dimColor; continue; }
+    if (n === 23) { delete next.italic; continue; }
+    if (n === 24) { delete next.underline; continue; }
+    if (n === 27) { delete next.inverse; continue; }
+    if (n === 29) { delete next.strikethrough; continue; }
+    if (n === 39) { delete next.color; continue; }
+    if (n === 49) { delete next.backgroundColor; continue; }
+    if (n >= 30 && n <= 37) { next.color = BASIC[n - 30]; continue; }
+    if (n >= 90 && n <= 97) { next.color = BASIC[n - 90 + 8]; continue; }
+    if (n >= 40 && n <= 47) { next.backgroundColor = BASIC[n - 40]; continue; }
+    if (n >= 100 && n <= 107) { next.backgroundColor = BASIC[n - 100 + 8]; continue; }
+    if (n === 38 || n === 48) {
+      const key = n === 38 ? 'color' : 'backgroundColor';
+      const mode = Number(codes[i + 1]);
+      if (mode === 5) {
+        const hex = xterm256(codes[i + 2]);
+        if (hex) next[key] = hex;
+        i += 2;
+      } else if (mode === 2) {
+        const [r, g, b] = [codes[i + 2], codes[i + 3], codes[i + 4]].map((v) => Number(v) || 0);
+        next[key] = `#${[r, g, b].map((v) => Math.max(0, Math.min(255, v)).toString(16).padStart(2, '0')).join('')}`;
+        i += 4;
+      }
+      continue;
+    }
+  }
+  return next;
+}
+
+/**
+ * One ANSI string → rows of spans. Newlines split rows; tabs become four spaces so
+ * column maths downstream stays honest.
+ */
+export function ansiToRows(value) {
+  const input = String(value ?? '').replace(/\r\n?/g, '\n').replace(OTHER_ESC, '').replace(/\t/g, '    ');
+  const rows = [[]];
+  let style = EMPTY;
+  let last = 0;
+  SGR.lastIndex = 0;
+
+  const push = (text) => {
+    if (!text) return;
+    const parts = text.split('\n');
+    for (let i = 0; i < parts.length; i++) {
+      if (i > 0) rows.push([]);
+      if (parts[i]) rows[rows.length - 1].push({ t: parts[i], ...style });
+    }
+  };
+
+  for (let m = SGR.exec(input); m; m = SGR.exec(input)) {
+    push(input.slice(last, m.index));
+    style = applyCodes(style, (m[1] || '0').split(';'));
+    last = m.index + m[0].length;
+  }
+  push(input.slice(last));
+  return rows;
+}
+
+/** Strip every escape sequence. For measuring, searching and clipboard copies. */
+export function plain(value) {
+  return String(value ?? '').replace(SGR, '').replace(OTHER_ESC, '').replace(/\r/g, '');
+}
+
+// ─── Width ──────────────────────────────────────────────────────────────────────
+//
+// Measured in terminal cells, not code units. A CJK glyph and most emoji occupy two
+// cells; combining marks occupy none. Getting this wrong is what makes a table with
+// one Japanese comment in it stop lining up, and what makes a wrapped line overflow
+// its box by exactly the number of wide characters it contains.
+
+const ZERO_WIDTH = /[̀-ͯ​-‏⁠︀-️]/;
+
+function cellWidth(codePoint) {
+  if (codePoint === 0x200d) return 0; // zero-width joiner
+  const ch = String.fromCodePoint(codePoint);
+  if (ZERO_WIDTH.test(ch)) return 0;
+  if (codePoint < 0x1100) return 1;
+  if (
+    (codePoint >= 0x1100 && codePoint <= 0x115f)
+    || (codePoint >= 0x2e80 && codePoint <= 0xa4cf)
+    || (codePoint >= 0xac00 && codePoint <= 0xd7a3)
+    || (codePoint >= 0xf900 && codePoint <= 0xfaff)
+    || (codePoint >= 0xfe30 && codePoint <= 0xfe6f)
+    || (codePoint >= 0xff00 && codePoint <= 0xff60)
+    || (codePoint >= 0xffe0 && codePoint <= 0xffe6)
+    || (codePoint >= 0x1f300 && codePoint <= 0x1f64f)
+    || (codePoint >= 0x1f900 && codePoint <= 0x1f9ff)
+    || (codePoint >= 0x20000 && codePoint <= 0x3fffd)
+  ) return 2;
+  return 1;
+}
+
+export function stringWidth(value) {
+  let total = 0;
+  for (const ch of String(value ?? '')) total += cellWidth(ch.codePointAt(0));
+  return total;
+}
+
+export const rowWidth = (row) => row.reduce((sum, span) => sum + stringWidth(span.t), 0);
+
+/** Cut a span row to `width` cells, appending an ellipsis when something was lost. */
+export function truncateRow(row, width, ellipsis = '…') {
+  if (rowWidth(row) <= width) return row;
+  const limit = Math.max(0, width - stringWidth(ellipsis));
+  const out = [];
+  let used = 0;
+  for (const span of row) {
+    let text = '';
+    for (const ch of span.t) {
+      const w = cellWidth(ch.codePointAt(0));
+      if (used + w > limit) break;
+      text += ch;
+      used += w;
+    }
+    if (text) out.push({ ...span, t: text });
+    if (used >= limit) break;
+  }
+  out.push({ t: ellipsis, dimColor: true });
+  return out;
+}
+
+/**
+ * Wrap a row of spans to `width`, breaking on spaces where one is close enough to the
+ * edge and hard-cutting where it is not (a 200-character path has no spaces in it, and
+ * pushing it whole onto its own line is worse than splitting it).
+ *
+ * `indent` is applied to every line after the first, which is what makes a wrapped
+ * bullet or a wrapped tool row stay visually attached to its marker.
+ */
+export function wrapRow(row, width, indent = '') {
+  if (width < 4) return [row];
+  if (rowWidth(row) <= width) return [row];
+
+  const lines = [];
+  let current = [];
+  let used = 0;
+  const indentWidth = stringWidth(indent);
+  const indentSpan = indent ? [{ t: indent }] : [];
+
+  // Every line after the first opens with the hanging indent, so a wrapped bullet or a
+  // wrapped tool row stays visually attached to its marker instead of resetting to
+  // column zero and reading as a new item.
+  const flush = () => {
+    lines.push(current.length ? current : [{ t: '' }]);
+    current = indent ? [...indentSpan] : [];
+    used = indent ? indentWidth : 0;
+  };
+
+  for (const span of row) {
+    // Keep the separators: splitting on /(\s+)/ means a run of spaces survives inside a
+    // line and only disappears when it lands on a break.
+    for (const chunk of span.t.split(/(\s+)/)) {
+      if (!chunk) continue;
+      const w = stringWidth(chunk);
+      if (used + w <= width) {
+        current.push({ ...span, t: chunk });
+        used += w;
+        continue;
+      }
+      if (/^\s+$/.test(chunk)) { flush(); continue; }
+      if (w <= width) { flush(); current.push({ ...span, t: chunk }); used += w; continue; }
+      // Longer than a whole line: cut it across as many lines as it needs.
+      let piece = '';
+      let pieceWidth = 0;
+      for (const ch of chunk) {
+        const cw = cellWidth(ch.codePointAt(0));
+        if (used + pieceWidth + cw > width) {
+          current.push({ ...span, t: piece });
+          flush();
+          piece = '';
+          pieceWidth = 0;
+        }
+        piece += ch;
+        pieceWidth += cw;
+      }
+      if (piece) { current.push({ ...span, t: piece }); used += pieceWidth; }
+    }
+  }
+  if (current.length) lines.push(current);
+  return lines.length ? lines : [[{ t: '' }]];
+}
+
+/** Wrap a list of rows. Blank rows survive as blank rows rather than vanishing. */
+export function wrapRows(rows, width, indent = '') {
+  const out = [];
+  for (const row of rows) {
+    if (!row.length) { out.push([{ t: '' }]); continue; }
+    for (const line of wrapRow(row, width, indent)) out.push(line);
+  }
+  return out;
+}
+
+/** The plain text of a row of spans, for selection, search and the clipboard. */
+export const rowText = (row) => (row || []).map((span) => span.t).join('');
+
+/**
+ * Invert the cells between two columns of a row, splitting spans where the range falls
+ * inside one. Used to show a drag selection: the terminal's own highlight is gone once
+ * mouse reporting is on, so the app has to draw it.
+ *
+ * Columns are 0-based and `to` is exclusive.
+ */
+export function inverseRange(row, from, to) {
+  if (to <= from) return row;
+  const out = [];
+  let at = 0;
+  for (const span of row) {
+    const width = span.t.length;
+    const start = at;
+    const end = at + width;
+    at = end;
+    if (end <= from || start >= to) { out.push(span); continue; }
+    const cutA = Math.max(0, from - start);
+    const cutB = Math.min(width, to - start);
+    if (cutA > 0) out.push({ ...span, t: span.t.slice(0, cutA) });
+    out.push({ ...span, t: span.t.slice(cutA, cutB), inverse: true });
+    if (cutB < width) out.push({ ...span, t: span.t.slice(cutB) });
+  }
+  return out;
+}
+
+/** Pad a row out to `width` cells — used for filled backgrounds that must not gap. */
+export function padRow(row, width, style = {}) {
+  const gap = width - rowWidth(row);
+  if (gap <= 0) return row;
+  return [...row, { t: ' '.repeat(gap), ...style }];
+}