topchester-ai 0.66.0 → 0.67.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-DfgLjXLl.mjs";
 //#region src/bin.ts
 await runTopchesterCli();
 //#endregion

package/dist/{cli-BS67FTk8.mjs → cli-DfgLjXLl.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";
@@ -4107,6 +4108,10 @@ const planTodoTool = defineTool({
 		};
 	}
 });
+//#endregion
+//#region src/agent/tools/read-file.ts
+const MAX_UTF8_READ_BYTES = 512 * 1024;
+const SAMPLE_BYTES = 256;
 const readFileTool = defineTool({
 	name: "read_file",
 	description: "Read a UTF-8 file inside the workspace.",
@@ -4133,15 +4138,94 @@ async function readWorkspaceFile(workspaceRoot, path) {
 	const resolvedPath = isAbsolute(path) ? resolve(path) : resolve(resolvedWorkspace, path);
 	const relativePath = relative(resolvedWorkspace, resolvedPath);
 	if (relativePath.startsWith("..") || isAbsolute(relativePath)) throw new Error(`read_file can only read files inside the workspace: ${path}`);
+	const fileStat = await stat(resolvedPath);
+	if (!fileStat.isFile()) throw new Error(`read_file can only read regular files: ${path}`);
+	if (fileStat.size > MAX_UTF8_READ_BYTES) {
+		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,
+				sample
+			}),
+			hash,
+			skipped: "too_large",
+			bytes: fileStat.size,
+			warning: `Skipped reading ${relativePath || "."}: file is ${fileStat.size} bytes, above the ${MAX_UTF8_READ_BYTES} byte read_file limit.`
+		};
+	}
 	const bytes = await readFile(resolvedPath);
+	const hash = `sha256:${createHash("sha256").update(bytes).digest("hex")}`;
+	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,
+				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 {
 		tool: "read_file",
 		path: relativePath || ".",
 		content,
-		hash: `sha256:${createHash("sha256").update(bytes).digest("hex")}`
+		hash
 	};
 }
+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 ${MAX_UTF8_READ_BYTES} 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 shell inspection tools such as `file`, `xxd`, `readelf`, `objdump`, `strings`, or a focused parser instead of reading the whole file into context."
+	].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 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")}`;
+}
 //#endregion
 //#region src/agent/tools/command-policy.ts
 const PACKAGE_MANAGERS = new Set([
@@ -14087,6 +14171,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 +16646,4 @@ function formatDryRunSyncStatus(status) {
 //#endregion
 export { runTopchesterCli as t };
 
-//# sourceMappingURL=cli-BS67FTk8.mjs.map
+//# sourceMappingURL=cli-DfgLjXLl.mjs.map