@agimon-ai/po-runner 0.0.0-alpha.0

package/dist/logFile-KKPbkC-a.mjs

@@ -0,0 +1,60 @@
+import { s as getLogMaxBytes } from "./runnerConfig-BQBlVAXn.mjs";
+import fs from "node:fs";
+//#region src/services/logFile/index.ts
+var LogFile = class {
+	paths;
+	constructor(paths) {
+		this.paths = paths;
+	}
+	open(id) {
+		this.paths.ensureDirectories();
+		const logPath = this.paths.logPathFor(id);
+		const rotatedPath = this.paths.rotatedLogPathFor(id);
+		const maxBytes = getLogMaxBytes();
+		let handle = fs.openSync(logPath, "w");
+		let written = 0;
+		let closed = false;
+		/**
+		* A run that keeps producing output for hours would otherwise grow one file
+		* without limit. Rotating keeps the newest window at the advertised path
+		* and the window before it alongside, so on-disk cost is bounded at roughly
+		* twice the ceiling, the path a result advertises stays valid, and the line
+		* counts a reader reports still describe the file it actually read.
+		*/
+		const rotate = () => {
+			fs.closeSync(handle);
+			try {
+				fs.renameSync(logPath, rotatedPath);
+			} catch (error) {
+				process.emitWarning(`Could not rotate runner log ${logPath}: ${String(error)}`);
+			}
+			handle = fs.openSync(logPath, "w");
+			written = 0;
+		};
+		return {
+			path: logPath,
+			append(text) {
+				const chunk = Buffer.from(text, "utf8");
+				if (written > 0 && written + chunk.byteLength > maxBytes) rotate();
+				fs.writeSync(handle, chunk);
+				written += chunk.byteLength;
+			},
+			size() {
+				return written;
+			},
+			close() {
+				if (closed) return;
+				closed = true;
+				try {
+					fs.closeSync(handle);
+				} catch (error) {
+					process.emitWarning(`Could not close runner log ${logPath}: ${String(error)}`);
+				}
+			}
+		};
+	}
+};
+//#endregion
+export { LogFile as t };
+
+//# sourceMappingURL=logFile-KKPbkC-a.mjs.map

package/dist/logFile-KKPbkC-a.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logFile-KKPbkC-a.mjs","names":[],"sources":["../src/services/logFile/index.ts"],"sourcesContent":["import fs from 'node:fs';\n\nimport type { ILogFile, LogWriter } from '../../types/logFile';\nimport { getLogMaxBytes } from '../runnerConfig';\nimport type { IRunnerPaths } from '../runnerPaths/type';\n\nexport class LogFile implements ILogFile {\n  constructor(private readonly paths: IRunnerPaths) {}\n\n  open(id: string): LogWriter {\n    this.paths.ensureDirectories();\n    const logPath = this.paths.logPathFor(id);\n    const rotatedPath = this.paths.rotatedLogPathFor(id);\n    const maxBytes = getLogMaxBytes();\n\n    // A reused name starts clean: the previous runner's output is already\n    // available to whoever wanted it, and mixing two runs in one file makes\n    // both unreadable.\n    let handle = fs.openSync(logPath, 'w');\n    let written = 0;\n    let closed = false;\n\n    /**\n     * A run that keeps producing output for hours would otherwise grow one file\n     * without limit. Rotating keeps the newest window at the advertised path\n     * and the window before it alongside, so on-disk cost is bounded at roughly\n     * twice the ceiling, the path a result advertises stays valid, and the line\n     * counts a reader reports still describe the file it actually read.\n     */\n    const rotate = (): void => {\n      fs.closeSync(handle);\n      try {\n        fs.renameSync(logPath, rotatedPath);\n      } catch (error) {\n        // Holding the ceiling matters more than keeping the previous window,\n        // so the new file is opened either way and the loss is reported.\n        process.emitWarning(`Could not rotate runner log ${logPath}: ${String(error)}`);\n      }\n      handle = fs.openSync(logPath, 'w');\n      written = 0;\n    };\n\n    return {\n      path: logPath,\n      append(text: string): void {\n        const chunk = Buffer.from(text, 'utf8');\n        // An empty file always takes the chunk, so a single write larger than\n        // the ceiling is stored rather than rotated away into nothing.\n        if (written > 0 && written + chunk.byteLength > maxBytes) rotate();\n        fs.writeSync(handle, chunk);\n        written += chunk.byteLength;\n      },\n      size(): number {\n        return written;\n      },\n      close(): void {\n        // Closing twice is normal: a launch that fails closes the log before\n        // the exit handler does. Only a first close that fails is news.\n        if (closed) return;\n        closed = true;\n        try {\n          fs.closeSync(handle);\n        } catch (error) {\n          process.emitWarning(`Could not close runner log ${logPath}: ${String(error)}`);\n        }\n      },\n    };\n  }\n}\n"],"mappings":";;;AAMA,IAAa,UAAb,MAAyC;CACV;CAA7B,YAAY,OAAsC;EAArB,KAAA,QAAA;CAAsB;CAEnD,KAAK,IAAuB;EAC1B,KAAK,MAAM,kBAAkB;EAC7B,MAAM,UAAU,KAAK,MAAM,WAAW,EAAE;EACxC,MAAM,cAAc,KAAK,MAAM,kBAAkB,EAAE;EACnD,MAAM,WAAW,eAAe;EAKhC,IAAI,SAAS,GAAG,SAAS,SAAS,GAAG;EACrC,IAAI,UAAU;EACd,IAAI,SAAS;;;;;;;;EASb,MAAM,eAAqB;GACzB,GAAG,UAAU,MAAM;GACnB,IAAI;IACF,GAAG,WAAW,SAAS,WAAW;GACpC,SAAS,OAAO;IAGd,QAAQ,YAAY,+BAA+B,QAAQ,IAAI,OAAO,KAAK,GAAG;GAChF;GACA,SAAS,GAAG,SAAS,SAAS,GAAG;GACjC,UAAU;EACZ;EAEA,OAAO;GACL,MAAM;GACN,OAAO,MAAoB;IACzB,MAAM,QAAQ,OAAO,KAAK,MAAM,MAAM;IAGtC,IAAI,UAAU,KAAK,UAAU,MAAM,aAAa,UAAU,OAAO;IACjE,GAAG,UAAU,QAAQ,KAAK;IAC1B,WAAW,MAAM;GACnB;GACA,OAAe;IACb,OAAO;GACT;GACA,QAAc;IAGZ,IAAI,QAAQ;IACZ,SAAS;IACT,IAAI;KACF,GAAG,UAAU,MAAM;IACrB,SAAS,OAAO;KACd,QAAQ,YAAY,8BAA8B,QAAQ,IAAI,OAAO,KAAK,GAAG;IAC/E;GACF;EACF;CACF;AACF"}

package/dist/logFile.cjs

@@ -0,0 +1,3 @@
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const require_logFile = require("./logFile-CNvepZh0.cjs");
+exports.LogFile = require_logFile.LogFile;

package/dist/logFile.d.mts

@@ -0,0 +1,11 @@
+import { n as LogWriter, t as ILogFile } from "./logFile-C7oQ_v-g.mjs";
+import { t as IRunnerPaths } from "./type-BXM03qSw.mjs";
+//#region src/services/logFile/index.d.ts
+export declare class LogFile implements ILogFile {
+  private readonly paths;
+  constructor(paths: IRunnerPaths);
+  open(id: string): LogWriter;
+}
+//#endregion
+export type { ILogFile, LogWriter };
+//# sourceMappingURL=logFile.d.mts.map

package/dist/logFile.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logFile.d.mts","names":[],"sources":["../src/services/logFile/index.ts"],"mappings":";;;qBAMa,mBAAmB;mBACD;EAA7B,YAA6B,OAAO;EAEpC,KAAK,aAAa"}

package/dist/logFile.mjs

@@ -0,0 +1,2 @@
+import { t as LogFile } from "./logFile-KKPbkC-a.mjs";
+export { LogFile };

package/dist/logReader-B6J7L7Ua.cjs

@@ -0,0 +1,282 @@
+const require_rolldown_runtime = require("./rolldown-runtime-VH7oDXx4.cjs");
+const require_runnerConfig = require("./runnerConfig-D2tGq5ZM.cjs");
+const require_bashResult = require("./bashResult-DNgtahGR.cjs");
+let node_fs = require("node:fs");
+node_fs = require_rolldown_runtime.__toESM(node_fs, 1);
+let node_string_decoder = require("node:string_decoder");
+//#region src/constants/logReader.ts
+const READ_CHUNK_BYTES = 65536;
+//#endregion
+//#region src/services/logReader/index.ts
+var LogReader = class {
+	read(logPath, query = {}) {
+		let handle;
+		try {
+			handle = node_fs.default.openSync(logPath, "r");
+			return {
+				...scanLog(handle, query),
+				fileSize: node_fs.default.fstatSync(handle).size,
+				path: logPath,
+				exists: true
+			};
+		} catch (error) {
+			if (error.code !== "ENOENT") throw error;
+			return {
+				text: "",
+				lineCount: 0,
+				totalLines: 0,
+				fileSize: 0,
+				completeBytes: 0,
+				path: logPath,
+				exists: false
+			};
+		} finally {
+			if (handle !== void 0) node_fs.default.closeSync(handle);
+		}
+	}
+};
+function scanLog(handle, query) {
+	const limit = Math.max(0, Math.floor(query.lines ?? 200));
+	const needle = query.grep ? query.ignoreCase ? query.grep.toLowerCase() : query.grep : void 0;
+	const contextLines = Math.max(0, Math.floor(query.contextLines ?? 0));
+	const decoder = new node_string_decoder.StringDecoder("utf8");
+	const buffer = Buffer.alloc(READ_CHUNK_BYTES);
+	const before = [];
+	const output = [];
+	let pending = "";
+	let totalLines = 0;
+	let afterThrough = -1;
+	let lastEmitted = -1;
+	let lastByte;
+	let bytesSeen = 0;
+	let completeBytes = 0;
+	const retain = (line) => {
+		if (limit === 0) return;
+		output.push(line);
+		if (output.length > limit) output.shift();
+	};
+	const emit = (line) => {
+		if (line.index <= lastEmitted) return;
+		lastEmitted = line.index;
+		retain(line);
+	};
+	const consume = (text) => {
+		const line = {
+			index: totalLines,
+			text
+		};
+		totalLines += 1;
+		if (!needle) {
+			retain(line);
+			return;
+		}
+		if ((query.ignoreCase ? text.toLowerCase() : text).includes(needle)) {
+			for (const previous of before) emit(previous);
+			emit(line);
+			afterThrough = Math.max(afterThrough, line.index + contextLines);
+		} else if (line.index <= afterThrough) emit(line);
+		before.push(line);
+		if (before.length > contextLines) before.shift();
+	};
+	for (;;) {
+		const bytesRead = node_fs.default.readSync(handle, buffer, 0, buffer.byteLength, null);
+		if (bytesRead === 0) break;
+		lastByte = buffer[bytesRead - 1];
+		const lastNewline = buffer.subarray(0, bytesRead).lastIndexOf(10);
+		if (lastNewline >= 0) completeBytes = bytesSeen + lastNewline + 1;
+		bytesSeen += bytesRead;
+		pending += decoder.write(buffer.subarray(0, bytesRead));
+		let newline = pending.indexOf("\n");
+		while (newline >= 0) {
+			consume(pending.slice(0, newline));
+			pending = pending.slice(newline + 1);
+			newline = pending.indexOf("\n");
+		}
+	}
+	pending += decoder.end();
+	if (pending.length > 0) consume(pending);
+	const trailingNewline = lastByte === 10;
+	const scanned = {
+		text: `${output.map((line) => line.text).join("\n")}${!needle && trailingNewline && output.length > 0 ? "\n" : ""}`,
+		lineCount: output.length,
+		totalLines,
+		completeBytes
+	};
+	if (!needle) return scanned;
+	return {
+		...scanned,
+		lineNumbers: output.map((line) => line.index + 1)
+	};
+}
+/**
+* Grep with context, matching the `product-stack logs` semantics so the two
+* surfaces behave the same. Overlapping and adjacent context windows merge.
+*/
+function filterLogText(text, query) {
+	if (!query.grep) return text;
+	const lines = text.split("\n");
+	const needle = query.ignoreCase ? query.grep.toLowerCase() : query.grep;
+	const contextLines = Math.max(0, query.contextLines ?? 0);
+	const ranges = [];
+	lines.forEach((line, index) => {
+		if (!(query.ignoreCase ? line.toLowerCase() : line).includes(needle)) return;
+		ranges.push({
+			start: Math.max(0, index - contextLines),
+			end: Math.min(lines.length - 1, index + contextLines)
+		});
+	});
+	if (ranges.length === 0) return "";
+	const merged = [];
+	for (const range of ranges) {
+		const previous = merged.at(-1);
+		if (previous && range.start <= previous.end + 1) previous.end = Math.max(previous.end, range.end);
+		else merged.push({ ...range });
+	}
+	return merged.flatMap((range) => lines.slice(range.start, range.end + 1)).join("\n");
+}
+/** Reads a bounded head and tail plus exact metadata after the writer has flushed. */
+function summarizeLog(path, maxLines = require_runnerConfig.getResultMaxLines(), maxBytes = require_runnerConfig.getResultMaxBytes(), maxTokens = require_runnerConfig.getResultMaxTokens(), settings) {
+	let handle;
+	try {
+		const size = node_fs.default.statSync(path).size;
+		handle = node_fs.default.openSync(path, "r");
+		const readBuffer = Buffer.alloc(READ_CHUNK_BYTES);
+		const endLimit = Math.max(1, maxBytes + 1);
+		let headBuffer = Buffer.alloc(0);
+		let tailBuffer = Buffer.alloc(0);
+		let newlineCount = 0;
+		let lastByte;
+		const decoder = new node_string_decoder.StringDecoder("utf8");
+		const scanned = require_bashResult.createErrorScanner(require_runnerConfig.getErrorMaxEntries(settings), settings);
+		let pending = "";
+		for (;;) {
+			const bytesRead = node_fs.default.readSync(handle, readBuffer, 0, readBuffer.byteLength, null);
+			if (bytesRead === 0) break;
+			const chunk = readBuffer.subarray(0, bytesRead);
+			for (const byte of chunk) if (byte === 10) newlineCount += 1;
+			lastByte = chunk.at(-1);
+			if (headBuffer.byteLength < endLimit) headBuffer = Buffer.concat([headBuffer, chunk.subarray(0, endLimit - headBuffer.byteLength)]);
+			tailBuffer = appendBufferTail(tailBuffer, chunk, endLimit);
+			pending += decoder.write(chunk);
+			let newline = pending.indexOf("\n");
+			while (newline >= 0) {
+				scanned.push(pending.slice(0, newline));
+				pending = pending.slice(newline + 1);
+				newline = pending.indexOf("\n");
+			}
+		}
+		pending += decoder.end();
+		if (pending.length > 0) scanned.push(pending);
+		const lines = newlineCount + (size > 0 && lastByte !== 10 ? 1 : 0);
+		const excerpt = size <= tailBuffer.byteLength ? require_bashResult.boundExcerpt(utf8Tail(tailBuffer, tailBuffer.byteLength), maxLines, maxBytes, maxTokens, settings) : require_bashResult.composeExcerpt(headBuffer.toString("utf8"), utf8Tail(tailBuffer, tailBuffer.byteLength), lines, maxLines, maxBytes, scanned.entries(), maxTokens, settings);
+		return {
+			tail: excerpt.text,
+			bytes: size,
+			lines,
+			tailLines: excerpt.lines
+		};
+	} catch {
+		return {
+			tail: "",
+			bytes: 0,
+			lines: 0,
+			tailLines: 0
+		};
+	} finally {
+		if (handle !== void 0) node_fs.default.closeSync(handle);
+	}
+}
+/**
+* Keeps both ends of an oversized result and points at the file holding the rest.
+*
+* The notice states the file's real size and line count so the model does not
+* guess at offsets when it goes on to read the file, which is the failure this
+* whole policy exists to prevent.
+*/
+function truncateForResult(text, fullOutputPath, maxBytes = require_runnerConfig.getResultMaxBytes(), maxLines = require_runnerConfig.getResultMaxLines()) {
+	const excerpt = require_bashResult.boundExcerpt(text, maxLines, maxBytes);
+	if (!excerpt.truncated) return {
+		text,
+		truncated: false,
+		outputLines: excerpt.lines
+	};
+	return {
+		text: `${excerpt.text}\n${truncationNotice(excerpt, fullOutputPath, text)}`,
+		truncated: true,
+		outputLines: excerpt.lines
+	};
+}
+function truncationNotice(excerpt, fullOutputPath, text) {
+	const file = measureFile(fullOutputPath);
+	const totalLines = file?.lines ?? require_bashResult.countLines(text);
+	const fileSize = file?.bytes ?? Buffer.byteLength(text, "utf8");
+	return [
+		`[output truncated: showing ${excerpt.lines.toLocaleString("en-US")} of ${totalLines.toLocaleString("en-US")} lines,`,
+		`${excerpt.elidedLines.toLocaleString("en-US")} elided from the middle.`,
+		`Full output is at ${fullOutputPath} (${require_bashResult.formatSize(fileSize)}, ${totalLines.toLocaleString("en-US")} lines).`,
+		`Inspect it with doom-runner logs, or read the file with an offset near line ${totalLines.toLocaleString("en-US")}.]`
+	].join(" ");
+}
+/** Real size and line count of the file the notice points at. */
+function measureFile(path) {
+	let handle;
+	try {
+		const bytes = node_fs.default.statSync(path).size;
+		handle = node_fs.default.openSync(path, "r");
+		const buffer = Buffer.alloc(READ_CHUNK_BYTES);
+		let newlineCount = 0;
+		let lastByte;
+		for (;;) {
+			const bytesRead = node_fs.default.readSync(handle, buffer, 0, buffer.byteLength, null);
+			if (bytesRead === 0) break;
+			const chunk = buffer.subarray(0, bytesRead);
+			for (const byte of chunk) if (byte === 10) newlineCount += 1;
+			lastByte = chunk.at(-1);
+		}
+		return {
+			bytes,
+			lines: newlineCount + (bytes > 0 && lastByte !== 10 ? 1 : 0)
+		};
+	} catch {
+		return;
+	} finally {
+		if (handle !== void 0) node_fs.default.closeSync(handle);
+	}
+}
+function utf8Tail(encoded, maxBytes) {
+	let start = Math.max(0, encoded.byteLength - maxBytes);
+	while (start < encoded.byteLength && (encoded[start] & 192) === 128) start += 1;
+	return encoded.subarray(start).toString("utf8");
+}
+function appendBufferTail(current, chunk, limit) {
+	if (chunk.byteLength >= limit) return Buffer.from(chunk.subarray(chunk.byteLength - limit));
+	const combined = Buffer.concat([current, chunk]);
+	return combined.byteLength > limit ? Buffer.from(combined.subarray(combined.byteLength - limit)) : combined;
+}
+//#endregion
+Object.defineProperty(exports, "LogReader", {
+	enumerable: true,
+	get: function() {
+		return LogReader;
+	}
+});
+Object.defineProperty(exports, "filterLogText", {
+	enumerable: true,
+	get: function() {
+		return filterLogText;
+	}
+});
+Object.defineProperty(exports, "summarizeLog", {
+	enumerable: true,
+	get: function() {
+		return summarizeLog;
+	}
+});
+Object.defineProperty(exports, "truncateForResult", {
+	enumerable: true,
+	get: function() {
+		return truncateForResult;
+	}
+});
+
+//# sourceMappingURL=logReader-B6J7L7Ua.cjs.map

package/dist/logReader-B6J7L7Ua.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"logReader-B6J7L7Ua.cjs","names":["fs","StringDecoder","getResultMaxLines","getResultMaxBytes","getResultMaxTokens","createErrorScanner","getErrorMaxEntries","boundExcerpt","composeExcerpt","countLines","formatSize"],"sources":["../src/constants/logReader.ts","../src/services/logReader/index.ts"],"sourcesContent":["export const DEFAULT_LINES = 200;\nexport const READ_CHUNK_BYTES = 65_536;\n","import fs from 'node:fs';\nimport { StringDecoder } from 'node:string_decoder';\n\nimport { DEFAULT_LINES, READ_CHUNK_BYTES } from '../../constants/logReader';\nimport { type Excerpt, type LogSummary, type TruncatedOutput } from '../../types/bashResult';\nimport type { ILogReader, LogQuery, LogSlice } from '../../types/logReader';\nimport type { RunnerSettings } from '../../types/runnerSettings';\nimport { boundExcerpt, composeExcerpt, countLines, createErrorScanner, formatSize } from '../bashResult';\nimport { getErrorMaxEntries, getResultMaxBytes, getResultMaxLines, getResultMaxTokens } from '../runnerConfig';\n\ninterface IndexedLine {\n  readonly index: number;\n  readonly text: string;\n}\n\ninterface ScannedLog {\n  readonly text: string;\n  readonly lineCount: number;\n  readonly totalLines: number;\n  readonly completeBytes: number;\n  readonly lineNumbers?: number[];\n}\n\nexport class LogReader implements ILogReader {\n  read(logPath: string, query: LogQuery = {}): LogSlice {\n    let handle: number | undefined;\n    try {\n      handle = fs.openSync(logPath, 'r');\n      const scanned = scanLog(handle, query);\n      return {\n        ...scanned,\n        fileSize: fs.fstatSync(handle).size,\n        path: logPath,\n        exists: true,\n      };\n    } catch (error) {\n      if ((error as NodeJS.ErrnoException).code !== 'ENOENT') throw error;\n      return {\n        text: '',\n        lineCount: 0,\n        totalLines: 0,\n        fileSize: 0,\n        completeBytes: 0,\n        path: logPath,\n        exists: false,\n      };\n    } finally {\n      if (handle !== undefined) fs.closeSync(handle);\n    }\n  }\n}\n\nfunction scanLog(handle: number, query: LogQuery): ScannedLog {\n  const limit = Math.max(0, Math.floor(query.lines ?? DEFAULT_LINES));\n  const needle = query.grep ? (query.ignoreCase ? query.grep.toLowerCase() : query.grep) : undefined;\n  const contextLines = Math.max(0, Math.floor(query.contextLines ?? 0));\n  const decoder = new StringDecoder('utf8');\n  const buffer = Buffer.alloc(READ_CHUNK_BYTES);\n  const before: IndexedLine[] = [];\n  const output: IndexedLine[] = [];\n  let pending = '';\n  let totalLines = 0;\n  let afterThrough = -1;\n  let lastEmitted = -1;\n  let lastByte: number | undefined;\n  let bytesSeen = 0;\n  let completeBytes = 0;\n\n  const retain = (line: IndexedLine): void => {\n    if (limit === 0) return;\n    output.push(line);\n    if (output.length > limit) output.shift();\n  };\n  const emit = (line: IndexedLine): void => {\n    if (line.index <= lastEmitted) return;\n    lastEmitted = line.index;\n    retain(line);\n  };\n  const consume = (text: string): void => {\n    const line = { index: totalLines, text };\n    totalLines += 1;\n    if (!needle) {\n      retain(line);\n      return;\n    }\n\n    const haystack = query.ignoreCase ? text.toLowerCase() : text;\n    if (haystack.includes(needle)) {\n      for (const previous of before) emit(previous);\n      emit(line);\n      afterThrough = Math.max(afterThrough, line.index + contextLines);\n    } else if (line.index <= afterThrough) {\n      emit(line);\n    }\n    before.push(line);\n    if (before.length > contextLines) before.shift();\n  };\n\n  for (;;) {\n    const bytesRead = fs.readSync(handle, buffer, 0, buffer.byteLength, null);\n    if (bytesRead === 0) break;\n    lastByte = buffer[bytesRead - 1];\n    // A newline is a single byte in UTF-8 and never a continuation byte, so the\n    // last one in this chunk ends the last complete line seen so far.\n    const lastNewline = buffer.subarray(0, bytesRead).lastIndexOf(0x0a);\n    if (lastNewline >= 0) completeBytes = bytesSeen + lastNewline + 1;\n    bytesSeen += bytesRead;\n    pending += decoder.write(buffer.subarray(0, bytesRead));\n    let newline = pending.indexOf('\\n');\n    while (newline >= 0) {\n      consume(pending.slice(0, newline));\n      pending = pending.slice(newline + 1);\n      newline = pending.indexOf('\\n');\n    }\n  }\n  pending += decoder.end();\n  if (pending.length > 0) consume(pending);\n\n  const trailingNewline = lastByte === 0x0a;\n  const body = output.map((line) => line.text).join('\\n');\n  const text = `${body}${!needle && trailingNewline && output.length > 0 ? '\\n' : ''}`;\n  const scanned: ScannedLog = { text, lineCount: output.length, totalLines, completeBytes };\n  if (!needle) return scanned;\n  return { ...scanned, lineNumbers: output.map((line) => line.index + 1) };\n}\n\n/**\n * Grep with context, matching the `product-stack logs` semantics so the two\n * surfaces behave the same. Overlapping and adjacent context windows merge.\n */\nexport function filterLogText(text: string, query: Pick<LogQuery, 'grep' | 'ignoreCase' | 'contextLines'>): string {\n  if (!query.grep) return text;\n  const lines = text.split('\\n');\n  const needle = query.ignoreCase ? query.grep.toLowerCase() : query.grep;\n  const contextLines = Math.max(0, query.contextLines ?? 0);\n  const ranges: Array<{ start: number; end: number }> = [];\n\n  lines.forEach((line, index) => {\n    const haystack = query.ignoreCase ? line.toLowerCase() : line;\n    if (!haystack.includes(needle)) return;\n    ranges.push({\n      start: Math.max(0, index - contextLines),\n      end: Math.min(lines.length - 1, index + contextLines),\n    });\n  });\n\n  if (ranges.length === 0) return '';\n  const merged: Array<{ start: number; end: number }> = [];\n  for (const range of ranges) {\n    const previous = merged.at(-1);\n    if (previous && range.start <= previous.end + 1) {\n      previous.end = Math.max(previous.end, range.end);\n    } else {\n      merged.push({ ...range });\n    }\n  }\n  return merged.flatMap((range) => lines.slice(range.start, range.end + 1)).join('\\n');\n}\n\n/** Reads a bounded head and tail plus exact metadata after the writer has flushed. */\nexport function summarizeLog(\n  path: string,\n  maxLines = getResultMaxLines(),\n  maxBytes = getResultMaxBytes(),\n  maxTokens = getResultMaxTokens(),\n  settings?: RunnerSettings,\n): LogSummary {\n  let handle: number | undefined;\n  try {\n    const size = fs.statSync(path).size;\n    handle = fs.openSync(path, 'r');\n    const readBuffer = Buffer.alloc(READ_CHUNK_BYTES);\n    // Both ends are captured at the full budget; the line trim decides the split.\n    const endLimit = Math.max(1, maxBytes + 1);\n    let headBuffer: Buffer<ArrayBufferLike> = Buffer.alloc(0);\n    let tailBuffer: Buffer<ArrayBufferLike> = Buffer.alloc(0);\n    let newlineCount = 0;\n    let lastByte: number | undefined;\n    const decoder = new StringDecoder('utf8');\n    const scanned = createErrorScanner(getErrorMaxEntries(settings), settings);\n    let pending = '';\n    for (;;) {\n      const bytesRead = fs.readSync(handle, readBuffer, 0, readBuffer.byteLength, null);\n      if (bytesRead === 0) break;\n      const chunk = readBuffer.subarray(0, bytesRead);\n      for (const byte of chunk) if (byte === 0x0a) newlineCount += 1;\n      lastByte = chunk.at(-1);\n      if (headBuffer.byteLength < endLimit) {\n        headBuffer = Buffer.concat([headBuffer, chunk.subarray(0, endLimit - headBuffer.byteLength)]);\n      }\n      tailBuffer = appendBufferTail(tailBuffer, chunk, endLimit);\n      pending += decoder.write(chunk);\n      let newline = pending.indexOf('\\n');\n      while (newline >= 0) {\n        scanned.push(pending.slice(0, newline));\n        pending = pending.slice(newline + 1);\n        newline = pending.indexOf('\\n');\n      }\n    }\n    pending += decoder.end();\n    if (pending.length > 0) scanned.push(pending);\n    const lines = newlineCount + (size > 0 && lastByte !== 0x0a ? 1 : 0);\n    // The tail capture holds the whole file only while the file fits inside one\n    // buffer. Past that the start is already gone from it, so the two ends have\n    // to be composed instead.\n    const excerpt =\n      size <= tailBuffer.byteLength\n        ? boundExcerpt(utf8Tail(tailBuffer, tailBuffer.byteLength), maxLines, maxBytes, maxTokens, settings)\n        : composeExcerpt(\n            headBuffer.toString('utf8'),\n            utf8Tail(tailBuffer, tailBuffer.byteLength),\n            lines,\n            maxLines,\n            maxBytes,\n            scanned.entries(),\n            maxTokens,\n            settings,\n          );\n    return { tail: excerpt.text, bytes: size, lines, tailLines: excerpt.lines };\n  } catch {\n    return { tail: '', bytes: 0, lines: 0, tailLines: 0 };\n  } finally {\n    if (handle !== undefined) fs.closeSync(handle);\n  }\n}\n\n/**\n * Keeps both ends of an oversized result and points at the file holding the rest.\n *\n * The notice states the file's real size and line count so the model does not\n * guess at offsets when it goes on to read the file, which is the failure this\n * whole policy exists to prevent.\n */\nexport function truncateForResult(\n  text: string,\n  fullOutputPath: string,\n  maxBytes = getResultMaxBytes(),\n  maxLines = getResultMaxLines(),\n): TruncatedOutput {\n  const excerpt = boundExcerpt(text, maxLines, maxBytes);\n  if (!excerpt.truncated) return { text, truncated: false, outputLines: excerpt.lines };\n\n  return {\n    text: `${excerpt.text}\\n${truncationNotice(excerpt, fullOutputPath, text)}`,\n    truncated: true,\n    outputLines: excerpt.lines,\n  };\n}\n\nfunction truncationNotice(excerpt: Excerpt, fullOutputPath: string, text: string): string {\n  // Counted from the file, never from `text`. What the caller holds in memory\n  // is itself capped, so using it here would understate the file by orders of\n  // magnitude and send the reader looking past the end of a much longer file.\n  const file = measureFile(fullOutputPath);\n  const totalLines = file?.lines ?? countLines(text);\n  const fileSize = file?.bytes ?? Buffer.byteLength(text, 'utf8');\n\n  return [\n    `[output truncated: showing ${excerpt.lines.toLocaleString('en-US')} of ${totalLines.toLocaleString('en-US')} lines,`,\n    `${excerpt.elidedLines.toLocaleString('en-US')} elided from the middle.`,\n    `Full output is at ${fullOutputPath} (${formatSize(fileSize)}, ${totalLines.toLocaleString('en-US')} lines).`,\n    `Inspect it with doom-runner logs, or read the file with an offset near line ${totalLines.toLocaleString('en-US')}.]`,\n  ].join(' ');\n}\n\n/** Real size and line count of the file the notice points at. */\nfunction measureFile(path: string): { bytes: number; lines: number } | undefined {\n  let handle: number | undefined;\n  try {\n    const bytes = fs.statSync(path).size;\n    handle = fs.openSync(path, 'r');\n    const buffer = Buffer.alloc(READ_CHUNK_BYTES);\n    let newlineCount = 0;\n    let lastByte: number | undefined;\n    for (;;) {\n      const bytesRead = fs.readSync(handle, buffer, 0, buffer.byteLength, null);\n      if (bytesRead === 0) break;\n      const chunk = buffer.subarray(0, bytesRead);\n      for (const byte of chunk) if (byte === 0x0a) newlineCount += 1;\n      lastByte = chunk.at(-1);\n    }\n    return { bytes, lines: newlineCount + (bytes > 0 && lastByte !== 0x0a ? 1 : 0) };\n  } catch {\n    return undefined;\n  } finally {\n    if (handle !== undefined) fs.closeSync(handle);\n  }\n}\n\nfunction utf8Tail(encoded: Buffer<ArrayBufferLike>, maxBytes: number): string {\n  let start = Math.max(0, encoded.byteLength - maxBytes);\n  while (start < encoded.byteLength && (encoded[start]! & 0xc0) === 0x80) start += 1;\n  return encoded.subarray(start).toString('utf8');\n}\n\nfunction appendBufferTail(\n  current: Buffer<ArrayBufferLike>,\n  chunk: Buffer<ArrayBufferLike>,\n  limit: number,\n): Buffer<ArrayBufferLike> {\n  if (chunk.byteLength >= limit) return Buffer.from(chunk.subarray(chunk.byteLength - limit));\n  const combined = Buffer.concat([current, chunk]);\n  return combined.byteLength > limit ? Buffer.from(combined.subarray(combined.byteLength - limit)) : combined;\n}\n"],"mappings":"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"}

package/dist/logReader-MdW9ffvV.d.mts

@@ -0,0 +1,43 @@
+//#region src/types/logReader.d.ts
+interface LogQuery {
+  /** Trailing lines to return before filtering. Defaults to 200. */
+  lines?: number;
+  grep?: string;
+  ignoreCase?: boolean;
+  contextLines?: number;
+}
+interface LogSlice {
+  text: string;
+  /** Lines in the returned slice. */
+  lineCount: number;
+  /** Lines in the whole file, so a truncated view says what it left out. */
+  totalLines: number;
+  /** Size of the log file on disk, in bytes. */
+  fileSize: number;
+  /**
+   * Bytes through the end of the last complete line.
+   *
+   * A runner caught mid-line leaves the file ending without a newline. That
+   * partial line is still returned in `text`, because a finished run whose
+   * last line never got a newline would otherwise lose it. A follower starts
+   * from here instead of `fileSize` so the line arrives whole from the stream
+   * rather than split across the slice and the first appended chunk.
+   */
+  completeBytes: number;
+  path: string;
+  /** False when the runner has produced no log file yet. */
+  exists: boolean;
+  /**
+   * 1-based numbers of the returned lines, for a grep whose results are not
+   * contiguous. Absent for a plain tail, where the numbers run unbroken to
+   * `totalLines` and the reader can count them itself.
+   */
+  lineNumbers?: number[];
+}
+/** Scans complete logs with bounded memory, then returns a tail or grep context. */
+interface ILogReader {
+  read(logPath: string, query?: LogQuery): LogSlice;
+}
+//#endregion
+export { LogQuery as n, LogSlice as r, ILogReader as t };
+//# sourceMappingURL=logReader-MdW9ffvV.d.mts.map

package/dist/logReader-MdW9ffvV.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"logReader-MdW9ffvV.d.mts","names":[],"sources":["../src/types/logReader.ts"],"mappings":";UAAiB;;EAEf;EACA;EACA;EACA;;UAGe;EACf;;EAEA;;EAEA;;EAEA;;;;;;;;;;EAUA;EACA;;EAEA;;;;;;EAMA;;;UAIe;EACf,KAAK,iBAAiB,QAAQ,WAAW"}