jaitus 0.3.0

package/src/diff.js

@@ -0,0 +1,129 @@
+// ─── Unified diff ───────────────────────────────────────────────────────────────
+//
+// "Edited src/index.js" tells you nothing about what changed, and nobody re-reads a
+// file to find out — they accept the claim and move on. Showing the actual hunks is
+// what makes an agent's edit reviewable at the moment it happens rather than at the
+// end of the session, and it costs one small algorithm rather than a dependency.
+//
+// Myers would be the textbook answer; this is the simpler Hunt–Szymanski shape built
+// on an LCS table, bounded so a pathological pair of large files degrades to a
+// whole-file replacement instead of allocating a gigabyte.
+
+const MAX_CELLS = 4_000_000; // ~2000×2000 lines before falling back
+
+/** Longest common subsequence of two line arrays, as index pairs. */
+function lcs(a, b) {
+  const n = a.length;
+  const m = b.length;
+  if (n * m > MAX_CELLS) return null;
+
+  // Trim the common head and tail first: most edits touch a few lines of a long file,
+  // and this turns the usual case into a table of a handful of cells.
+  let head = 0;
+  while (head < n && head < m && a[head] === b[head]) head++;
+  let tail = 0;
+  while (tail < n - head && tail < m - head && a[n - 1 - tail] === b[m - 1 - tail]) tail++;
+
+  const ai = a.slice(head, n - tail);
+  const bi = b.slice(head, m - tail);
+  const rows = ai.length;
+  const cols = bi.length;
+
+  const table = new Uint32Array((rows + 1) * (cols + 1));
+  const at = (i, j) => i * (cols + 1) + j;
+  for (let i = rows - 1; i >= 0; i--) {
+    for (let j = cols - 1; j >= 0; j--) {
+      table[at(i, j)] = ai[i] === bi[j]
+        ? table[at(i + 1, j + 1)] + 1
+        : Math.max(table[at(i + 1, j)], table[at(i, j + 1)]);
+    }
+  }
+
+  const pairs = [];
+  for (let i = 0; i < head; i++) pairs.push([i, i]);
+  let i = 0;
+  let j = 0;
+  while (i < rows && j < cols) {
+    if (ai[i] === bi[j]) { pairs.push([head + i, head + j]); i++; j++; }
+    else if (table[at(i + 1, j)] >= table[at(i, j + 1)]) i++;
+    else j++;
+  }
+  for (let k = 0; k < tail; k++) pairs.push([n - tail + k, m - tail + k]);
+  return pairs;
+}
+
+/**
+ * A unified diff of two strings.
+ *
+ * Returns '' when nothing changed, which callers use to skip rendering entirely: an
+ * edit that produced no change is worth knowing about, but it is not worth a hunk.
+ */
+export function unifiedDiff(before, after, { context = 3, file = '' } = {}) {
+  const a = String(before ?? '').replace(/\r\n?/g, '\n').split('\n');
+  const b = String(after ?? '').replace(/\r\n?/g, '\n').split('\n');
+  if (a.length === b.length && a.every((line, i) => line === b[i])) return '';
+
+  const pairs = lcs(a, b);
+  if (!pairs) {
+    // Too large to diff honestly. Saying so beats inventing hunks.
+    return `@@ ${file || 'file'} @@\n-[${a.length} lines replaced]\n+[${b.length} lines]`;
+  }
+
+  // Walk both sides together, emitting -/+/space operations in order.
+  const ops = [];
+  let ai = 0;
+  let bi = 0;
+  for (const [pa, pb] of pairs) {
+    while (ai < pa) ops.push(['-', a[ai++]]);
+    while (bi < pb) ops.push(['+', b[bi++]]);
+    ops.push([' ', a[pa]]);
+    ai = pa + 1;
+    bi = pb + 1;
+  }
+  while (ai < a.length) ops.push(['-', a[ai++]]);
+  while (bi < b.length) ops.push(['+', b[bi++]]);
+
+  // Group changes into hunks with `context` unchanged lines either side.
+  const changed = ops.map(([sign]) => sign !== ' ');
+  const keep = new Array(ops.length).fill(false);
+  for (let i = 0; i < ops.length; i++) {
+    if (!changed[i]) continue;
+    for (let j = Math.max(0, i - context); j <= Math.min(ops.length - 1, i + context); j++) keep[j] = true;
+  }
+
+  const lines = [];
+  let oldLine = 1;
+  let newLine = 1;
+  let hunk = null;
+  const flush = () => {
+    if (!hunk) return;
+    lines.push(`@@ -${hunk.oldStart},${hunk.oldCount} +${hunk.newStart},${hunk.newCount} @@`);
+    lines.push(...hunk.body);
+    hunk = null;
+  };
+
+  for (let i = 0; i < ops.length; i++) {
+    const [sign, text] = ops[i];
+    if (keep[i]) {
+      if (!hunk) hunk = { oldStart: oldLine, newStart: newLine, oldCount: 0, newCount: 0, body: [] };
+      hunk.body.push(`${sign}${text}`);
+      if (sign !== '+') hunk.oldCount++;
+      if (sign !== '-') hunk.newCount++;
+    } else {
+      flush();
+    }
+    if (sign !== '+') oldLine++;
+    if (sign !== '-') newLine++;
+  }
+  flush();
+  return lines.join('\n');
+}
+
+/** Added and removed line counts, for a one-line summary. */
+export function diffStat(patch) {
+  const lines = String(patch || '').split('\n');
+  return {
+    added: lines.filter((l) => l.startsWith('+') && !l.startsWith('+++')).length,
+    removed: lines.filter((l) => l.startsWith('-') && !l.startsWith('---')).length,
+  };
+}

package/src/errors.js

@@ -0,0 +1,101 @@
+// ─── What the CLI says when something fails ─────────────────────────────────────
+//
+// The gateway answers every failure with a `jaitus_*` code from one catalog. This file
+// is the CLI's half of that contract: a code maps to a title and a hint written here,
+// and anything WITHOUT a known code — an HTML page from a proxy, a body in some other
+// shape, a code this build has never heard of — becomes "something went wrong in
+// Jaitus" plus the request id. The CLI never prints an error body it does not
+// recognise, because the only text that is safe to show is text we wrote.
+
+const CATALOG = {
+  auth_required: { title: 'Not signed in', hint: 'Run `jaitus login` to sign in.' },
+  session_expired: { title: 'Signed out', hint: 'Run `jaitus login` to sign in again.' },
+  account_suspended: { title: 'Account suspended', hint: 'Contact support if you think this is a mistake.' },
+  email_unverified: { title: 'Email not verified', hint: 'Open the verification link in your inbox, then retry.' },
+  free_limit_reached: { title: 'Free prompts used up', hint: 'Subscribe on the website, then retry this turn.' },
+  free_request_too_large: { title: 'Too large for the free plan', hint: 'Run /compact or start a new session, or subscribe.' },
+  plan_limit_reached: { title: 'Monthly allowance used', hint: 'It resets at the start of your next period, or upgrade on the website. /usage shows where you are.' },
+  rate_limited: { title: 'Slow down', hint: 'Wait a moment, then retry.' },
+  context_too_long: { title: 'Conversation too long', hint: 'Run /compact, or start a new session.' },
+  content_blocked: { title: 'Request refused', hint: 'Rephrase the request and try again.' },
+  bad_request: { title: 'Request not accepted', hint: 'Try again; if it repeats, run /debug and contact support.' },
+  model_unavailable: { title: 'Model unavailable', hint: 'Run /model to pick another.' },
+  busy: { title: 'Jaitus is busy', hint: 'Try again in a minute.' },
+  unavailable: { title: 'Jaitus is unavailable', hint: 'Try again shortly. `jaitus doctor` checks your side.' },
+  maintenance: { title: 'Down for maintenance', hint: 'Try again shortly.' },
+  timeout: { title: 'Timed out', hint: 'Try again.' },
+  interrupted: { title: 'Response interrupted', hint: 'Try again.' },
+  internal: { title: 'Something went wrong', hint: 'Try again; if it keeps happening, contact support with the request id.' },
+};
+
+const GENERIC = 'Something went wrong in Jaitus.';
+
+export class JaitusError extends Error {
+  constructor({ code = 'internal', message, status = 0, requestId = '', retryAfter = null } = {}) {
+    const known = Object.prototype.hasOwnProperty.call(CATALOG, code) ? code : 'internal';
+    super(message || GENERIC);
+    this.name = 'JaitusError';
+    this.code = known;
+    this.status = status;
+    this.requestId = requestId;
+    this.retryAfter = retryAfter;
+    this.title = CATALOG[known].title;
+    this.hint = CATALOG[known].hint;
+  }
+}
+
+/**
+ * An error body from the gateway → a JaitusError.
+ *
+ * The gateway's message is shown ONLY when the body carries a recognised `jaitus_`
+ * code, because only then is it guaranteed to be our wording (it may carry specifics,
+ * like how many free prompts there were). Otherwise the message is ours, generic.
+ */
+export function fromGatewayBody(status, body, { requestId = '', retryAfter = null } = {}) {
+  let parsed = body;
+  if (typeof body === 'string') {
+    try { parsed = JSON.parse(body); } catch { parsed = null; }
+  }
+  const err = parsed?.error || null;
+  const rawCode = String(err?.code || '');
+  const code = rawCode.startsWith('jaitus_') ? rawCode.slice(7) : '';
+  const known = code && Object.prototype.hasOwnProperty.call(CATALOG, code);
+  const id = String(parsed?.request_id || requestId || '');
+  return new JaitusError({
+    code: known ? code : 'internal',
+    message: known && typeof err?.message === 'string' && err.message.trim() ? err.message.trim() : GENERIC,
+    status,
+    requestId: id,
+    retryAfter,
+  });
+}
+
+/** A failed fetch Response → a JaitusError, reading the body once. */
+export async function fromResponse(res) {
+  const text = await res.text().catch(() => '');
+  const requestId = res.headers?.get?.('x-request-id') || '';
+  const retryAfter = Number(res.headers?.get?.('retry-after')) || null;
+  return fromGatewayBody(res.status, text, { requestId, retryAfter });
+}
+
+/**
+ * fetch() threw before any response — the network, not the service. This is the one
+ * failure where the true cause is on the user's side and worth naming plainly.
+ */
+export function fromNetwork(cause) {
+  if (cause?.name === 'AbortError') return cause;
+  const error = new JaitusError({
+    code: 'unavailable',
+    message: 'Could not reach Jaitus. Check your internet connection.',
+  });
+  error.title = 'Cannot reach Jaitus';
+  error.hint = 'Check your connection, then run `jaitus doctor`.';
+  error.cause = cause;
+  return error;
+}
+
+export function isJaitusError(e) {
+  return e instanceof JaitusError || e?.name === 'JaitusError';
+}
+
+export const ERROR_CODES = Object.freeze(Object.keys(CATALOG));

package/src/hooks.js

@@ -0,0 +1,55 @@
+// ─── Local lifecycle hooks ──────────────────────────────────────────────────────
+//
+// Hooks are explicit project configuration, not hidden magic. A hook receives a small
+// JSON event on stdin and may block the lifecycle by exiting non-zero. Hook stdout is
+// intentionally not echoed: hooks often inspect repositories and must not accidentally
+// publish credentials or noisy logs into the conversation.
+
+import fs from 'node:fs';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+
+function load(cwd) {
+  // Only Jaitus's own file. Hooks are shell commands: ones written for another tool
+  // must never start running because Jaitus happened to find them.
+  const candidates = [
+    path.join(cwd, '.jaitus', 'hooks.json'),
+  ];
+  for (const file of candidates) {
+    try {
+      const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (data?.hooks && typeof data.hooks === 'object') return data.hooks;
+    } catch { /* the next supported location may exist */ }
+  }
+  return {};
+}
+
+function commandsFor(value) {
+  if (typeof value === 'string') return [value];
+  if (!Array.isArray(value)) return [];
+  return value.flatMap((item) => typeof item === 'string' ? [item] : item?.command ? [item.command] : []);
+}
+
+export async function runHook(cwd, event, payload = {}) {
+  const commands = commandsFor(load(cwd)[event]);
+  for (const command of commands) {
+    const code = await new Promise((resolve) => {
+      const child = spawn(command, {
+        cwd,
+        shell: true,
+        env: { ...process.env, JAITUS_HOOK_EVENT: event },
+        stdio: ['pipe', 'ignore', 'ignore'],
+      });
+      const timer = setTimeout(() => { child.kill(); resolve(124); }, 30_000);
+      child.on('error', () => { clearTimeout(timer); resolve(127); });
+      child.on('close', (exitCode) => { clearTimeout(timer); resolve(exitCode ?? 1); });
+      child.stdin.end(JSON.stringify({ event, cwd, ...payload }));
+    });
+    if (code !== 0) return { ok: false, event, code, command };
+  }
+  return { ok: true, event };
+}
+
+export function configuredHookEvents(cwd) {
+  return Object.keys(load(cwd));
+}