@semalt-ai/code 1.8.5 → 1.20.0

package/test/exec-diff.test.js

@@ -0,0 +1,268 @@
+'use strict';
+
+// Execution-time file-edit diffs.
+//
+// The fix moves file-edit diff rendering OUT of the permission modal and INTO
+// the execution-result path, so the diff renders for EVERY edit regardless of
+// approval state (manual-approved, auto-approved) or entry mode (fresh /
+// --resume / /history / /chats). These tests pin the three layers of that fix:
+//
+//   1. lib/ui/diff.js renderDiff — the changed-line cap (head+tail + notice for
+//      a large edit; full render for a small edit or a series of small edits).
+//   2. lib/ui/diff.js buildExecutionDiff — the once-per-edit decision: renders
+//      when a payload is present, returns null on error / no payload (a loaded
+//      history turn carries none, so past turns are NOT replayed) / no-op edit.
+//   3. The mutating executors (write/append/edit_file/replace_in_file) attach
+//      the before/after payload UNCONDITIONALLY — not gated by the permission
+//      modal — which is what makes an auto-approved edit show its diff.
+//
+// Home-based paths are redirected into a temp dir BEFORE any lib module loads,
+// matching test/readonly-tools.test.js.
+
+const os = require('node:os');
+const fs = require('node:fs');
+const path = require('node:path');
+
+const TMP_HOME = fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-diff-home-'));
+const PREV_HOME = process.env.HOME;
+const PREV_USERPROFILE = process.env.USERPROFILE;
+process.env.HOME = TMP_HOME;
+process.env.USERPROFILE = TMP_HOME;
+
+const { test, before, after } = require('node:test');
+const assert = require('node:assert');
+
+const ui = require('../lib/ui');
+const { renderDiff, buildExecutionDiff } = require('../lib/ui/diff');
+const { summarizeToolResult } = require('../lib/ui/format');
+const { createPermissionManager } = require('../lib/permissions');
+const { createToolExecutor } = require('../lib/tools');
+const { DEFAULT_CONFIG } = require('../lib/constants');
+
+// renderDiff styles with ANSI only when stdout.isTTY; under `node --test` it is
+// false, so output is already plain. stripAnsi defends against a TTY harness.
+const stripAnsi = (s) => String(s).replace(/\x1b\[[0-9;]*m/g, '');
+
+function mkExec({ config = {}, pmOpts = {} } = {}) {
+  const pm = createPermissionManager(ui, pmOpts);
+  return createToolExecutor(pm, ui, () => ({
+    max_file_size_kb: 512,
+    command_timeout_ms: 30000,
+    max_output_lines: 50,
+    ...config,
+  }));
+}
+
+let CWD;
+let PREV_CWD;
+
+before(() => {
+  PREV_CWD = process.cwd();
+  CWD = fs.mkdtempSync(path.join(os.tmpdir(), 'semalt-diff-cwd-'));
+  process.chdir(CWD);
+});
+
+after(() => {
+  process.chdir(PREV_CWD);
+  if (PREV_HOME === undefined) delete process.env.HOME; else process.env.HOME = PREV_HOME;
+  if (PREV_USERPROFILE === undefined) delete process.env.USERPROFILE; else process.env.USERPROFILE = PREV_USERPROFILE;
+});
+
+const tmpFile = (name, content) => {
+  const p = path.join(CWD, name);
+  fs.writeFileSync(p, content);
+  return p;
+};
+
+// ── 1. renderDiff cap ───────────────────────────────────────────────────────
+
+test('renderDiff: small edit renders fully with no truncation notice', () => {
+  const out = stripAnsi(renderDiff('a\nb\nc', 'a\nB\nc', 'f.txt', { maxLines: 50 }));
+  assert.match(out, /B/, 'the changed line is shown');
+  assert.doesNotMatch(out, /more changed lines/, 'no cap notice for a small edit');
+});
+
+test('renderDiff: edit exceeding diff_max_lines renders head+tail + notice', () => {
+  const before = Array.from({ length: 100 }, (_, i) => `old ${i}`).join('\n');
+  const after = Array.from({ length: 100 }, (_, i) => `new ${i}`).join('\n');
+  const out = stripAnsi(renderDiff(before, after, 'big.txt', { maxLines: 10 }));
+  // 100 removed + 100 added = 200 changed lines, capped at 10 (head 6 + tail 4).
+  assert.match(out, /…\s*190 more changed lines \(200 total\)/, 'notice reports elided + total changed lines');
+  // Head shows the first removed line; tail shows the last added line.
+  assert.match(out, /old 0/, 'head of the diff is present');
+  assert.match(out, /new 99/, 'tail of the diff is present');
+  // Bounded: head(6) + notice + tail(4) = 11 lines, far below the input.
+  assert.ok(out.split('\n').length <= 14, 'capped output is bounded');
+});
+
+test('renderDiff: a series of small edits each render fully (no spurious truncation)', () => {
+  for (let i = 0; i < 5; i++) {
+    const before = `line one\nline two\nline three`;
+    const after = `line one\nline two CHANGED ${i}\nline three`;
+    const out = stripAnsi(renderDiff(before, after, `s${i}.txt`, { maxLines: 50 }));
+    assert.match(out, new RegExp(`CHANGED ${i}`), `edit ${i} renders its change`);
+    assert.doesNotMatch(out, /more changed lines/, `edit ${i} is not truncated`);
+  }
+});
+
+test('renderDiff: a large NEW file is also capped on changed (added) lines', () => {
+  const after = Array.from({ length: 80 }, (_, i) => `gen ${i}`).join('\n');
+  const out = stripAnsi(renderDiff('', after, 'new.txt', { maxLines: 10 }));
+  assert.match(out, /more changed lines \(80 total\)/, 'new-file additions count as changed lines');
+});
+
+// ── 1b. D3 (Output Refactor Phase 2): the diff body no longer repeats the path ─
+// The result line above the diff already states the file path (the descriptor's
+// `target`). The diff body therefore drops its redundant path header — the path
+// is stated once, on the result line. The @@ hunk ranges and the (new file)
+// marker remain; only the bare path-header line is gone.
+
+test('D3: an existing-file diff body does NOT restate the file path', () => {
+  const out = stripAnsi(renderDiff('a\nb\nc', 'a\nB\nc', 'unique/path/to/file.js', { maxLines: 50 }));
+  assert.doesNotMatch(out, /unique\/path\/to\/file\.js/, 'the path is not repeated in the diff body');
+  assert.match(out, /B/, 'the changed line is still shown');
+  assert.match(out, /@@/, 'the hunk range header remains');
+});
+
+test('D3: the capped diff body also omits the redundant path header', () => {
+  const before = Array.from({ length: 100 }, (_, i) => `old ${i}`).join('\n');
+  const after = Array.from({ length: 100 }, (_, i) => `new ${i}`).join('\n');
+  const out = stripAnsi(renderDiff(before, after, 'capped/unique-path.txt', { maxLines: 10 }));
+  assert.doesNotMatch(out, /capped\/unique-path\.txt/, 'no path header on the capped path');
+  // The cap notice + head + tail are unchanged.
+  assert.match(out, /…\s*190 more changed lines \(200 total\)/);
+  assert.match(out, /old 0/, 'head of the diff is present');
+  assert.match(out, /new 99/, 'tail of the diff is present');
+});
+
+test('D3: a new-file diff keeps its @@ (new file) marker but not a path header', () => {
+  const out = stripAnsi(renderDiff('', 'one\ntwo\nthree', 'brand/new-file.js', { maxLines: 50 }));
+  assert.doesNotMatch(out, /brand\/new-file\.js/, 'no path header for a new file');
+  assert.match(out, /\(new file\)/, 'the new-file hunk marker remains');
+  assert.match(out, /@@ -0,0 \+1,3 @@/, 'the new-file hunk range remains');
+});
+
+// ── 2. buildExecutionDiff (the once-per-edit decision) ───────────────────────
+
+test('buildExecutionDiff: renders the diff when a payload is present', () => {
+  const out = buildExecutionDiff({ diff: { before: 'a\nb', after: 'a\nB', path: 'f.txt' }, maxLines: 50 });
+  assert.ok(out, 'a diff string is produced');
+  assert.match(stripAnsi(out), /B/);
+});
+
+test('buildExecutionDiff: returns null on a failed edit (no diff under an error)', () => {
+  const out = buildExecutionDiff({ diff: { before: 'a', after: 'b', path: 'f' }, error: { message: 'boom' }, maxLines: 50 });
+  assert.strictEqual(out, null);
+});
+
+test('buildExecutionDiff: returns null with no payload — loaded turns are not replayed', () => {
+  // A loaded-history tool result reaches the UI without a before/after payload
+  // (diffs are never persisted), so nothing replays for past turns.
+  assert.strictEqual(buildExecutionDiff({ diff: null, maxLines: 50 }), null);
+  assert.strictEqual(buildExecutionDiff({ maxLines: 50 }), null);
+  assert.strictEqual(buildExecutionDiff({ diff: { before: 'a' }, maxLines: 50 }), null);
+});
+
+test('buildExecutionDiff: returns null for a no-op edit (before === after)', () => {
+  assert.strictEqual(buildExecutionDiff({ diff: { before: 'x\ny', after: 'x\ny', path: 'f' }, maxLines: 50 }), null);
+});
+
+test('buildExecutionDiff: honors diff_max_lines for the cap', () => {
+  const before = Array.from({ length: 60 }, (_, i) => `o${i}`).join('\n');
+  const after = Array.from({ length: 60 }, (_, i) => `n${i}`).join('\n');
+  const out = stripAnsi(buildExecutionDiff({ diff: { before, after, path: 'p' }, maxLines: 8 }));
+  assert.match(out, /more changed lines \(120 total\)/);
+});
+
+// ── 3. Executors attach the before/after payload unconditionally ─────────────
+// The payload is produced by the executor itself, NOT by the permission modal —
+// so it is present whether the call was manual-approved, auto-approved, or run
+// in any entry mode. (The agent loop forwards it to onToolEnd, which renders it
+// exactly once — the modal no longer carries the full diff.)
+
+test('write (new file): payload captures empty before → full content after', async () => {
+  const exec = mkExec();
+  const f = path.join(CWD, 'created.txt');
+  const r = await exec.agentExecFile('write', f, 'hello\nworld');
+  assert.strictEqual(r.status, 'ok');
+  assert.strictEqual(r._diffBefore, '');
+  assert.strictEqual(r._diffAfter, 'hello\nworld');
+});
+
+test('write (existing file): payload captures prior content as before', async () => {
+  const exec = mkExec();
+  const f = tmpFile('over.txt', 'old text');
+  const r = await exec.agentExecFile('write', f, 'new text');
+  assert.strictEqual(r._diffBefore, 'old text');
+  assert.strictEqual(r._diffAfter, 'new text');
+});
+
+test('append: payload after is prior + appended content', async () => {
+  const exec = mkExec();
+  const f = tmpFile('log.txt', 'line1\n');
+  const r = await exec.agentExecFile('append', f, 'line2\n');
+  assert.strictEqual(r._diffBefore, 'line1\n');
+  assert.strictEqual(r._diffAfter, 'line1\nline2\n');
+});
+
+test('edit_file (single line): payload reflects the one-line swap', async () => {
+  const exec = mkExec();
+  const f = tmpFile('e.txt', 'a\nb\nc');
+  const r = await exec.agentExecFile('edit_file', f, 2, 'B');
+  assert.strictEqual(r._diffBefore, 'a\nb\nc');
+  assert.strictEqual(r._diffAfter, 'a\nB\nc');
+});
+
+test('edit_file (line range): payload reflects the block replacement', async () => {
+  const exec = mkExec();
+  const f = tmpFile('r.txt', 'a\nb\nc\nd');
+  const r = await exec.agentExecFile('edit_file', f, 2, 'X\nY\nZ', 3);
+  assert.strictEqual(r._diffBefore, 'a\nb\nc\nd');
+  assert.strictEqual(r._diffAfter, 'a\nX\nY\nZ\nd');
+});
+
+test('replace_in_file: payload captures before/after of the replacement', async () => {
+  const exec = mkExec();
+  const f = tmpFile('rep.txt', 'foo bar foo');
+  const r = await exec.agentExecFile('replace_in_file', f, 'bar', 'baz', '');
+  assert.strictEqual(r._diffBefore, 'foo bar foo');
+  assert.strictEqual(r._diffAfter, 'foo baz foo');
+});
+
+test('a failed edit attaches NO payload (out-of-range line)', async () => {
+  const exec = mkExec();
+  const f = tmpFile('oor.txt', 'one\ntwo');
+  const r = await exec.agentExecFile('edit_file', f, 99, 'X');
+  assert.ok(r.error, 'the edit failed');
+  assert.strictEqual(r._diffBefore, undefined, 'no diff payload on a failed edit');
+});
+
+// End-to-end through buildExecutionDiff: the executor payload renders a real diff
+// for an auto-approve-style call (no modal involved in this harness at all).
+test('parity: an executor payload renders a diff with no modal in the loop', async () => {
+  const exec = mkExec();
+  const f = tmpFile('parity.txt', 'keep\nold\nkeep');
+  const r = await exec.agentExecFile('edit_file', f, 2, 'new');
+  const out = stripAnsi(buildExecutionDiff({
+    diff: { before: r._diffBefore, after: r._diffAfter, path: f },
+    maxLines: DEFAULT_CONFIG.diff_max_lines,
+  }));
+  assert.match(out, /new/, 'the new content shows in the rendered diff');
+  assert.match(out, /old/, 'the removed content shows in the rendered diff');
+});
+
+// ── 4. No replay: loaded history collapses to summaries, not diffs ───────────
+
+test('loaded-history file results summarize to a one-liner (never a diff)', () => {
+  // displayLoadedMessages renders stored tool results through summarizeToolResult.
+  // A persisted write result is a short "Wrote …" line — there is no diff to replay.
+  const summary = summarizeToolResult('Wrote 42 bytes to /tmp/x.txt');
+  assert.strictEqual(summary, 'Wrote 42 bytes to /tmp/x.txt');
+  assert.doesNotMatch(summary, /more changed lines/);
+});
+
+// ── config default ───────────────────────────────────────────────────────────
+
+test('diff_max_lines has a sane default', () => {
+  assert.strictEqual(DEFAULT_CONFIG.diff_max_lines, 50);
+});