@causyne/agent 0.0.0-stage → 1.10.1

package/src/tui/diff.js

@@ -0,0 +1,296 @@
+// Structural diff for the approval prompt.
+//
+// The approval gate used to show the user a tool name and a path:
+//
+//   [ DANGEROUS ] fs_edit   edit
+//     site/index.html (3 edits)
+//
+// and then asked "Approve?". That is a procedural gate, not a real one — the
+// human is consenting to a file mutation whose content they have never seen.
+// sandbox.js classifies the risk correctly and makeApprovalHandler asks the
+// question correctly; the missing half was always the payload.
+//
+// This module answers "what will actually change" for the four tools that
+// mutate a file, and it does so under three hard bounds, because the input is
+// attacker-influenced:
+//
+//  1. The diff is computed over at most MAX_SIDE_LINES rows per side. LCS is
+//     O(n*m); an unbounded model-supplied payload is a way to hang the terminal
+//     at exactly the moment the user is being asked to consent.
+//  2. At most MAX_RENDER_LINES rows reach the screen, so a large rewrite cannot
+//     scroll the question itself out of the scrollback.
+//  3. Every content row passes through text.safeDisplay(), because file content
+//     can carry escapes — and a cursor-moving escape printed one row above an
+//     approval prompt can repaint the prompt.
+//
+// Pure Node over ./theme.js and ./text.js. No dependency, no shell.
+
+import fs from 'fs';
+import { paint, dim, GLYPHS } from './theme.js';
+import { truncate, safeDisplay, shortenHome } from './text.js';
+
+// Per side, for the LCS table. 600x600 int cells is ~1.4 MB and a few ms.
+const MAX_SIDE_LINES = 600;
+
+// Rows that reach the terminal. Deliberately smaller than a screen so the
+// approval question stays visible under the diff.
+const MAX_RENDER_LINES = 40;
+
+// Unchanged rows kept either side of a change, so an edit has context.
+const CONTEXT = 2;
+
+// A file larger than this is not read to build a diff. At that size the diff is
+// not readable anyway, and the read is on the interactive path.
+const MAX_FILE_BYTES = 512 * 1024;
+
+/** Split into lines without inventing a trailing empty row for a final \n. */
+function splitLines(text) {
+  const normalised = String(text == null ? '' : text).replace(/\r\n?/g, '\n');
+  if (normalised === '') return [];
+  const lines = normalised.split('\n');
+  if (lines[lines.length - 1] === '') lines.pop();
+  return lines;
+}
+
+/**
+ * Line diff by longest common subsequence.
+ *
+ * Returns ops in source order: { kind: 'ctx' | 'del' | 'add', text }.
+ *
+ * A word-level or Myers diff would produce prettier output, but this runs while
+ * a human is waiting to answer a security question. Correct and bounded beats
+ * minimal.
+ */
+export function diffLines(before, after) {
+  const a = splitLines(before);
+  const b = splitLines(after);
+
+  // Bound BEFORE building the table, not after.
+  const truncated = a.length > MAX_SIDE_LINES || b.length > MAX_SIDE_LINES;
+  const left = truncated ? a.slice(0, MAX_SIDE_LINES) : a;
+  const right = truncated ? b.slice(0, MAX_SIDE_LINES) : b;
+
+  const rows = left.length;
+  const cols = right.length;
+
+  // lengths[i][j] = LCS length of left[i..] and right[j..], flattened.
+  const width = cols + 1;
+  const lengths = new Int32Array((rows + 1) * width);
+  for (let i = rows - 1; i >= 0; i--) {
+    for (let j = cols - 1; j >= 0; j--) {
+      lengths[i * width + j] = left[i] === right[j]
+        ? lengths[(i + 1) * width + (j + 1)] + 1
+        : Math.max(lengths[(i + 1) * width + j], lengths[i * width + (j + 1)]);
+    }
+  }
+
+  const ops = [];
+  let i = 0;
+  let j = 0;
+  while (i < rows && j < cols) {
+    if (left[i] === right[j]) {
+      ops.push({ kind: 'ctx', text: left[i] });
+      i++; j++;
+    } else if (lengths[(i + 1) * width + j] >= lengths[i * width + (j + 1)]) {
+      ops.push({ kind: 'del', text: left[i] });
+      i++;
+    } else {
+      ops.push({ kind: 'add', text: right[j] });
+      j++;
+    }
+  }
+  while (i < rows) ops.push({ kind: 'del', text: left[i++] });
+  while (j < cols) ops.push({ kind: 'add', text: right[j++] });
+
+  return { ops, truncated };
+}
+
+/** Added/removed counts, for the one-line summary. */
+export function diffStat(ops) {
+  let added = 0;
+  let removed = 0;
+  for (const op of ops) {
+    if (op.kind === 'add') added++;
+    else if (op.kind === 'del') removed++;
+  }
+  return { added, removed };
+}
+
+/**
+ * Keep only the changed rows plus CONTEXT unchanged rows either side.
+ *
+ * Without this, editing line 900 of a 1000-line file prints 1000 rows to show
+ * one change — which is how a diff scrolls the approval question off screen.
+ */
+function collapse(ops) {
+  const keep = new Array(ops.length).fill(false);
+  for (let index = 0; index < ops.length; index++) {
+    if (ops[index].kind === 'ctx') continue;
+    const from = Math.max(0, index - CONTEXT);
+    const to = Math.min(ops.length - 1, index + CONTEXT);
+    for (let k = from; k <= to; k++) keep[k] = true;
+  }
+
+  const out = [];
+  let skipping = 0;
+  for (let index = 0; index < ops.length; index++) {
+    if (keep[index]) {
+      if (skipping > 0) {
+        out.push({ kind: 'gap', count: skipping });
+        skipping = 0;
+      }
+      out.push(ops[index]);
+    } else {
+      skipping++;
+    }
+  }
+  // A trailing run of unchanged rows needs no marker — nothing follows it.
+  return out;
+}
+
+/**
+ * Render ops as terminal rows.
+ *
+ * Colour comes from the semantic roles, so this degrades with NO_COLOR and on a
+ * light background exactly like the rest of the TUI. The +/- markers carry the
+ * meaning on their own, which is what makes the no-colour output still readable.
+ */
+export function renderDiffOps(ops, options = {}) {
+  const width = Math.max(20, (options.width || 80) - 8);
+  const maxLines = options.maxLines || MAX_RENDER_LINES;
+  const collapsed = collapse(ops);
+  const rendered = [];
+
+  for (const op of collapsed) {
+    if (rendered.length >= maxLines) break;
+
+    if (op.kind === 'gap') {
+      rendered.push(dim(`     ${GLYPHS.ellipsis} ${op.count} unchanged line${op.count === 1 ? '' : 's'}`));
+      continue;
+    }
+
+    // Untrusted content: a file can carry escapes, and a credential the model
+    // echoed back into an edit must not be printed.
+    const body = truncate(safeDisplay(op.text), width, GLYPHS.ellipsis);
+
+    if (op.kind === 'add') rendered.push(`     ${paint('success', '+')} ${paint('success', body)}`);
+    else if (op.kind === 'del') rendered.push(`     ${paint('danger', '-')} ${paint('danger', body)}`);
+    else rendered.push(`     ${dim(' ')} ${dim(body)}`);
+  }
+
+  const clipped = collapsed.length > rendered.length;
+  return { rows: rendered, clipped };
+}
+
+/** Convenience: two texts straight to rows. */
+export function renderDiff(before, after, options = {}) {
+  const { ops, truncated } = diffLines(before, after);
+  const { rows, clipped } = renderDiffOps(ops, options);
+  return { rows, stat: diffStat(ops), clipped: clipped || truncated };
+}
+
+/** Read a file for diffing, or null when that is not sensible. */
+function readForDiff(pathish) {
+  if (!pathish) return null;
+  try {
+    const target = String(pathish).replace(/^~(?=\/|\\|$)/, process.env.HOME || '~');
+    const stat = fs.statSync(target);
+    if (!stat.isFile() || stat.size > MAX_FILE_BYTES) return null;
+    return fs.readFileSync(target, 'utf8');
+  } catch (e) {
+    // Missing file is the normal case for a create; anything else (permission,
+    // a directory, a binary) simply means no diff, never a broken transcript.
+    return null;
+  }
+}
+
+function firstString(args, keys) {
+  for (const key of keys) {
+    const value = args[key];
+    if (typeof value === 'string' && value.length > 0) return value;
+  }
+  return '';
+}
+
+/**
+ * Concatenate the search/replace sides of an edit list into two texts.
+ *
+ * Diffing each edit separately would be more precise, but an edit list is
+ * applied as one atomic mutation and the user is answering one question about
+ * it. One diff, in edit order, matches what they are consenting to.
+ */
+function editSides(edits) {
+  const before = [];
+  const after = [];
+  for (const edit of edits) {
+    if (!edit || typeof edit !== 'object') continue;
+    const from = firstString(edit, ['searchContent', 'old_string', 'oldText', 'search']);
+    const to = firstString(edit, ['replaceContent', 'new_string', 'newText', 'replace']);
+    if (from) before.push(from);
+    if (to) after.push(to);
+  }
+  return { before: before.join('\n'), after: after.join('\n') };
+}
+
+
+const DIFF_BUILDERS = new Map([
+  ['fs_write', (args) => {
+    const path = firstString(args, ['path', 'file_path']);
+    const content = typeof args.content === 'string' ? args.content : '';
+    const existing = readForDiff(path);
+    return {
+      path,
+      before: existing === null ? '' : existing,
+      after: content,
+      note: existing === null ? 'new file' : ''
+    };
+  }],
+  ['fs_edit', (args) => {
+    const sides = editSides(Array.isArray(args.edits) ? args.edits : []);
+    return { path: firstString(args, ['path', 'file_path']), before: sides.before, after: sides.after, note: '' };
+  }],
+  ['MultiEdit', (args) => {
+    const sides = editSides(Array.isArray(args.edits) ? args.edits : []);
+    return { path: firstString(args, ['file_path', 'path']), before: sides.before, after: sides.after, note: '' };
+  }],
+  ['fs_delete', (args) => {
+    const path = firstString(args, ['path', 'file_path']);
+    const existing = readForDiff(path);
+    if (existing === null) return null;
+    return { path, before: existing, after: '', note: 'entire file' };
+  }]
+]);
+
+/**
+ * The diff block for one approval, or null when the tool does not mutate a file.
+ *
+ * Never throws: a rendering failure here must not be able to suppress the
+ * approval question itself.
+ */
+export function approvalDiff(toolName, args, options = {}) {
+  try {
+    const builder = DIFF_BUILDERS.get(toolName);
+    if (!builder) return null;
+
+    const safeArgs = args && typeof args === 'object' ? args : {};
+    const plan = builder(safeArgs);
+    if (!plan) return null;
+    if (plan.before === plan.after) return null;
+
+    const { rows, stat, clipped } = renderDiff(plan.before, plan.after, options);
+    if (rows.length === 0) return null;
+
+    return {
+      path: plan.path ? shortenHome(plan.path) : '',
+      note: plan.note,
+      rows,
+      added: stat.added,
+      removed: stat.removed,
+      clipped
+    };
+  } catch (e) {
+    return null;
+  }
+}
+
+export { MAX_SIDE_LINES, MAX_RENDER_LINES, CONTEXT };

package/src/tui/history.js

@@ -0,0 +1,135 @@
+// Persisted prompt history.
+//
+// Every serious terminal tool remembers what you typed. The chat did not: close
+// it and the last hour of prompts was gone.
+//
+// SECURITY: a shell history file is a classic place for a key to leak, and this
+// one is written by a program whose users paste API keys into it. Any line that
+// redactSecrets() would alter is a line that contains something credential
+// shaped, and it is never written to disk. Losing one recallable prompt is
+// cheaper than persisting a key in plaintext.
+//
+// Pure Node. No dependency, no shell.
+
+import fs from 'fs';
+import os from 'os';
+import path from 'path';
+import { redactSecrets } from './text.js';
+import { causyneHome } from '../utils/paths.js';
+
+export const MAX_ENTRIES = 500;
+
+function historyPath() {
+  return path.join(causyneHome(), 'history');
+}
+
+/** True when the line carries something that looks like a credential. */
+export function looksSensitive(line) {
+  return redactSecrets(line) !== line;
+}
+
+export class PromptHistory {
+  constructor(options = {}) {
+    this.file = options.file || historyPath();
+    this.entries = [];
+    this.cursor = -1;      // -1 means "editing a fresh line, not browsing"
+    this.draft = '';
+    this.load();
+  }
+
+  load() {
+    try {
+      const raw = fs.readFileSync(this.file, 'utf8');
+      this.entries = raw.split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .map((line) => {
+          try {
+            const parsed = JSON.parse(line);
+            return typeof parsed === 'string' ? parsed : null;
+          } catch (e) {
+            return null;
+          }
+        })
+        .filter((entry) => typeof entry === 'string' && entry.length > 0);
+    } catch (e) {
+      this.entries = []; // no history yet is the normal first run
+    }
+    if (this.entries.length > MAX_ENTRIES) {
+      this.entries = this.entries.slice(-MAX_ENTRIES);
+    }
+    this.cursor = -1;
+  }
+
+  /**
+   * Record a submitted prompt.
+   *
+   * Returns false when the line was deliberately not kept, so a caller can say
+   * so rather than leaving the user to wonder why it never comes back.
+   */
+  add(text) {
+    const line = String(text == null ? '' : text).trim();
+    this.cursor = -1;
+    this.draft = '';
+
+    if (!line) return false;
+    if (looksSensitive(line)) return false;
+    // Consecutive duplicates are noise; re-running the same prompt is common.
+    if (this.entries[this.entries.length - 1] === line) return true;
+
+    this.entries.push(line);
+    if (this.entries.length > MAX_ENTRIES) {
+      this.entries = this.entries.slice(-MAX_ENTRIES);
+    }
+    this.persist();
+    return true;
+  }
+
+  persist() {
+    try {
+      fs.mkdirSync(path.dirname(this.file), { recursive: true });
+      const body = this.entries.map((entry) => JSON.stringify(entry)).join('\n') + '\n';
+      // Write then rename: a crash mid-write must not truncate the history.
+      const temporary = this.file + '.tmp';
+      fs.writeFileSync(temporary, body, { mode: 0o600 });
+      fs.renameSync(temporary, this.file);
+    } catch (e) {
+      // History is a convenience. Failing to save it must never break the chat.
+    }
+  }
+
+  /**
+   * Entries matching the prefix the user has already typed, newest first.
+   *
+   * Typing `npm ` then pressing Up should walk npm prompts, not everything.
+   */
+  matching(prefix) {
+    if (!prefix) return this.entries.slice().reverse();
+    return this.entries.filter((entry) => entry.startsWith(prefix)).reverse();
+  }
+
+  /** Older entry, or null at the end. `draft` is the line being edited. */
+  previous(draft) {
+    if (this.cursor === -1) this.draft = draft;
+    const pool = this.matching(this.draft);
+    if (pool.length === 0) return null;
+    const next = Math.min(this.cursor + 1, pool.length - 1);
+    if (next === this.cursor) return null;
+    this.cursor = next;
+    return pool[this.cursor];
+  }
+
+  /** Newer entry, or the original draft once the walk returns to the start. */
+  next() {
+    if (this.cursor <= -1) return null;
+    const pool = this.matching(this.draft);
+    this.cursor -= 1;
+    if (this.cursor === -1) return this.draft;
+    return pool[this.cursor] ?? this.draft;
+  }
+
+  reset() {
+    this.cursor = -1;
+    this.draft = '';
+  }
+}

package/src/tui/home.js

@@ -0,0 +1,217 @@
+// Local desktop home: chat, configuration and workspace reports.
+
+import { SelectLayer, InputLayer } from './dialogs.js';
+import { paint, dim, bold, badge, GLYPHS } from './theme.js';
+import { DEFAULT_MODEL_BY_PROVIDER } from '../modelCatalogue.js';
+
+/** Local runtime and provider summary. */
+export function homeStatusLine({ config = {} } = {}) {
+  const model = config.model ? `${config.provider || 'default'}/${config.model}` : (config.provider || 'no provider');
+  const configured = config.apiKey || config.provider === 'ollama';
+  return '  ' + [
+    paint('success', `${GLYPHS.bullet} local desktop`),
+    configured ? dim(model) : paint('warn', `${model} — no key`)
+  ].join(dim(`  ${GLYPHS.dot}  `));
+}
+
+/**
+ * Actions shown on the front page.
+ *
+ * `kind` decides what happens after `run`:
+ *   'stay'     — the result is drawn into the live region, home stays up
+ *   'takeover' — the prompt is stopped and something else owns the terminal
+ *   'chat'     — nothing to run; closing the menu already IS chat
+ */
+export const PRIMARY_ACTIONS = [
+  { id: 'chat', label: 'chat', hint: 'talk to the agent here', kind: 'chat' },
+  {
+    id: 'status',
+    label: 'status',
+    hint: 'local runtime and workspace',
+    kind: 'stay',
+    run: async () => {
+      const { buildStatusText } = await import('../reporting.js');
+      return buildStatusText();
+    }
+  },
+  {
+    id: 'usage',
+    label: 'usage',
+    hint: 'tokens and cost today',
+    kind: 'stay',
+    run: async () => (await import('../reporting.js')).buildUsageText()
+  },
+  { id: 'config', label: 'config', hint: 'provider, model, API key', kind: 'config' },
+  { id: 'more', label: 'more…', hint: 'context · checkpoints · undo · mcp · update', kind: 'more' }
+];
+
+/**
+ * The second page.
+ *
+ * These are real, and several of them are destructive, which is why they are
+ * one level down rather than absent: hiding `unpair` would not make it safer,
+ * it would make it undiscoverable.
+ */
+export const MORE_ACTIONS = [
+  {
+    id: 'context', label: 'context', category: 'reports', hint: 'what fills the context window', kind: 'stay',
+    run: async () => (await import('../reporting.js')).buildContextText()
+  },
+  {
+    id: 'checkpoints', label: 'checkpoints', category: 'reports', hint: 'recent undo points', kind: 'stay',
+    run: async () => (await import('../reporting.js')).buildCheckpointsText(15)
+  },
+  {
+    id: 'undo', label: 'undo', category: 'reports', hint: 'roll back the last task', kind: 'command',
+    // Routed through the registry so it gets the same confirmation gate the
+    // typed command gets. An action that wrote files straight from a menu would
+    // be the one path around the gate.
+    command: '/undo'
+  },
+  { id: 'mcp', label: 'mcp', category: 'tools', hint: 'manage MCP servers', kind: 'mcp' },
+  {
+    id: 'update', label: 'update', category: 'tools', hint: 'update to the latest version', kind: 'takeover',
+    run: async () => {
+      const { runSelfUpdate } = await import('../autoUpdate.js');
+      await runSelfUpdate(true);
+    }
+  },
+
+];
+
+/** Items in the shape SelectList wants, for the `more…` page. */
+export function moreLayer(onPick) {
+  return new SelectLayer({
+    title: 'more',
+    items: MORE_ACTIONS.map((action) => ({
+      id: action.id,
+      label: action.label,
+      description: action.hint,
+      category: action.category,
+      value: action
+    })),
+    onPick: (item) => onPick(item && item.value)
+  });
+}
+
+/** The hint row under the input while the menu is up. */
+export function homeHint() {
+  return dim(`  ${bold('↑↓')} pick  ${GLYPHS.dot}  ${bold('enter')} run  ${GLYPHS.dot}  ${bold('esc')} menu off  ${GLYPHS.dot}  or just start typing`);
+}
+
+export { badge };
+
+// ---------------------------------------------------------------------------
+// The two flows that need a keyboard
+//
+// Both of these used inquirer, which takes stdin while ChatPrompt is already
+// holding it in raw mode — the two contend and the question lands on a
+// half-drawn prompt. Inside home there IS a live region and a modal stack, so
+// they can be asked properly. `causyne config` invoked on its own still uses the
+// inquirer wizard, because standalone there is no live region to draw into and
+// building a second one is how the deleted alt-screen shell started.
+// ---------------------------------------------------------------------------
+
+/** Provider choices for local CLI configuration. */
+// Suggested models come from src/modelCatalogue.js rather than being repeated
+// here. This list had drifted to `gpt-4o` and `gemini-2.5-pro` — two
+
+// stale values again. Labels and hints stay local because they are terminal UI.
+export const PROVIDERS = [
+  { id: 'deepseek', label: 'DeepSeek', hint: 'recommended for STEM' },
+  { id: 'qwen', label: 'Qwen / Alibaba Cloud', hint: 'fastest' },
+  { id: 'dashscope-byok', label: 'Alibaba DashScope', hint: 'multi-model gateway' },
+  { id: 'muse', label: 'Meta Model API', hint: 'Muse Spark · 1M context' },
+  { id: 'anthropic', label: 'Anthropic', hint: 'Claude' },
+  { id: 'openai', label: 'OpenAI', hint: 'GPT' },
+  { id: 'gemini', label: 'Gemini', hint: 'Google' },
+  { id: 'moonshot', label: 'Moonshot', hint: 'Kimi' },
+  { id: 'xai', label: 'xAI', hint: 'Grok' },
+  { id: 'openai-compatible', label: 'OpenAI-compatible endpoint', hint: 'custom base URL' },
+  { id: 'ollama', label: 'Ollama', hint: 'local / offline' }
+].map((entry) => ({ ...entry, model: DEFAULT_MODEL_BY_PROVIDER[entry.id] ?? '' }));
+
+/**
+ * Ask for provider, then model, then key — each in the prompt's own panel.
+ *
+ * Resolves when the last answer is in, or when any step is dismissed. Dismissing
+ * cancels the whole flow rather than saving a half-configuration, because a
+ * provider saved without its key leaves the agent in a state that fails on the
+ * next turn with an error about credentials rather than about the cancel.
+ */
+export function configureInPrompt(prompt, { loadConfig, saveConfig }) {
+  return new Promise((resolve) => {
+    const config = loadConfig();
+
+    prompt.openLayer(new SelectLayer({
+      title: 'provider',
+      items: PROVIDERS.map((p) => ({ id: p.id, label: p.label, description: p.hint, value: p })),
+      onPick: (item) => {
+        if (!item) { resolve(null); return; }
+        const provider = item.value;
+        askModel(provider);
+      }
+    }));
+
+    function askModel(provider) {
+      const suggested = (config.provider === provider.id && config.model) ? config.model : provider.model;
+      prompt.openLayer(new InputLayer({
+        title: `model for ${provider.label}`,
+        lines: [
+          'Model ids change often. Type the one you want, or accept the suggestion.'
+        ],
+        value: suggested,
+        placeholder: 'model id',
+        onSubmit: (model) => askKey(provider, (model || '').trim() || suggested),
+        onCancel: () => resolve(null)
+      }));
+    }
+
+    function askKey(provider, model) {
+      prompt.openLayer(new InputLayer({
+        title: 'API key',
+        lines: [
+          `${provider.label} ${GLYPHS.arrow} ${model}`,
+          '',
+          'Stored encrypted in ~/.causyne/config.json. It never leaves this machine.'
+        ],
+        mask: true,
+        value: '',
+        placeholder: 'paste your key (blank keeps the current one)',
+        onSubmit: (apiKey) => {
+          const next = loadConfig();
+          next.provider = provider.id;
+          next.model = model;
+          if (apiKey) next.apiKey = apiKey;
+          saveConfig(next);
+          resolve({ provider: provider.id, model });
+        },
+        onCancel: () => resolve(null)
+      }));
+    }
+  });
+}
+
+/** The MCP server list, as something you can act on rather than read. */
+export async function mcpPicker(prompt, onAction) {
+  const { serverStatus } = await import('../mcp/mcpRegistry.js');
+  const servers = await serverStatus();
+  const rows = Array.isArray(servers) ? servers : (servers && servers.servers) || [];
+
+  if (rows.length === 0) {
+    return { empty: true };
+  }
+
+  prompt.openLayer(new SelectLayer({
+    title: 'MCP servers',
+    items: rows.map((server) => ({
+      id: server.name,
+      label: server.name,
+      description: `${server.granted ? 'granted' : 'not granted'}${server.command ? ` ${GLYPHS.dot} ${server.command}` : ''}`,
+      category: server.granted ? 'granted' : 'available',
+      value: server
+    })),
+    onPick: (item) => { if (item) onAction(item.value); }
+  }));
+  return { empty: false };
+}