ucode-agent 1.63.0 → 1.65.0

package/src/core/settings.js

@@ -0,0 +1,148 @@
+/**
+ * settings.js — what ucode may do without asking, and what runs around its work.
+ *
+ *   ~/.ucode/settings.json          yours, in every project
+ *   <project>/.ucode/settings.json  this project's, on top of yours
+ *
+ *   {
+ *     "commands": "ask",              ask before every command ("auto", the default, runs them)
+ *     "allow": ["npm test"],          never asked about: a command by its first words, or "mcp:server__tool"
+ *     "hooks": {
+ *       "afterEdit": ["npx prettier --write {files}"],
+ *       "beforeCommand": ["node guard.js"]     a non-zero exit stops the command
+ *     }
+ *   }
+ *
+ * A project's own hooks and MCP servers run commands on this computer, and a
+ * cloned repository can carry any it likes. So they run only once the user
+ * has said yes to them, and saying yes is remembered against exactly what was
+ * approved: change the hooks and ucode asks again.
+ */
+
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+
+const UCODE_DIR = path.join(os.homedir(), '.ucode');
+export const USER_SETTINGS = path.join(UCODE_DIR, 'settings.json');
+export const TRUST_FILE = path.join(UCODE_DIR, 'trusted.json');
+export const projectSettingsFile = (cwd) => path.join(cwd, '.ucode', 'settings.json');
+
+export async function readJson(file) {
+  try {
+    const data = JSON.parse(await fs.readFile(file, 'utf8'));
+    return data && typeof data === 'object' && !Array.isArray(data) ? data : {};
+  } catch {
+    return {};
+  }
+}
+
+export async function writeJson(file, data) {
+  await fs.mkdir(path.dirname(file), { recursive: true });
+  const temp = `${file}.${process.pid}.tmp`;
+  await fs.writeFile(temp, `${JSON.stringify(data, null, 2)}\n`);
+  await fs.rename(temp, file);
+}
+
+const list = (v) => (Array.isArray(v) ? v : v ? [v] : []).map(String).filter((s) => s.trim());
+
+/** Both files, merged: allow lists add up, the project's "commands" wins. */
+export async function loadSettings(cwd, { userFile = USER_SETTINGS } = {}) {
+  const [user, project] = await Promise.all([readJson(userFile), readJson(projectSettingsFile(cwd))]);
+  const hooks = (s, key) => list(s.hooks?.[key]);
+  return {
+    commands: (project.commands ?? user.commands) === 'ask' ? 'ask' : 'auto',
+    allow: [...new Set([...list(user.allow), ...list(project.allow)])],
+    hooks: { afterEdit: hooks(user, 'afterEdit'), beforeCommand: hooks(user, 'beforeCommand') },
+    projectHooks: { afterEdit: hooks(project, 'afterEdit'), beforeCommand: hooks(project, 'beforeCommand') },
+  };
+}
+
+/**
+ * What "always allow" remembers: "npm test" for `npm test -- --watch`. Never
+ * shorter than a flag: allowing `node -e "…"` once must not allow every
+ * `node -e` after it, so a command whose second word is a flag is kept whole.
+ */
+export function commandKey(command) {
+  const words = String(command).trim().split(/\s+/).filter(Boolean);
+  if (!words[1] || words[1].startsWith('-')) return words.join(' ');
+  return words.slice(0, 2).join(' ');
+}
+
+/** Is this command (or "mcp:name") on the allow list? A whole-word prefix counts. */
+export function isAllowed(allow, command) {
+  const c = String(command).trim();
+  // Chained commands are never covered by an entry for their first part.
+  if (/[;&|`$<>]/.test(c) && !c.startsWith('mcp:')) return false;
+  return allow.some((a) => c === a || c.startsWith(`${a} `));
+}
+
+/** Add an entry to this project's allow list. */
+export async function addAllow(cwd, entry) {
+  const file = projectSettingsFile(cwd);
+  const settings = await readJson(file);
+  const allow = list(settings.allow);
+  if (!allow.includes(entry)) await writeJson(file, { ...settings, allow: [...allow, entry] });
+}
+
+/**
+ * What was approved, down to the scripts it runs. Hashing only the settings
+ * text would let `node .ucode/guard.js` be approved and guard.js swapped
+ * afterwards, so every word of the commands that names a file in the project
+ * adds that file's contents. (A package fetched by npx is not covered: pin
+ * its version in the command to approve one release.)
+ */
+async function fingerprint(cwd, value) {
+  const hash = createHash('sha1').update(JSON.stringify(value));
+  const words = JSON.stringify(value).match(/[\w./\\@-]+\.\w+/g) ?? [];
+  for (const word of [...new Set(words)].sort()) {
+    const abs = path.resolve(cwd, word);
+    if (!abs.startsWith(path.resolve(cwd))) continue;
+    const text = await fs.readFile(abs).catch(() => null);
+    if (text) hash.update(`\0${word}\0`).update(text);
+  }
+  return hash.digest('hex');
+}
+
+/** Has the user approved exactly this (the project's hooks, its MCP servers) here before? */
+export async function isTrusted(cwd, what, value, file = TRUST_FILE) {
+  const all = await readJson(file);
+  return all[`${path.resolve(cwd)}#${what}`] === (await fingerprint(cwd, value));
+}
+
+export async function trust(cwd, what, value, file = TRUST_FILE) {
+  const all = await readJson(file);
+  await writeJson(file, { ...all, [`${path.resolve(cwd)}#${what}`]: await fingerprint(cwd, value) });
+}
+
+/** A path safe to put on a shell command line as it is. */
+const SAFE_PATH = /^[\w./\\ @+~-]+$/;
+
+/**
+ * Run one hook. `{files}` becomes the changed files, quoted; they are also in
+ * UCODE_FILES. Resolves to { code, output } and never throws.
+ */
+export function runHook(command, { cwd, files = [], env = {}, timeout = 30_000 } = {}) {
+  const quoted = files.filter((f) => SAFE_PATH.test(f)).map((f) => `"${f}"`).join(' ');
+  const line = String(command).includes('{files}') ? String(command).split('{files}').join(quoted) : String(command);
+  return new Promise((resolve) => {
+    let output = '';
+    let child;
+    try {
+      child = spawn(line, {
+        cwd, shell: true, windowsHide: true,
+        env: { ...process.env, ...env, UCODE_FILES: files.join('\n') },
+      });
+    } catch (err) {
+      resolve({ code: -1, output: err.message });
+      return;
+    }
+    const timer = setTimeout(() => { output += `\n(stopped after ${timeout / 1000}s)`; child.kill(); }, timeout);
+    child.stdout?.on('data', (d) => { output += d; });
+    child.stderr?.on('data', (d) => { output += d; });
+    child.on('error', (err) => { clearTimeout(timer); resolve({ code: -1, output: err.message }); });
+    child.on('close', (code) => { clearTimeout(timer); resolve({ code: code ?? -1, output: output.trim() }); });
+  });
+}

package/src/core/snapshot.js

@@ -0,0 +1,147 @@
+/**
+ * snapshot.js — the whole project as it was before each turn, for /undo.
+ *
+ * undo.js remembers files ucode's own tools write, for one turn. That misses
+ * everything a command changes — a script that rewrites a config, a generator
+ * that adds twenty files — and it forgets the moment the next turn starts. So
+ * the project is snapshotted before every turn into a hidden git repository
+ * of ucode's own, under ~/.ucode/snapshots: the project's own .git is never
+ * read or written, and a folder with no git at all gets the same undo.
+ *
+ * The project's .gitignore is honoured, and node_modules and build output are
+ * always left out: they are huge, and an install can simply be run again.
+ *
+ * ponytail: snapshots are never pruned. Git only stores what changed, so a
+ * long-lived project grows by its edits; `git gc` in the snapshot folder, or
+ * deleting it, is the upgrade path if that ever matters.
+ */
+
+import { spawn } from 'node:child_process';
+import { createHash } from 'node:crypto';
+import { promises as fs } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { walk } from '../tools/shared.js';
+
+export const SNAPSHOT_HOME = path.join(os.homedir(), '.ucode', 'snapshots');
+
+/** Past this many files, snapshotting every turn would cost real time. */
+export const MAX_FILES = 3000;
+
+const EXCLUDE = [
+  'node_modules/', '.next/', 'dist/', 'build/', 'out/', 'coverage/', '.cache/', '.turbo/',
+  '.venv/', 'venv/', '__pycache__/', 'target/', '.ucode/', '*.log',
+];
+
+function run(args, { cwd }) {
+  return new Promise((resolve) => {
+    let out = '';
+    let err = '';
+    let child;
+    try {
+      child = spawn('git', args, { cwd, windowsHide: true, env: { ...process.env, GIT_TERMINAL_PROMPT: '0' } });
+    } catch (e) {
+      resolve({ code: -1, out: '', err: e.message });
+      return;
+    }
+    child.stdout.on('data', (d) => { out += d; });
+    child.stderr.on('data', (d) => { err += d; });
+    child.on('error', (e) => resolve({ code: -1, out, err: e.message }));
+    child.on('close', (code) => resolve({ code, out, err }));
+  });
+}
+
+export class Snapshots {
+  constructor(cwd, { home = SNAPSHOT_HOME } = {}) {
+    this.cwd = path.resolve(cwd);
+    const id = createHash('sha1').update(this.cwd.toLowerCase()).digest('hex').slice(0, 16);
+    this.gitDir = path.join(home, `${id}.git`);
+    this.usable = null; // decided once, by ready()
+  }
+
+  git(args) {
+    return run([
+      `--git-dir=${this.gitDir}`, `--work-tree=${this.cwd}`,
+      '-c', 'core.autocrlf=false', '-c', 'core.safecrlf=false', '-c', 'core.longpaths=true',
+      '-c', 'user.name=ucode', '-c', 'user.email=ucode@localhost', '-c', 'commit.gpgsign=false',
+      ...args,
+    ], { cwd: this.cwd });
+  }
+
+  /**
+   * Whether this folder can be snapshotted: git is installed, the folder is a
+   * project rather than a home directory or a drive, and it is small enough
+   * that a snapshot costs a moment.
+   */
+  async ready() {
+    if (this.usable !== null) return this.usable;
+    this.usable = false;
+    if (process.env.UCODE_SNAPSHOTS === '0') return false;
+    const home = path.resolve(os.homedir());
+    if (this.cwd === home || this.cwd === path.parse(this.cwd).root) return false;
+    const files = await walk(this.cwd, { limit: MAX_FILES + 1 }).catch(() => null);
+    if (!files || files.length > MAX_FILES) return false;
+    try {
+      await fs.access(path.join(this.gitDir, 'HEAD'));
+    } catch {
+      await fs.mkdir(path.dirname(this.gitDir), { recursive: true });
+      const init = await run(['init', '-q', '--bare', this.gitDir], { cwd: path.dirname(this.gitDir) });
+      if (init.code !== 0) return false;
+    }
+    await fs.mkdir(path.join(this.gitDir, 'info'), { recursive: true });
+    await fs.writeFile(path.join(this.gitDir, 'info', 'exclude'), `${EXCLUDE.join('\n')}\n`);
+    this.usable = true;
+    return true;
+  }
+
+  /** Record the project as it is now. Resolves to the snapshot id, or null. */
+  async take(label = 'snapshot') {
+    if (!(await this.ready())) return null;
+    const add = await this.git(['add', '-A', '.']);
+    if (add.code !== 0) return null;
+    const commit = await this.git(['commit', '-q', '--allow-empty', '--no-verify', '-m', label]);
+    if (commit.code !== 0) return null;
+    const head = await this.git(['rev-parse', 'HEAD']);
+    return head.code === 0 ? head.out.trim() : null;
+  }
+
+  /** Files that differ between a snapshot and now: [{ status: 'A'|'M'|'D', file }]. */
+  async changedSince(id) {
+    const now = await this.take('now');
+    if (!now) return [];
+    const diff = await this.git(['diff', '--name-status', '--no-renames', id, now]);
+    if (diff.code !== 0) return [];
+    return diff.out.split('\n').filter(Boolean).map((line) => {
+      const [status, ...rest] = line.split('\t');
+      return { status: status[0], file: rest.join('\t') };
+    });
+  }
+
+  /**
+   * Put the project back the way it was at a snapshot. Files made since are
+   * removed; files changed or deleted since come back.
+   */
+  async restore(id) {
+    const out = { restored: [], removed: [], failed: [] };
+    const changes = await this.changedSince(id);
+    for (const { status, file } of changes) {
+      if (status === 'A') {
+        try {
+          await fs.rm(path.join(this.cwd, file), { force: true });
+          out.removed.push(file);
+        } catch (err) {
+          out.failed.push(`${file}: ${err.message}`);
+        }
+      }
+    }
+    const back = changes.filter((c) => c.status !== 'A').map((c) => c.file);
+    // In batches: Windows caps a command line at 32K characters.
+    for (let i = 0; i < back.length; i += 100) {
+      const batch = back.slice(i, i + 100);
+      const checkout = await this.git(['checkout', id, '--', ...batch]);
+      if (checkout.code === 0) out.restored.push(...batch);
+      else out.failed.push(checkout.err.trim().split('\n')[0] || 'git checkout failed');
+    }
+    return out;
+  }
+}

package/src/core/terminal.js

@@ -0,0 +1,232 @@
+/**
+ * terminal.js — changing the terminal ucode runs in, when the user asks:
+ * "make my terminal dark green", "bigger font", "a bit see-through".
+ *
+ * Each terminal keeps its look somewhere different, so each gets its own way:
+ *
+ *   Windows Terminal  its settings.json, which it reloads the moment it is saved.
+ *                     Kept: every new tab looks the same. The file as it was is
+ *                     backed up first, and `reset` puts it back.
+ *   Terminal.app      AppleScript on the window ucode is in: colours, cursor,
+ *                     font and size. That window only; the old values are kept
+ *                     so `reset` can restore them.
+ *   iTerm2            its escape sequence for colours, this session only.
+ *   anything else     the standard xterm escapes for colours, this session only.
+ *
+ * Nothing here runs unless the user asked, and the loop asks before it does.
+ */
+
+import { execFile } from 'node:child_process';
+import { promises as fs, existsSync } from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { jsonrepair } from 'jsonrepair';
+import { normaliseColour, hexRGB } from '../ui/theme.js';
+
+export const BACKUP_DIR = path.join(os.homedir(), '.ucode', 'terminal-backup');
+const backups = () => process.env.UCODE_TERMINAL_BACKUP || BACKUP_DIR;
+
+/** Which terminal this is, from what it puts in the environment. */
+export function detectTerminal(env = process.env, platform = process.platform) {
+  if (env.WT_SESSION) return 'windows-terminal';
+  if (env.TERM_PROGRAM === 'Apple_Terminal') return 'apple-terminal';
+  if (env.TERM_PROGRAM === 'iTerm.app' || env.LC_TERMINAL === 'iTerm2') return 'iterm';
+  if (env.TERM_PROGRAM === 'vscode') return 'vscode';
+  if (platform === 'win32') return 'windows-console';
+  return 'other';
+}
+
+export const TERMINAL_NAMES = {
+  'windows-terminal': 'Windows Terminal',
+  'apple-terminal': 'Terminal',
+  iterm: 'iTerm2',
+  vscode: 'the VS Code terminal',
+  'windows-console': 'the Windows console',
+  other: 'this terminal',
+};
+
+/** Where Windows Terminal keeps its settings: the Store build, Preview, or unpackaged. */
+export function windowsTerminalSettings(env = process.env) {
+  const local = env.LOCALAPPDATA ?? path.join(os.homedir(), 'AppData', 'Local');
+  const candidates = [
+    path.join(local, 'Packages', 'Microsoft.WindowsTerminal_8wekyb3d8bbwe', 'LocalState', 'settings.json'),
+    path.join(local, 'Packages', 'Microsoft.WindowsTerminalPreview_8wekyb3d8bbwe', 'LocalState', 'settings.json'),
+    path.join(local, 'Microsoft', 'Windows Terminal', 'settings.json'),
+  ];
+  return candidates.find((f) => existsSync(f)) ?? null;
+}
+
+/** What was asked for, cleaned: colours as #rrggbb, a sane size and opacity. */
+export function cleanRequest(req = {}) {
+  const out = {};
+  for (const key of ['background', 'foreground', 'cursor']) {
+    if (req[key] === undefined || req[key] === null || req[key] === '') continue;
+    const colour = normaliseColour(req[key]);
+    if (!colour) throw new Error(`"${req[key]}" is not a colour ucode can read — use a name like "navy" or a hex like #1e1e2e`);
+    out[key] = colour;
+  }
+  if (req.font_size !== undefined && req.font_size !== null && req.font_size !== '') {
+    const size = Number(req.font_size);
+    if (!Number.isFinite(size) || size < 6 || size > 48) throw new Error('font_size should be a number from 6 to 48');
+    out.font_size = Math.round(size);
+  }
+  if (req.font) out.font = String(req.font).replace(/["\\\r\n]/g, '').slice(0, 60);
+  if (req.opacity !== undefined && req.opacity !== null && req.opacity !== '') {
+    const opacity = Number(req.opacity);
+    if (!Number.isFinite(opacity) || opacity < 20 || opacity > 100) throw new Error('opacity should be a number from 20 to 100');
+    out.opacity = Math.round(opacity);
+  }
+  return out;
+}
+
+/** Windows Terminal: set the look on the defaults, and on any profile that overrides it. */
+export function applyToWindowsTerminal(settings, want) {
+  const next = structuredClone(settings);
+  if (Array.isArray(next.profiles)) next.profiles = { defaults: {}, list: next.profiles };
+  next.profiles ??= {};
+  next.profiles.defaults ??= {};
+  const set = (profile) => {
+    if (want.background) profile.background = want.background;
+    if (want.foreground) profile.foreground = want.foreground;
+    if (want.cursor) profile.cursorColor = want.cursor;
+    if (want.font || want.font_size) {
+      profile.font = { ...(profile.font ?? {}), ...(want.font ? { face: want.font } : {}), ...(want.font_size ? { size: want.font_size } : {}) };
+    }
+    if (want.opacity !== undefined) {
+      profile.opacity = want.opacity;
+      profile.useAcrylic = want.opacity < 100;
+    }
+  };
+  set(next.profiles.defaults);
+  // A profile with its own value would hide the default, so it changes too.
+  const keys = ['background', 'foreground', 'cursorColor', 'font', 'opacity'];
+  for (const profile of next.profiles.list ?? []) {
+    if (keys.some((k) => profile[k] !== undefined)) set(profile);
+  }
+  return next;
+}
+
+const run = (file, args) => new Promise((resolve) => {
+  execFile(file, args, { windowsHide: true, timeout: 15_000 }, (err, stdout, stderr) =>
+    resolve({ ok: !err, out: String(stdout ?? '').trim(), err: String(stderr || err?.message || '').trim() }));
+});
+
+/** AppleScript's colours run 0-65535. */
+const appleColour = (hex) => `{${hexRGB(hex).map((v) => v * 257).join(', ')}}`;
+const TAB = 'selected tab of front window';
+
+async function appleTerminal(want) {
+  const backup = path.join(backups(), 'apple-terminal.json');
+  if (!existsSync(backup)) {
+    const get = await run('osascript', ['-e', `tell application "Terminal" to get {background color, normal text color, cursor color, font name, font size} of ${TAB}`]);
+    if (get.ok) {
+      await fs.mkdir(backups(), { recursive: true });
+      await fs.writeFile(backup, JSON.stringify({ raw: get.out }));
+    }
+  }
+  const lines = [];
+  if (want.background) lines.push(`set background color of ${TAB} to ${appleColour(want.background)}`);
+  if (want.foreground) lines.push(`set normal text color of ${TAB} to ${appleColour(want.foreground)}`);
+  if (want.cursor) lines.push(`set cursor color of ${TAB} to ${appleColour(want.cursor)}`);
+  if (want.font) lines.push(`set font name of ${TAB} to "${want.font}"`);
+  if (want.font_size) lines.push(`set font size of ${TAB} to ${want.font_size}`);
+  if (!lines.length) return { ok: false, message: 'Terminal can change colours, the cursor, the font and its size here — not the opacity.' };
+  const script = ['tell application "Terminal"', ...lines.map((l) => `  ${l}`), 'end tell'].join('\n');
+  const done = await run('osascript', ['-e', script]);
+  return done.ok
+    ? { ok: true, message: `Changed this Terminal window${want.opacity !== undefined ? ' (opacity is not something Terminal lets ucode set)' : ''}.` }
+    : { ok: false, message: `Terminal refused: ${done.err}. macOS may need ucode's terminal allowed under Privacy & Security > Automation.` };
+}
+
+/** The escape sequences for colours: iTerm2's own, or the xterm ones nearly everything reads. */
+export function colourEscapes(kind, want) {
+  const hex = (h) => h.slice(1);
+  if (kind === 'iterm') {
+    return [
+      want.background && `\x1b]1337;SetColors=bg=${hex(want.background)}\x07`,
+      want.foreground && `\x1b]1337;SetColors=fg=${hex(want.foreground)}\x07`,
+      want.cursor && `\x1b]1337;SetColors=curbg=${hex(want.cursor)}\x07`,
+    ].filter(Boolean).join('');
+  }
+  return [
+    want.foreground && `\x1b]10;${want.foreground}\x07`,
+    want.background && `\x1b]11;${want.background}\x07`,
+    want.cursor && `\x1b]12;${want.cursor}\x07`,
+  ].filter(Boolean).join('');
+}
+
+/**
+ * Change the terminal. Resolves to { ok, message } and never throws on a
+ * terminal that cannot do it; throws only on a request that makes no sense.
+ */
+export async function customizeTerminal(request, { env = process.env, platform = process.platform, write = (s) => process.stdout.write(s) } = {}) {
+  const want = cleanRequest(request);
+  if (!Object.keys(want).length) throw new Error('Say what to change: background, foreground, cursor, font, font_size or opacity.');
+  const kind = detectTerminal(env, platform);
+
+  if (kind === 'windows-terminal') {
+    const file = windowsTerminalSettings(env);
+    if (!file) return { ok: false, message: 'Could not find Windows Terminal\'s settings.json.' };
+    const text = await fs.readFile(file, 'utf8');
+    if (!text.trim()) return { ok: false, message: 'Windows Terminal\'s settings.json is empty, so it was left alone.' };
+    let settings;
+    try {
+      settings = JSON.parse(jsonrepair(text.replace(/^/, '')));
+    } catch {
+      return { ok: false, message: 'Windows Terminal\'s settings.json could not be read, so it was left alone.' };
+    }
+    await fs.mkdir(backups(), { recursive: true });
+    const backup = path.join(backups(), 'windows-terminal.json');
+    if (!existsSync(backup)) await fs.writeFile(backup, JSON.stringify({ file, text }));
+    await fs.writeFile(file, `${JSON.stringify(applyToWindowsTerminal(settings, want), null, 4)}\n`);
+    return { ok: true, message: 'Changed Windows Terminal — every tab, and it stays. "/theme terminal reset" puts it back.' };
+  }
+
+  if (kind === 'apple-terminal') return appleTerminal(want);
+
+  if (kind === 'windows-console') {
+    return { ok: false, message: 'The old Windows console cannot be changed from here. Windows Terminal (free in the Microsoft Store) can.' };
+  }
+
+  const escapes = colourEscapes(kind, want);
+  if (!escapes) return { ok: false, message: `${TERMINAL_NAMES[kind]} only lets ucode change its colours, not the font or opacity.` };
+  write(escapes);
+  const skipped = want.font || want.font_size || want.opacity !== undefined ? ' The font and opacity are not something it lets ucode set.' : '';
+  return { ok: true, message: `Changed ${TERMINAL_NAMES[kind]}'s colours for this session.${skipped}` };
+}
+
+/** Put the terminal back as it was before ucode changed it. */
+export async function resetTerminal({ env = process.env, platform = process.platform, write = (s) => process.stdout.write(s) } = {}) {
+  const kind = detectTerminal(env, platform);
+  if (kind === 'windows-terminal') {
+    const backup = path.join(backups(), 'windows-terminal.json');
+    if (!existsSync(backup)) return { ok: false, message: 'ucode has not changed Windows Terminal, so there is nothing to put back.' };
+    const { file, text } = JSON.parse(await fs.readFile(backup, 'utf8'));
+    await fs.writeFile(file, text);
+    await fs.rm(backup, { force: true });
+    return { ok: true, message: 'Windows Terminal is back the way it was.' };
+  }
+  if (kind === 'apple-terminal') {
+    const backup = path.join(backups(), 'apple-terminal.json');
+    if (!existsSync(backup)) return { ok: false, message: 'ucode has not changed this Terminal window.' };
+    const { raw } = JSON.parse(await fs.readFile(backup, 'utf8'));
+    const n = raw.split(/,\s*/);
+    // {r,g,b} three times, then the font name and size.
+    if (n.length >= 11) {
+      const colour = (i) => `{${n.slice(i, i + 3).join(', ')}}`;
+      await run('osascript', ['-e', [
+        'tell application "Terminal"',
+        `  set background color of ${TAB} to ${colour(0)}`,
+        `  set normal text color of ${TAB} to ${colour(3)}`,
+        `  set cursor color of ${TAB} to ${colour(6)}`,
+        `  set font name of ${TAB} to "${n[9].replace(/"/g, '')}"`,
+        `  set font size of ${TAB} to ${Number(n[10]) || 12}`,
+        'end tell',
+      ].join('\n')]);
+    }
+    await fs.rm(backup, { force: true });
+    return { ok: true, message: 'This Terminal window is back the way it was.' };
+  }
+  write(kind === 'iterm' ? '\x1b]1337;SetColors=preset=Default\x07' : '\x1b]110\x07\x1b]111\x07\x1b]112\x07');
+  return { ok: true, message: 'The terminal\'s own colours are back.' };
+}

package/src/core/tests.js

@@ -42,7 +42,11 @@ export async function testRunnerFor(dir) {
     ['pytest.ini', 'pyproject.toml', 'setup.cfg', 'tox.ini'].map((f) =>
       fs.access(path.join(dir, f)).then(() => true, () => false))
   );
-  return py.some(Boolean) ? 'pytest' : null;
+  if (py.some(Boolean)) return 'pytest';
+  const at = (f) => fs.access(path.join(dir, f)).then(() => true, () => false);
+  if (await at('go.mod')) return 'go';
+  if (await at('Cargo.toml')) return 'cargo';
+  return null;
 }
 
 /** Quote a path for a shell, and use forward slashes so Windows agrees. */
@@ -71,6 +75,15 @@ export function relatedCommand(runner, files) {
     if (!tests.length) return null;
     return `python -m pytest -q ${tests.map(arg).join(' ')}`;
   }
+  // Go tests a package at a time: the packages that hold the changed files.
+  if (runner === 'go') {
+    const dirs = [...new Set(list.filter((f) => /\.go$/i.test(f)).map((f) => path.dirname(f).replace(/\\/g, '/')))];
+    if (!dirs.length) return null;
+    return `go test ${dirs.map((d) => `./${d === '.' ? '' : `${d}/`}...`).join(' ')}`;
+  }
+  if (runner === 'cargo') {
+    return list.some((f) => /\.rs$/i.test(f)) ? 'cargo test --quiet' : null;
+  }
   return null;
 }
 

package/src/tools/browser.js

@@ -154,7 +154,8 @@ async function review(shots) {
     // tokens came back as an empty review. Keep the thinking short, and leave
     // room for the answer.
     maxOutputTokens: 4000,
-    reasoning: { effort: 'low' },
+    // Gemini's own field; the OpenRouter-style `reasoning` object was ignored.
+    effort: 'low',
     // The free vision model is often busy. One try, and a hard cap: a review
     // that cannot run is skipped, never waited on.
     attempts: 1,

package/src/tools/index.js

@@ -722,6 +722,10 @@ export function describe(name, args = {}) {
       return `Searching the web for ${clip(args.query, 60)}`;
     case 'load_skill':
       return `Loading the ${clip(args.name, 40)} skill`;
+    case 'change_look':
+      return args.reset ? 'Putting ucode\'s look back' : 'Changing how ucode looks';
+    case 'change_terminal':
+      return args.reset ? 'Putting the terminal back' : 'Changing the terminal';
     default:
       return `${name} ${clip(JSON.stringify(args), 60)}`;
   }

package/src/tools/search.js

@@ -3,6 +3,7 @@
  * name pattern, and which lines match a regular expression.
  */
 
+import { spawn } from 'node:child_process';
 import { promises as fs } from 'node:fs';
 import path from 'node:path';
 import { ToolFailure } from '../core/failure.js';
@@ -11,6 +12,59 @@ import {
   SKIP, MAX_GLOB_HITS, MAX_GREP_HITS, WALK_WIDTH,
 } from './shared.js';
 
+/** Whether `rg` runs here, asked once. UCODE_RIPGREP=0 never uses it. */
+let hasRipgrep;
+function ripgrepReady() {
+  if (process.env.UCODE_RIPGREP === '0') return Promise.resolve(false);
+  hasRipgrep ??= new Promise((resolve) => {
+    const child = spawn('rg', ['--version'], { windowsHide: true, stdio: 'ignore' });
+    child.on('error', () => resolve(false));
+    child.on('close', (code) => resolve(code === 0));
+  });
+  return hasRipgrep;
+}
+
+/**
+ * The same search through ripgrep, with the same rules as the walk below: the
+ * same folders skipped, hidden files and .gitignored ones searched, the same
+ * line format. Resolves to { hits, files }, or null when ripgrep is missing or
+ * cannot read the pattern.
+ */
+async function ripgrep(pattern, dir, { filter, ignoreCase }) {
+  if (!(await ripgrepReady())) return null;
+  const args = ['--line-number', '--no-heading', '--color', 'never', '--hidden', '--no-ignore', '--sort', 'path'];
+  for (const skip of SKIP) args.push('-g', `!${skip}/`);
+  if (filter) args.push('-g', filter);
+  if (ignoreCase) args.push('-i');
+  args.push('-e', pattern, '--', '.');
+
+  return new Promise((resolve) => {
+    const hits = [];
+    const files = new Set();
+    let rest = '';
+    let done = false;
+    const child = spawn('rg', args, { cwd: dir, windowsHide: true });
+    const finish = (value) => { if (!done) { done = true; resolve(value); } };
+    child.on('error', () => finish(null));
+    child.stdout.setEncoding('utf8');
+    child.stdout.on('data', (chunk) => {
+      const lines = (rest + chunk).split(/\r?\n/);
+      rest = lines.pop();
+      for (const line of lines) {
+        const m = /^(.*?):(\d+):(.*)$/.exec(line);
+        if (!m || hits.length >= MAX_GREP_HITS) continue;
+        const rel = m[1].replace(/^\.[\\/]/, '').replace(/\\/g, '/');
+        const text = m[3].trim();
+        files.add(rel);
+        hits.push(`${rel}:${m[2]}: ${text.length > 200 ? `${text.slice(0, 200)}…` : text}`);
+      }
+      if (hits.length >= MAX_GREP_HITS) { child.kill(); finish({ hits, files: files.size }); }
+    });
+    // 0 found, 1 nothing found, 2 an error such as a pattern it cannot read.
+    child.on('close', (code) => finish(code === 0 || code === 1 || hits.length ? { hits, files: files.size } : null));
+  });
+}
+
 export async function listDir({ path: p = '.' }) {
   const target = resolveIn(p || '.', 'list_dir');
   await guard(target, `list ${target.abs}`);
@@ -131,6 +185,26 @@ export async function grep({ pattern, path: p = '.', glob: filter, ignore_case =
     throw fsFailure(err, 'searching file contents', target.show);
   });
 
+  // A directory goes to ripgrep when it is installed: it is many times faster
+  // on a real project. A pattern ripgrep reads differently (lookarounds,
+  // back-references) makes it fail, and the search below runs instead.
+  if (!stat.isFile()) {
+    const fast = await ripgrep(pattern, target.abs, { filter, ignoreCase: ignore_case });
+    if (fast) {
+      if (!fast.hits.length) {
+        return result(`No line matched /${pattern}/ under ${target.show}${filter ? ` (limited to ${filter})` : ''}.`, 'no matches');
+      }
+      const capped = fast.hits.length >= MAX_GREP_HITS
+        ? `\n[stopped at ${MAX_GREP_HITS} matches — narrow the pattern, or pass a glob]`
+        : '';
+      return result(
+        fast.hits.join('\n') + capped,
+        `${fast.hits.length} match${fast.hits.length === 1 ? '' : 'es'} in ` +
+        `${fast.files} file${fast.files === 1 ? '' : 's'}`
+      );
+    }
+  }
+
   let base = target.abs;
   let candidates;
   if (stat.isFile()) {