topchester-ai 0.66.0 → 0.68.0

package/dist/bin.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { t as runTopchesterCli } from "./cli-BS67FTk8.mjs";
+import { t as runTopchesterCli } from "./cli-CRhzHqMB.mjs";
 //#region src/bin.ts
 await runTopchesterCli();
 //#endregion

package/dist/{cli-BS67FTk8.mjs → cli-CRhzHqMB.mjs}

@@ -9,8 +9,9 @@ import { createOpenAICompatible } from "@ai-sdk/openai-compatible";
 import { generateText, stepCountIs, streamText, tool } from "ai";
 import { ZodError, z } from "zod";
 import { execFile, spawn } from "node:child_process";
-import { accessSync, constants, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
+import { accessSync, constants, createReadStream, existsSync, mkdirSync, readFileSync, statSync, writeFileSync } from "node:fs";
 import { createHash, randomUUID } from "node:crypto";
+import { TextDecoder as TextDecoder$1 } from "node:util";
 import { parseDocument } from "yaml";
 import { fileURLToPath } from "node:url";
 import pino from "pino";
@@ -420,6 +421,7 @@ function toAiSdkToolSet(definitions) {
 //#region src/agent/tools/process-runner.ts
 const DEFAULT_MAX_OUTPUT_BYTES$1 = 4e4;
 const DEFAULT_MAX_OUTPUT_LINES = 1e3;
+const TERMINAL_BENCH_MAX_OUTPUT_BYTES = 2e4;
 async function runProcess(options) {
 	const startedAt = Date.now();
 	const pathEnv = options.pathEnv ?? process.env.PATH ?? "";
@@ -785,6 +787,8 @@ async function runBashCommand(workspaceRoot, args, options = {}) {
 		pathEnv: options.pathEnv,
 		timeoutMs: args.timeout_ms,
 		abortSignal: options.abortSignal,
+		outputLimitBytes: options.benchmarkProfile === "terminal-bench" ? TERMINAL_BENCH_MAX_OUTPUT_BYTES : void 0,
+		outputLimitLines: options.benchmarkProfile === "terminal-bench" ? 500 : void 0,
 		env: { NO_COLOR: "1" },
 		missingExecutableLabel: "bash"
 	});
@@ -3584,7 +3588,10 @@ const inspectCommandTool = defineTool({
 	description: "Run a narrowly validated read-only command for repository orientation.",
 	prompt: "inspect_command: run a safe read-only discovery command inside the workspace for quick repo orientation; prefer read_file, list_files, grep, and find_file for exact file tasks, and do not use it for builds, tests, installs, network, shell scripts, edits, or user-requested specific commands such as node --version, which node, or pnpm --version. To use it, reply with only JSON: {\"tool\":\"inspect_command\",\"args\":{\"command\":\"pwd && rg --files docs/plans | head -20\",\"workdir\":\".\",\"timeout_ms\":10000}}",
 	argsSchema: inspectCommandArgsSchema,
-	execute: (context, args) => inspectWorkspaceCommand(context.workspaceRoot, args, { pathEnv: context.pathEnv })
+	execute: (context, args) => inspectWorkspaceCommand(context.workspaceRoot, args, {
+		pathEnv: context.pathEnv,
+		benchmarkProfile: context.benchmarkProfile
+	})
 });
 async function inspectWorkspaceCommand(workspaceRoot, args, options = {}) {
 	const startedAt = Date.now();
@@ -3596,7 +3603,8 @@ async function inspectWorkspaceCommand(workspaceRoot, args, options = {}) {
 	const result = await executePlan(decision.plan, {
 		cwd,
 		pathEnv: options.pathEnv ?? process.env.PATH ?? "",
-		deadlineAt
+		deadlineAt,
+		benchmarkProfile: options.benchmarkProfile
 	});
 	const durationMs = Date.now() - startedAt;
 	return {
@@ -3634,14 +3642,16 @@ async function executePlan(plan, context) {
 			timedOut: true,
 			truncated
 		};
+		const outputLimits = getOutputLimits(context.benchmarkProfile);
 		const result = await executePipeline(entry.pipeline, {
 			...context,
 			timeoutMs: remainingMs
 		});
-		stdout = appendBoundedOutput(stdout, result.stdout).output;
-		const nextStderr = appendBoundedOutput(stderr, result.stderr);
+		const nextStdout = appendBoundedOutput(stdout, result.stdout, outputLimits);
+		stdout = nextStdout.output;
+		const nextStderr = appendBoundedOutput(stderr, result.stderr, outputLimits);
 		stderr = nextStderr.output;
-		truncated = truncated || result.truncated || nextStderr.truncated;
+		truncated = truncated || result.truncated || nextStdout.truncated || nextStderr.truncated;
 		timedOut = timedOut || result.timedOut;
 		lastExitCode = result.exitCode;
 		if (result.missingExecutable || result.timedOut) return {
@@ -3681,7 +3691,8 @@ async function executePipeline(pipeline, context) {
 			timeoutMs: remainingMs
 		});
 		input = result.stdout;
-		const nextStderr = appendBoundedOutput(stderr, result.stderr);
+		const outputLimits = getOutputLimits(context.benchmarkProfile);
+		const nextStderr = appendBoundedOutput(stderr, result.stderr, outputLimits);
 		stderr = nextStderr.output;
 		exitCode = result.exitCode;
 		timedOut = timedOut || result.timedOut;
@@ -3718,6 +3729,8 @@ async function executeSimpleCommand(command, input, context) {
 		cwd: context.cwd,
 		pathEnv: context.pathEnv,
 		timeoutMs: context.timeoutMs,
+		outputLimitBytes: context.benchmarkProfile === "terminal-bench" ? TERMINAL_BENCH_MAX_OUTPUT_BYTES : void 0,
+		outputLimitLines: context.benchmarkProfile === "terminal-bench" ? 500 : void 0,
 		missingExecutableLabel: "inspect_command"
 	});
 	return {
@@ -3740,6 +3753,13 @@ function shouldExecuteEntry(entry, previousExitCode) {
 function getRemainingTimeoutMs(deadlineAt) {
 	return deadlineAt - Date.now();
 }
+function getOutputLimits(benchmarkProfile) {
+	if (benchmarkProfile !== "terminal-bench") return {};
+	return {
+		maxBytes: TERMINAL_BENCH_MAX_OUTPUT_BYTES,
+		maxLines: 500
+	};
+}
 function formatInspectCommandContent(result) {
 	const sections = [];
 	sections.push(result.stdout.trimEnd() || "(no output)");
@@ -4107,16 +4127,30 @@ const planTodoTool = defineTool({
 		};
 	}
 });
+//#endregion
+//#region src/agent/tools/read-file.ts
+const DEFAULT_MAX_UTF8_READ_BYTES = 512 * 1024;
+const TERMINAL_BENCH_MAX_UTF8_READ_BYTES = 64 * 1024;
+const SAMPLE_BYTES = 256;
 const readFileTool = defineTool({
 	name: "read_file",
 	description: "Read a UTF-8 file inside the workspace.",
-	prompt: "read_file: read a UTF-8 file inside the workspace. To use it, reply with only JSON: {\"tool\":\"read_file\",\"args\":{\"path\":\"package.json\"}}",
-	argsSchema: z.object({ path: z.string() }),
+	prompt: "read_file: read a UTF-8 file inside the workspace. For large files, use offset and limit to read a focused byte range. To use it, reply with only JSON: {\"tool\":\"read_file\",\"args\":{\"path\":\"package.json\"}}",
+	argsSchema: z.object({
+		path: z.string(),
+		offset: z.number().int().min(0).optional(),
+		limit: z.number().int().min(1).max(DEFAULT_MAX_UTF8_READ_BYTES).optional()
+	}),
 	parallelSafe: true,
 	mutatesWorkspace: false,
 	resourceKeys: (args) => [`file:${args.path}`],
 	execute: async (context, args) => {
-		const result = await readWorkspaceFile(context.workspaceRoot, args.path);
+		const result = await readWorkspaceFile(context.workspaceRoot, args.path, {
+			offset: args.offset,
+			limit: args.limit,
+			benchmarkProfile: context.benchmarkProfile,
+			cache: context.readFileCache
+		});
 		const projectInstructions = await resolveToolProjectInstructions(context, {
 			targetPath: args.path,
 			skipWhenTargetIsInstructionFile: true
@@ -4128,19 +4162,181 @@ const readFileTool = defineTool({
 		};
 	}
 });
-async function readWorkspaceFile(workspaceRoot, path) {
+async function readWorkspaceFile(workspaceRoot, path, options = {}) {
 	const resolvedWorkspace = resolve(workspaceRoot);
 	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
 	const relativePath = relative(resolvedWorkspace, resolvedPath);
+	const maxReadBytes = getReadFileMaxBytes(options.benchmarkProfile);
 	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`read_file can only read files inside the workspace: ${path}`);
-	const bytes = await readFile(resolvedPath);
+	const fileStat = await stat(resolvedPath);
+	if (!fileStat.isFile()) throw new Error(`read_file can only read regular files: ${path}`);
+	const offset = options.offset ?? 0;
+	const requestedLimit = options.limit;
+	const hasExplicitRange = options.offset !== void 0 || requestedLimit !== void 0;
+	if (offset > fileStat.size) throw new Error(`read_file offset ${offset} is beyond end of file ${relativePath || "."} (${fileStat.size} bytes).`);
+	if (!hasExplicitRange && fileStat.size > maxReadBytes) {
+		const [sample, hash] = await Promise.all([readFileSample(resolvedPath, SAMPLE_BYTES), hashFile$2(resolvedPath)]);
+		return {
+			tool: "read_file",
+			path: relativePath || ".",
+			content: formatSkippedReadSummary({
+				reason: "too_large",
+				relativePath: relativePath || ".",
+				bytes: fileStat.size,
+				maxReadBytes,
+				sample
+			}),
+			hash,
+			skipped: "too_large",
+			bytes: fileStat.size,
+			warning: `Skipped reading ${relativePath || "."}: file is ${fileStat.size} bytes, above the ${maxReadBytes} byte read_file limit.`
+		};
+	}
+	const hashPromise = hashFile$2(resolvedPath);
+	const bytes = hasExplicitRange ? await readFileRange(resolvedPath, offset, Math.min(requestedLimit ?? maxReadBytes, maxReadBytes)) : await readFile(resolvedPath);
+	const hash = await hashPromise;
+	const length = bytes.length;
+	const truncated = hasExplicitRange ? offset + length < fileStat.size : false;
+	const cacheKey = makeReadFileCacheKey(relativePath || ".", hash, fileStat.size, offset, length);
+	if (options.cache?.seen.has(cacheKey)) return {
+		tool: "read_file",
+		path: relativePath || ".",
+		content: formatDedupedReadSummary({
+			relativePath: relativePath || ".",
+			bytes: fileStat.size,
+			hash,
+			offset,
+			length
+		}),
+		hash,
+		bytes: fileStat.size,
+		offset,
+		length,
+		deduped: true,
+		truncated,
+		warning: `Skipped repeated read of unchanged ${relativePath || "."} bytes ${offset}-${offset + length}.`
+	};
+	if (looksBinary$1(bytes) || !isValidUtf8(bytes)) {
+		const sample = bytes.subarray(0, SAMPLE_BYTES);
+		return {
+			tool: "read_file",
+			path: relativePath || ".",
+			content: formatSkippedReadSummary({
+				reason: "binary",
+				relativePath: relativePath || ".",
+				bytes: fileStat.size,
+				maxReadBytes,
+				sample
+			}),
+			hash,
+			skipped: "binary",
+			bytes: fileStat.size,
+			warning: `Skipped reading ${relativePath || "."}: file appears to be binary or non-UTF-8.`
+		};
+	}
 	const content = bytes.toString("utf8");
-	return {
+	options.cache?.seen.set(cacheKey, {
+		hash,
+		bytes: fileStat.size,
+		offset,
+		length
+	});
+	const result = {
 		tool: "read_file",
 		path: relativePath || ".",
-		content,
-		hash: `sha256:${createHash("sha256").update(bytes).digest("hex")}`
+		content: formatReadFileContent({
+			content,
+			relativePath: relativePath || ".",
+			bytes: fileStat.size,
+			offset,
+			length,
+			truncated,
+			ranged: hasExplicitRange
+		}),
+		hash
 	};
+	if (hasExplicitRange) {
+		result.bytes = fileStat.size;
+		result.offset = offset;
+		result.length = length;
+		result.truncated = truncated;
+	}
+	return result;
+}
+function createReadFileCache() {
+	return { seen: /* @__PURE__ */ new Map() };
+}
+function looksBinary$1(bytes) {
+	return bytes.subarray(0, Math.min(bytes.length, SAMPLE_BYTES)).includes(0);
+}
+function isValidUtf8(bytes) {
+	try {
+		new TextDecoder$1("utf-8", { fatal: true }).decode(bytes);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function formatSkippedReadSummary(options) {
+	const reason = options.reason === "binary" ? "read_file did not return file contents because this file appears to be binary or non-UTF-8." : `read_file did not return file contents because this file is ${options.bytes} bytes, above the ${options.maxReadBytes} byte limit.`;
+	const sampleHex = options.sample.length > 0 ? options.sample.toString("hex").match(/.{1,2}/g)?.join(" ") : "";
+	return [
+		reason,
+		`path: ${options.relativePath}`,
+		`bytes: ${options.bytes}`,
+		sampleHex ? `first_${options.sample.length}_bytes_hex: ${sampleHex}` : "first_bytes_hex: <empty>",
+		"Use read_file with offset and limit for a focused byte range, or shell inspection tools such as `file`, `xxd`, `readelf`, `objdump`, `strings`, or a focused parser instead of reading the whole file into context."
+	].join("\n");
+}
+function formatReadFileContent(options) {
+	if (!options.ranged) return options.content;
+	return [`read_file range: ${options.relativePath} bytes ${options.offset}-${options.offset + options.length} of ${options.bytes}${options.truncated ? " (truncated)" : ""}`, options.content].join("\n");
+}
+function formatDedupedReadSummary(options) {
+	return [
+		"read_file did not return file contents because this exact unchanged file range was already shown in this session.",
+		`path: ${options.relativePath}`,
+		`bytes: ${options.bytes}`,
+		`hash: ${options.hash}`,
+		`range: ${options.offset}-${options.offset + options.length}`,
+		"Use a different offset/limit if you need another part of the file."
+	].join("\n");
+}
+async function readFileSample(path, maxBytes) {
+	const handle = await open(path, "r");
+	try {
+		const sample = Buffer.alloc(maxBytes);
+		const { bytesRead } = await handle.read(sample, 0, maxBytes, 0);
+		return sample.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+}
+async function readFileRange(path, offset, maxBytes) {
+	const handle = await open(path, "r");
+	try {
+		const sample = Buffer.alloc(maxBytes);
+		const { bytesRead } = await handle.read(sample, 0, maxBytes, offset);
+		return sample.subarray(0, bytesRead);
+	} finally {
+		await handle.close();
+	}
+}
+async function hashFile$2(path) {
+	const hash = createHash("sha256");
+	await new Promise((resolvePromise, reject) => {
+		const stream = createReadStream(path);
+		stream.on("data", (chunk) => hash.update(chunk));
+		stream.on("error", reject);
+		stream.on("end", resolvePromise);
+	});
+	return `sha256:${hash.digest("hex")}`;
+}
+function getReadFileMaxBytes(benchmarkProfile) {
+	return benchmarkProfile === "terminal-bench" ? TERMINAL_BENCH_MAX_UTF8_READ_BYTES : DEFAULT_MAX_UTF8_READ_BYTES;
+}
+function makeReadFileCacheKey(path, hash, bytes, offset, length) {
+	return `${path}\0${hash}\0${bytes}\0${offset}\0${length}`;
 }
 //#endregion
 //#region src/agent/tools/command-policy.ts
@@ -4583,18 +4779,29 @@ const runValidatorTool = defineTool({
 		timeout_ms: z.number().int().min(100).max(6e5).optional().default(12e4)
 	}),
 	requiresExclusiveWorkspace: true,
-	execute: async (context, args) => runValidatorCommand(context.workspaceRoot, args, context.pathEnv, context.abortSignal)
+	execute: async (context, args) => runValidatorCommand(context.workspaceRoot, args, {
+		pathEnv: context.pathEnv,
+		abortSignal: context.abortSignal,
+		benchmarkProfile: context.benchmarkProfile
+	})
 });
-async function runValidatorCommand(workspaceRoot, args, pathEnv, abortSignal) {
+async function runValidatorCommand(workspaceRoot, args, pathEnvOrOptions, legacyAbortSignal) {
+	const options = typeof pathEnvOrOptions === "string" ? {
+		pathEnv: pathEnvOrOptions,
+		abortSignal: legacyAbortSignal,
+		benchmarkProfile: void 0
+	} : pathEnvOrOptions ?? {};
 	const decision = await validateValidatorCommand(args, { workspaceRoot });
 	if (!decision.allowed) throw new Error(decision.reason);
 	const result = await runProcess({
 		executable: decision.plan.executable,
 		args: decision.plan.args,
 		cwd: decision.plan.cwd,
-		pathEnv,
+		pathEnv: options.pathEnv,
 		timeoutMs: args.timeout_ms,
-		abortSignal,
+		abortSignal: options.abortSignal,
+		outputLimitBytes: options.benchmarkProfile === "terminal-bench" ? TERMINAL_BENCH_MAX_OUTPUT_BYTES : void 0,
+		outputLimitLines: options.benchmarkProfile === "terminal-bench" ? 500 : void 0,
 		env: {
 			CI: "1",
 			NO_COLOR: "1"
@@ -12065,6 +12272,7 @@ async function executeToolCall(workspaceRoot, call, options = {}) {
 		projectInstructions: options.projectInstructions,
 		currentUserMessage: options.currentUserMessage,
 		benchmarkProfile: options.benchmarkProfile,
+		readFileCache: options.readFileCache,
 		eventSink: options.eventSink,
 		abortSignal: options.abortSignal,
 		toolCallId: options.toolCallId
@@ -13319,6 +13527,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 		const requireFinishTask = isFinishTaskRequiredByEnv() && isToolAllowed(permissions, "finish_task");
 		const projectInstructionToolState = { shownSourceKeys: /* @__PURE__ */ new Set() };
 		const persistedProjectInstructionKeys = /* @__PURE__ */ new Set();
+		const readFileCache = createReadFileCache();
 		try {
 			for (let toolCalls = 0; toolCalls <= maxToolCallsPerTurn; toolCalls += 1) {
 				const startedAt = Date.now();
@@ -13504,6 +13713,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 							projectInstructions: projectInstructionToolState,
 							currentUserMessage: message,
 							benchmarkProfile: options.benchmarkProfile,
+							readFileCache,
 							abortSignal,
 							toolCallId: entry.toolCallId,
 							toolCatalog,
@@ -13575,6 +13785,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 						projectInstructions: projectInstructionToolState,
 						currentUserMessage: message,
 						benchmarkProfile: options.benchmarkProfile,
+						readFileCache,
 						abortSignal,
 						toolCallId: entry.toolCallId,
 						toolCatalog
@@ -13653,6 +13864,7 @@ var TopchesterAgentRuntime = class TopchesterAgentRuntime {
 								projectInstructions: projectInstructionToolState,
 								currentUserMessage: message,
 								benchmarkProfile: options.benchmarkProfile,
+								readFileCache,
 								abortSignal,
 								toolCallId: toolCall.id,
 								toolCatalog,
@@ -14087,6 +14299,14 @@ function getToolCallDisplayDiff(result) {
 function readMaxToolCallsPerTurn() {
 	const raw = process.env[MAX_TOOL_CALLS_PER_TURN_ENV]?.trim();
 	if (!raw) return DEFAULT_MAX_TOOL_CALLS_PER_TURN;
+	if ([
+		"0",
+		"off",
+		"false",
+		"none",
+		"unlimited",
+		"disabled"
+	].includes(raw.toLowerCase())) return Number.POSITIVE_INFINITY;
 	const parsed = Number(raw);
 	if (!Number.isInteger(parsed) || parsed <= 0) return DEFAULT_MAX_TOOL_CALLS_PER_TURN;
 	return parsed;
@@ -16554,4 +16774,4 @@ function formatDryRunSyncStatus(status) {
 //#endregion
 export { runTopchesterCli as t };
 
-//# sourceMappingURL=cli-BS67FTk8.mjs.map
+//# sourceMappingURL=cli-CRhzHqMB.mjs.map