loom-agent 1.2.0

package/src/core/events.js

@@ -0,0 +1,24 @@
+// Tiny synchronous event bus. Core emits lifecycle events (turn start/end,
+// model switch, tool calls, cost recorded); features like the pet, toasts, and
+// telemetry subscribe without coupling.
+const listeners = new Map();
+
+function on(event, fn) {
+  if (!listeners.has(event)) listeners.set(event, new Set());
+  listeners.get(event).add(fn);
+  return () => listeners.get(event).delete(fn);
+}
+
+function off(event, fn) {
+  listeners.get(event)?.delete(fn);
+}
+
+function emit(event, data) {
+  const set = listeners.get(event);
+  if (!set) return;
+  for (const fn of Array.from(set)) {
+    try { fn(data); } catch {}
+  }
+}
+
+module.exports = { on, off, emit };

package/src/core/file-diffs.js

@@ -0,0 +1,282 @@
+// File-diff capture for the chat area — right-side visual panel showing
+// which files the agent edited and the actual +/- hunks.
+// Snapshot BEFORE a write/edit/bash tool runs, then record AFTER to build the diff.
+const fs = require('fs');
+const path = require('path');
+const { execSync } = require('child_process');
+const { diffLines } = require('diff');
+
+const cwd = process.cwd();
+
+// Binary content (png/pdf/zip/exe…) read as utf8 is meaningless garbage, and
+// diffing it fills the panel with noise. Detect it up front and show a short
+// "(binary file)" line instead of the hunks.
+function looksBinary(text) {
+  if (!text) return false;
+  const sample = text.slice(0, 8192);
+  if (sample.indexOf('\0') >= 0) return true;
+  let bad = 0;
+  for (let i = 0; i < sample.length; i++) {
+    const c = sample.charCodeAt(i);
+    if (c < 8) bad++;
+  }
+  return bad / Math.max(1, sample.length) > 0.02;
+}
+
+// Mirrors the TUI file walker's ignore list (node_modules, .git, dist, …).
+const IGNORE_RX = /(^|[\/])(node_modules|\.git|dist|build|\.next|\.venv|venv|coverage|__pycache__|\.loom|\.idea|\.vscode)([\/]|$)/i;
+
+function relPath(abs) {
+  const rel = path.relative(cwd, abs).replace(/\\/g, '/');
+  return rel || abs;
+}
+
+// Read file content, or null if missing.
+function readFileOrNull(abs) {
+  try { return fs.readFileSync(abs, 'utf8'); } catch { return null; }
+}
+
+// Track edits per session: abs path -> { before, after }
+const edits = new Map();
+
+export function snapshotBefore(filePath) {
+  const abs = path.resolve(filePath);
+  const before = readFileOrNull(abs);
+  edits.set(abs, { before, after: before });
+  return { abs, before };
+}
+
+// After the tool finished, re-read the file and build the diff vs. the
+// pre-edit snapshot. Accumulates: if the same file is edited twice in one
+// turn, diff is always against the ORIGINAL snapshot (cumulative view).
+export function snapshotAfter(filePath) {
+  const abs = path.resolve(filePath);
+  const prev = edits.get(abs) || { before: null };
+  const after = readFileOrNull(abs);
+  prev.after = after;
+  edits.set(abs, prev);
+  return buildFileDiff(abs, prev.before, prev.after);
+}
+
+// ─── Bash tool detection ───
+// The bash tool can modify files outside write/edit (sed -i, git apply, npm
+// install, scaffolders, …). Snapshot the repo state before the call, then
+// diff after it: git repos use `git diff` (accurate, no content copies);
+// non-git directories snapshot small file contents + mtimes.
+let bashBefore = null; // { git: bool, files: Map<abs, {content|null, mtimeMs, size}>, untracked: Set<abs> }
+
+function walkFiles(root, depth, out) {
+  if (depth > 5 || out.length > 400) return;
+  let entries;
+  try { entries = fs.readdirSync(root, { withFileTypes: true }); } catch { return; }
+  for (const e of entries) {
+    const full = path.join(root, e.name);
+    if (IGNORE_RX.test(full)) continue;
+    if (e.isDirectory()) walkFiles(full, depth + 1, out);
+    else out.push(full);
+  }
+}
+
+function git(args) {
+  try {
+    return execSync('git ' + args, { cwd: process.cwd(), encoding: 'utf8', timeout: 10000, stdio: ['ignore', 'pipe', 'pipe'], windowsHide: true });
+  } catch {
+    return null;
+  }
+}
+
+export function snapshotBashBefore() {
+  const isGit = git('rev-parse --is-inside-work-tree') === 'true';
+  const files = new Map();
+  if (isGit) {
+    const untracked = new Set();
+    const st = git('status --porcelain');
+    for (const line of String(st || '').split('\n')) {
+      if (/^\?\?/.test(line)) untracked.add(path.resolve(cwd, line.slice(3).trim()));
+    }
+    bashBefore = { git: true, files, untracked };
+  } else {
+    const list = [];
+    walkFiles(cwd, 0, list);
+    for (const f of list) {
+      try {
+        const st = fs.statSync(f);
+        let content = null;
+        if (st.size <= 1024 * 1024) content = readFileOrNull(f);
+        files.set(f, { content, mtimeMs: st.mtimeMs, size: st.size });
+      } catch {}
+    }
+    bashBefore = { git: false, files, untracked: new Set() };
+  }
+  return isGit;
+}
+
+// After the bash tool finished, return diffs for everything it changed.
+export function diffBashAfter() {
+  if (!bashBefore) return [];
+  const out = [];
+  if (bashBefore.git) {
+    const diffText = git('diff --no-color --no-ext-diff') || '';
+    for (const d of parseGitDiff(diffText)) out.push(d);
+    // New untracked files → all-added diffs.
+    const st = git('status --porcelain') || '';
+    for (const line of st.split('\n')) {
+      if (!/^\?\?/.test(line)) continue;
+      const abs = path.resolve(cwd, line.slice(3).trim());
+      if (bashBefore.untracked.has(abs)) continue; // was already there
+      const d = buildFileDiff(abs, null, readFileOrNull(abs));
+      if (d.added || d.removed) out.push(d);
+    }
+  } else {
+    const list = [];
+    walkFiles(cwd, 0, list);
+    const now = new Map();
+    for (const f of list) {
+      try {
+        const st = fs.statSync(f);
+        now.set(f, { mtimeMs: st.mtimeMs, size: st.size });
+      } catch {}
+    }
+    // Changed or deleted files.
+    const changed = [];
+    for (const [abs, st] of bashBefore.files) {
+      const cur = now.get(abs);
+      if (!cur || cur.mtimeMs !== st.mtimeMs || cur.size !== st.size) changed.push(abs);
+    }
+    for (const abs of now.keys()) {
+      if (!bashBefore.files.has(abs)) changed.push(abs); // newly created
+    }
+    for (const abs of changed) {
+      const before = bashBefore.files.get(abs)?.content;
+      const after = readFileOrNull(abs);
+      const d = buildFileDiff(abs, before, after);
+      if (d.added || d.removed) out.push(d);
+    }
+  }
+  bashBefore = null;
+  return out;
+}
+
+// Parse a unified `git diff` into per-file { path, added, removed, lines }.
+function parseGitDiff(text) {
+  const out = [];
+  const filePat = /^diff --git a\/(.*) b\/(.*)$/;
+  let cur = null;
+  const lines = String(text).split('\n');
+  for (const line of lines) {
+    const fm = line.match(filePat);
+    if (fm) {
+      if (cur && (cur.added || cur.removed)) out.push(cur);
+      const p = fm[2].replace(/^"|"$/g, '');
+      cur = { path: p, abs: path.resolve(cwd, p), added: 0, removed: 0, lines: /** @type {Array<{kind: string, text: string}>} */ ([]) };
+      continue;
+    }
+    if (!cur) continue;
+    if (line.startsWith('@@')) continue;
+    if (line.startsWith('+++') || line.startsWith('---')) continue;
+    if (line.startsWith('\\')) continue;
+    if (/^Binary files/.test(line)) { cur.added++; cur.removed++; cur.lines.push({ kind: 'ctx', text: '(binary file changed)' }); continue; }
+    if (line.startsWith('+')) { if (looksBinary(line.slice(1))) continue; cur.added++; cur.lines.push({ kind: 'add', text: line.slice(1) }); }
+    else if (line.startsWith('-')) { if (looksBinary(line.slice(1))) continue; cur.removed++; cur.lines.push({ kind: 'del', text: line.slice(1) }); }
+    else { if (looksBinary(line.slice(1))) continue; cur.lines.push({ kind: 'ctx', text: line.slice(1) }); }
+  }
+  if (cur && (cur.added || cur.removed)) out.push(cur);
+  for (const d of out) {
+    d.lines = trimContext(d.lines, 2);
+    d.lines = d.lines.length > 24 ? d.lines.slice(0, 24) : d.lines;
+  }
+  return out;
+}
+
+// Build a compact visual diff: counts + colored hunk lines.
+export function buildFileDiff(abs, before, after) {
+  if (looksBinary(after) || looksBinary(before)) {
+    // Unchanged binary file (snapshot taken before a tool that didn't touch
+    // it) → empty diff; don't show a bogus "0 bytes changed" entry.
+    if (before !== null && after !== null && before === after) {
+      return { path: relPath(abs), abs, added: 0, removed: 0, lines: [], isNew: false };
+    }
+    const beforeBytes = before ? Buffer.byteLength(before, 'utf8') : 0;
+    const afterBytes = after ? Buffer.byteLength(after, 'utf8') : 0;
+    const bytesChanged = Math.max(0, Math.abs(afterBytes - beforeBytes));
+    return {
+      path: relPath(abs),
+      abs,
+      added: 1,
+      removed: 0,
+      lines: [{ kind: 'ctx', text: '(binary file, ' + bytesChanged + ' bytes changed)' }],
+      isNew: before === null && after !== null,
+    };
+  }
+  const parts = diffLines(before || '', after || '');
+  let added = 0;
+  let removed = 0;
+  const hunks = [];
+  for (const part of parts) {
+    if (part.added) { added += part.count; }
+    else if (part.removed) { removed += part.count; }
+  }
+  // Line-by-line with kind markers; trim context to keep the panel compact.
+  const lines = diffToLines(parts);
+  const trimmed = trimContext(lines, 2);
+  const shown = trimmed.length > 24 ? trimmed.slice(0, 24) : trimmed;
+  return {
+    path: relPath(abs),
+    abs,
+    added,
+    removed,
+    lines: shown,
+    isNew: before === null && after !== null,
+  };
+}
+
+function diffToLines(parts) {
+  const out = [];
+  for (const part of parts) {
+    if (part.added) out.push({ kind: 'add', text: part.value });
+    else if (part.removed) out.push({ kind: 'del', text: part.value });
+    else out.push({ kind: 'ctx', text: part.value });
+  }
+  return out;
+}
+
+// Keep 2 context lines around each hunk, drop the rest (ellipsis marker).
+function trimContext(lines, ctx) {
+  if (!lines.length) return lines;
+  const keep = [];
+  for (let i = 0; i < lines.length; i++) {
+    if (lines[i].kind !== 'ctx') {
+      for (let j = Math.max(0, i - ctx); j <= Math.min(lines.length - 1, i + ctx); j++) {
+        if (!keep.includes(j)) keep.push(j);
+      }
+    }
+  }
+  keep.sort((a, b) => a - b);
+  if (!keep.length) return [];
+  const out = [];
+  let last = -10;
+  for (const i of keep) {
+    if (i - last > 1) out.push({ kind: 'ctx', text: '…' });
+    out.push(lines[i]);
+    last = i;
+  }
+  return out;
+}
+
+export function clearFileDiffs() { edits.clear(); }
+export function getFileDiffs() {
+  const out = [];
+  for (const [abs, e] of edits) {
+    const d = buildFileDiff(abs, e.before, e.after);
+    if (d.added || d.removed) out.push(d);
+  }
+  return out;
+}
+export function formatDiffCount(d) {
+  const parts = [];
+  if (d.added) parts.push('+' + d.added);
+  if (d.removed) parts.push('-' + d.removed);
+  return parts.join(' ') || '±0';
+}
+
+export { parseGitDiff };

package/src/core/format.js

@@ -0,0 +1,206 @@
+// Formatters — run language-specific formatters on files after the agent
+// writes/edits them (OpenCode-style). Disabled by default; enable via
+// config.json `formatter`: true (all built-ins) or an object of per-formatter
+// overrides / custom formatters.
+//
+//   formatter: false                      → all disabled (default)
+//   formatter: true                       → all built-ins enabled
+//   formatter: { ... }                    → built-ins enabled + overrides
+//   formatter: { prettier: { disabled: true } }            → disable one
+//   formatter: { gofmt: { command: ["gofmt","-w","$FILE"], extensions: [".go"] } }  → override
+//   formatter: { myfmt: { command: ["fmt", "$FILE"], extensions: [".zzz"] } }        → custom
+//
+// The `$FILE` placeholder is replaced with the formatted file's path. When a
+// command has no `$FILE`, the path is appended as the final argument.
+const fs = require('fs');
+const path = require('path');
+const { spawn } = require('child_process');
+const { loadConfig } = require('../config/settings');
+
+/** @typedef {Object} FormatterDef
+ *  @property {Array<string>} command
+ *  @property {Array<string>} extensions
+ */
+
+/** @typedef {Object} FormatResult
+ *  @property {boolean} formatted
+ *  @property {string} [id]
+ *  @property {Array<string>} [command]
+ *  @property {string} [reason]
+ */
+
+/** @type {Record<string, FormatterDef>} */
+const DEFAULT_FORMATTERS = {
+  prettier: {
+    command: ['npx', 'prettier', '--write', '$FILE'],
+    extensions: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.html', '.css', '.scss', '.md', '.json', '.json5', '.yaml', '.yml'],
+  },
+  biome: {
+    command: ['npx', 'biome', 'format', '--write', '$FILE'],
+    extensions: ['.js', '.jsx', '.ts', '.tsx', '.mjs', '.cjs', '.html', '.css', '.json', '.jsonc', '.md'],
+  },
+  gofmt: { command: ['gofmt', '-w', '$FILE'], extensions: ['.go'] },
+  rustfmt: { command: ['rustfmt', '--edition', '2021', '$FILE'], extensions: ['.rs'] },
+  ruff: { command: ['ruff', 'format', '$FILE'], extensions: ['.py', '.pyi'] },
+  uv: { command: ['uv', 'fmt', '$FILE'], extensions: ['.py', '.pyi'] },
+  clangformat: {
+    command: ['clang-format', '-i', '$FILE'],
+    extensions: ['.c', '.h', '.cpp', '.hpp', '.cc', '.cxx', '.hxx', '.ino', '.m', '.mm'],
+  },
+  shfmt: { command: ['shfmt', '-w', '$FILE'], extensions: ['.sh', '.bash'] },
+  ktlint: { command: ['ktlint', '-F', '$FILE'], extensions: ['.kt', '.kts'] },
+  dart: { command: ['dart', 'format', '$FILE'], extensions: ['.dart'] },
+  terraform: { command: ['terraform', 'fmt', '$FILE'], extensions: ['.tf', '.tfvars'] },
+  mix: { command: ['mix', 'format', '$FILE'], extensions: ['.ex', '.exs', '.eex', '.heex', '.leex', '.neex'] },
+  gleam: { command: ['gleam', 'format', '$FILE'], extensions: ['.gleam'] },
+  zig: { command: ['zig', 'fmt', '$FILE'], extensions: ['.zig', '.zon'] },
+  nixfmt: { command: ['nixfmt', '$FILE'], extensions: ['.nix'] },
+  ormolu: { command: ['ormolu', '--mode', 'inplace', '$FILE'], extensions: ['.hs'] },
+  ocamlformat: { command: ['ocamlformat', '--inplace', '$FILE'], extensions: ['.ml', '.mli'] },
+  rubocop: { command: ['rubocop', '-a', '$FILE'], extensions: ['.rb', '.rake', '.gemspec', '.ru'] },
+  standardrb: { command: ['standardrb', '--fix', '$FILE'], extensions: ['.rb', '.rake', '.gemspec', '.ru'] },
+  htmlbeautifier: { command: ['htmlbeautifier', '$FILE'], extensions: ['.erb'] },
+};
+
+/**
+ * Resolve the enabled formatter set from config + built-ins.
+ * @returns {{enabled: boolean, formatters: Record<string, FormatterDef>}}
+ */
+function enabledFormatters() {
+  const cfg = loadConfig();
+  const f = cfg.formatter;
+  if (f === false || f === undefined || f === null) return { enabled: false, formatters: /** @type {Record<string, FormatterDef>} */ ({}) };
+  if (f === true) return { enabled: true, formatters: { ...DEFAULT_FORMATTERS } };
+  if (f && typeof f === 'object') {
+    const out = /** @type {Record<string, FormatterDef>} */ ({});
+    for (const [id, def] of Object.entries(DEFAULT_FORMATTERS)) {
+      const u = f[id];
+      const merged = { command: def.command, extensions: def.extensions, ...(u && typeof u === 'object' ? u : {}) };
+      if (merged.disabled) continue;
+      out[id] = /** @type {FormatterDef} */ ({ command: merged.command, extensions: merged.extensions });
+    }
+    // Custom formatters: any object key that isn't built-in with command+extensions.
+    for (const [id, u] of Object.entries(f)) {
+      if (!u || typeof u !== 'object') continue;
+      if (u.command && Array.isArray(u.extensions)) {
+        if (!u.disabled) out[id] = /** @type {FormatterDef} */ ({ command: u.command, extensions: u.extensions });
+      }
+    }
+    return { enabled: true, formatters: out };
+  }
+  return { enabled: false, formatters: /** @type {Record<string, FormatterDef>} */ ({}) };
+}
+
+/** Substitute the $FILE placeholder (or append the path) in a command.
+ * @param {Array<string>} command
+ * @param {string} filePath
+ * @returns {Array<string>} */
+function buildCommand(command, filePath) {
+  if (command.includes('$FILE')) {
+    return command.map((a) => (a === '$FILE' ? filePath : a));
+  }
+  return command.concat([filePath]);
+}
+
+/** Pick the first enabled formatter that handles the given extension.
+ * @param {string} ext
+ * @returns {{found: boolean, id?: string, command?: Array<string>, reason?: string}} */
+function resolveFormatter(ext) {
+  const { enabled, formatters } = enabledFormatters();
+  if (!enabled) return { found: false, reason: 'formatters are disabled (set config formatter: true to enable)' };
+  const extLower = ext.toLowerCase();
+  const ids = Object.keys(formatters).sort();
+  for (const id of ids) {
+    const def = formatters[id];
+    if (def.extensions.some((e) => e.toLowerCase() === extLower)) {
+      // Return the raw template — the $FILE placeholder is substituted with the
+      // real path in formatFile (resolveFormatter has no path yet).
+      return { found: true, id, command: def.command.slice() };
+    }
+  }
+  return { found: false, reason: `no enabled formatter handles extension "${ext}"` };
+}
+
+/** Run the file through its formatter in place.
+ * @param {string} filePath
+ * @returns {Promise<FormatResult>} */
+function formatFile(filePath) {
+  const ext = path.extname(filePath);
+  const resolved = resolveFormatter(ext);
+  if (!resolved.found) return Promise.resolve({ formatted: false, reason: resolved.reason });
+  const template = resolved.command;
+  const id = resolved.id;
+  if (!template || !id) return Promise.resolve({ formatted: false, reason: 'formatter not resolved' });
+  const command = buildCommand(template, filePath);
+  return new Promise((resolve) => {
+    let child;
+    try {
+      child = spawn(command[0], command.slice(1), {
+        stdio: ['ignore', 'pipe', 'pipe'],
+        windowsHide: true,
+      });
+    } catch (e) {
+      resolve({ formatted: false, reason: e && e.message ? e.message : String(e) });
+      return;
+    }
+    let stdout = '';
+    let stderr = '';
+    let settled = false;
+    const done = (res) => { if (!settled) { settled = true; clearTimeout(timer); resolve(res); } };
+    const timer = setTimeout(() => {
+      try { child.kill(); } catch {}
+      done({ formatted: false, reason: `${id} timed out after 30000ms` });
+    }, 30000);
+    child.stdout.on('data', (d) => { stdout += d.toString(); });
+    child.stderr.on('data', (d) => { stderr += d.toString(); });
+    child.on('error', (err) => {
+      const errCode = err && 'code' in err ? err.code : undefined;
+      if (errCode === 'ENOENT') {
+        done({ formatted: false, reason: `formatter command not found: ${command[0]}. Install it or disable the ${id} formatter.` });
+      } else {
+        done({ formatted: false, reason: err && err.message ? err.message : String(err) });
+      }
+    });
+    child.on('close', (code) => {
+      if (code !== 0) {
+        const msg = String(stderr || stdout || '').trim();
+        done({ formatted: false, reason: `${id} exited ${code}: ${msg.slice(0, 300)}` });
+        return;
+      }
+      done({ formatted: true, id, command });
+    });
+  });
+}
+
+/** Convenience for the tool layer: format a file just written; on success
+ *  return a short note to append to the tool result.
+ * @param {string} filePath
+ * @returns {Promise<string>} */
+async function formatAfterWrite(filePath) {
+  if (!fs.existsSync(filePath)) return '';
+  const res = await formatFile(filePath);
+  return res.formatted ? `\n[formatted by ${res.id}]` : '';
+}
+
+/** A names/status summary of the current formatter setup (for /format).
+ * @returns {Array<string>} */
+function formatStatusLines() {
+  const { enabled, formatters } = enabledFormatters();
+  const lines = [`Formatters: ${enabled ? 'ENABLED' : 'DISABLED'} (set config.json "formatter": true to enable)`];
+  if (enabled) {
+    for (const [id, def] of Object.entries(formatters)) {
+      lines.push(`  ${id.padEnd(16)} ${def.extensions.join(' ')}`);
+    }
+  }
+  return lines;
+}
+
+module.exports = {
+  DEFAULT_FORMATTERS,
+  enabledFormatters,
+  resolveFormatter,
+  buildCommand,
+  formatFile,
+  formatAfterWrite,
+  formatStatusLines,
+};