fix(levelcode-ai): #107 review — a long command's result starts at its real start and counts what it left out

The bug: runCommand keeps only the last 262144 characters of a command's output in memory, and
commandResult then took its "start" from that buffer and counted the omitted characters against it.
Above 256 KiB the start the model saw came from the middle of the output, and the gap was a lie: a 2 MB
`cat` was reported as "[~254000 characters of output omitted]". The desktop and the browser shell share
this code, so both were affected.

The fix: runCommand also keeps the first 8000 characters of the output and counts every character it
was given. When the buffer has dropped the beginning, commandResult is handed that real start and the
true total, so the start shown is the start and kept + omitted is the whole output. Output up to 256 KiB
goes through exactly as before (nothing extra is passed).

Test: agentCommandResult.test.js "OUTPUT OVER 256 KiB: the start is the command's real start, and the
omitted count is everything that is not shown" drives the real runAgent -> run_command -> runCommand
chain with about 2.2 MB of output. It fails on the unfixed code (the result started at line 61809) and
passes now; the other agentCommandResult, agentRunCommand (untouched) and shellSeam tests still pass.

Author: ndemianc

extensions/levelcode-ai/agent.js

@@ -421,19 +421,27 @@ function isBinaryFile(abs) { return host.isBinary(abs); }
  * Output that fits is returned exactly as it always was. Output that does not keeps its START and its END with
  * the gap said out loud, and the status line (`[exit 1]`, `[timed out]`, `[stopped by user]`) is never what is cut:
  * it used to be, because it sits at the end and the whole thing was sliced from the front.
- * @param {string} out
+ * @param {string} out    the output — or, when runCommand kept only its end (OUT_KEPT), that end
  * @param {string} note
  * @param {number} [max]
+ * @param {{ start: string, total: number }} [whole]  when `out` is only the end: the output's real start (at least a
+ *   quarter of `max` of it) and how many characters there were in all, so the start shown is the start and the count
+ *   of what was left out is the true one
  */
-function commandResult(out, note, max) {
+function commandResult(out, note, max, whole) {
 	max = max || 8000;
-	if (out.length + note.length <= max) { return out + note; }
+	const total = whole ? whole.total : out.length;
+	if (total + note.length <= max) { return out + note; }
 	const gapText = (n) => '\n… [' + n + ' characters of output omitted] …\n';
-	const room = max - note.length - gapText(out.length).length;
+	const room = max - note.length - gapText(total).length;
 	const head = Math.max(0, Math.floor(room / 4));      // a quarter for the start, the rest for the end — where the failure is
 	const tail = Math.max(0, room - head);
-	return out.slice(0, head) + gapText(out.length - head - tail) + out.slice(out.length - tail) + note;
+	return (whole ? whole.start : out).slice(0, head) + gapText(total - head - tail) + out.slice(out.length - tail) + note;
 }
+/** What runCommand keeps of a command's output in memory: its last OUT_KEPT characters and, apart from them, its first
+ *  START_KEPT (more than commandResult ever shows of a start). */
+const OUT_KEPT = 262144;
+const START_KEPT = 8000;
 
 // Run a shell command, STREAMING its output: onChunk(text, 'stdout'|'stderr') fires as it runs (live
 // terminal in the chat), onExit(code, ms, how) at the end. onStart(child, stop) exposes a stop() that
@@ -446,12 +454,15 @@ function commandResult(out, note, max) {
 function runCommand(root, command, onChunk, onExit, onStart, timeoutMs, opts) {
 	return new Promise((resolve) => {
 		let out = '', streamed = 0, settled = false, timedOut = false, stopped = false;
+		let head = '', total = 0;             // the output's first START_KEPT characters, and its length: `out` keeps only the end
 		const STREAM_CAP = 100000;            // max we push to the live terminal view
 		const start = Date.now();
 		const onData = opts && opts.onData;
 		const cap = (s, stream) => {
 			out += s;
-			if (out.length > 262144) { out = out.slice(-262144); }   // bound the model buffer's memory
+			total += s.length;
+			if (head.length < START_KEPT) { head += s.slice(0, START_KEPT - head.length); }
+			if (out.length > OUT_KEPT) { out = out.slice(-OUT_KEPT); }   // bound the model buffer's memory
 			if (onChunk && streamed < STREAM_CAP) {
 				const room = STREAM_CAP - streamed;
 				const piece = s.length > room ? s.slice(0, room) : s;
@@ -481,7 +492,7 @@ function runCommand(root, command, onChunk, onExit, onStart, timeoutMs, opts) {
 			const exit = stopped ? 130 : (timedOut ? 124 : (code == null ? -1 : code));
 			if (onExit) { onExit(exit, ms, how); }
 			const note = stopped ? '\n[stopped by user]' : timedOut ? '\n[timed out]' : (exit !== 0 ? '\n[exit ' + exit + ']' : '');
-			resolve(commandResult(out, note) || '(no output)');
+			resolve(commandResult(out, note, undefined, total > out.length ? { start: head, total } : undefined) || '(no output)');
 		};
 		child.on('close', (code) => finish(code));
 		child.on('error', (e) => { cap('\n' + ((e && e.message) || e), 'stderr'); finish(1); });

extensions/levelcode-ai/test/agentCommandResult.test.js

@@ -85,6 +85,31 @@ const line = (i) => 'line ' + String(i).padStart(4, '0') + ' ' + 'x'.repeat(20)
 			assert.strictEqual(r.length - '\n[exit 1]'.length - (r.match(/\n… \[\d+ characters of output omitted\] …\n/)[0].length) + omitted, total, 'nothing is lost silently: kept + omitted = everything');
 		});
 
+		await test('OUTPUT OVER 256 KiB: the start is the command\'s real start, and the omitted count is everything that is not shown', async () => {
+			// runCommand keeps only the last 256 KiB of the output in memory; a 2 MB `cat` used to come back with a "start"
+			// from the middle of the file and "[~254000 characters of output omitted]" for about two million.
+			let total = 0;
+			const r = await result((c) => {
+				const first = 'BEGIN of the output\n';
+				c.stdout.emit('data', Buffer.from(first)); total += first.length;
+				for (let k = 0; k < 70; k++) {
+					let chunk = '';
+					for (let i = 0; i < 1000; i++) { chunk += line(k * 1000 + i); }
+					c.stdout.emit('data', Buffer.from(chunk)); total += chunk.length;
+				}
+				const last = 'FAIL at the very end\n';
+				c.stderr.emit('data', Buffer.from(last)); total += last.length;
+				c.emit('close', 1);
+			});
+			assert.ok(total > 2000000, 'about 2 MB: ' + total);
+			assert.ok(r.length <= 8000, 'still bounded: ' + r.length);
+			assert.ok(r.startsWith('BEGIN of the output\nline 0000 '), 'the start is the real start: ' + JSON.stringify(r.slice(0, 60)));
+			assert.ok(r.endsWith('FAIL at the very end\n\n[exit 1]'), 'the end and the status: ' + JSON.stringify(r.slice(-40)));
+			const gap = /\n… \[(\d+) characters of output omitted\] …\n/.exec(r);
+			assert.ok(gap, 'the gap is said out loud');
+			assert.strictEqual(r.length - '\n[exit 1]'.length - gap[0].length + Number(gap[1]), total, 'kept + omitted = everything the command wrote');
+		});
+
 		await test('a timeout and a stop are still said, however much came before', async () => {
 			const noisy = (c) => { for (let i = 0; i < 1000; i++) { c.stdout.emit('data', Buffer.from(line(i))); } };
 			const t = await result((c) => { noisy(c); }, { commandTimeout: 30 });