blun-king-cli 9.1.38 → 9.1.39

package/blun.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-// BLUN_BUILD_INPUT_SHA256:e0036ad7d958609c5cf630953c5e1b6b6ec22fda3e8c09f26e7c97767acf846b
+// BLUN_BUILD_INPUT_SHA256:100000256c8742e28ac1b44fd85c258bacd68037bbbe180b9d79717e466d1d89
 import { fileURLToPath as __cjsShimFileURLToPath } from 'node:url';
 import { dirname as __cjsShimDirname } from 'node:path';
 const __filename = __cjsShimFileURLToPath(import.meta.url);
@@ -258794,7 +258794,7 @@ var init_read_media = __esmMin((() => {
 //#region ../../packages/agent-core/src/tools/builtin/file/write.md?raw
 var write_default;
 var init_write$1 = __esmMin((() => {
-	write_default = "Create, append to, or replace a file entirely.\n\n- Missing parent directories are created automatically (like `mkdir(parents=True, exist_ok=True)`).\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\n- Do not create unsolicited documentation files (`*.md` write-ups, `README`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\n- Read before overwriting an existing file.\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\n- Write outputs content literally, including supplied line endings: \\n stays LF, \\r\\n stays CRLF.\n- Source files may contain at most 500 lines. Split larger implementations into focused files; append cannot bypass the limit.\n- Set `single_file_override=true` only when the latest direct user message explicitly requires one single file. The accepted override is reported visibly.\n- For non-source content too large for one call, overwrite the first chunk, then append subsequent chunks. Never chunk Write to modify an existing file.\n- Runaway generated JavaScript/TypeScript identifiers are rejected before disk I/O. Regenerate only the affected section as a smaller focused chunk.\n";
+	write_default = "Create, append to, or replace a file entirely.\n\n- Missing parent directories are created automatically (like `mkdir(parents=True, exist_ok=True)`).\n- Mode defaults to overwrite; append adds content at EOF without adding a newline.\n- Write is NOT ALLOWED for incremental changes to existing files, including trivial, one-line, quick, or cosmetic edits. Use Edit instead.\n- Use Write only when the file does not exist, you intend a complete replacement, or the new contents have little continuity with the old contents.\n- Do not create unsolicited documentation files (`*.md` write-ups, `README`s, summaries) just because a task finished — write one only when the user asks for it, or when a task or project instruction requires it (e.g. the plan-mode plan file, created with Write when plan mode directs you to, or a changeset the repo mandates).\n- Read before overwriting an existing file.\n- Write ignores the Read/Edit line-number view. NEVER include line prefixes.\n- Write outputs content literally, including supplied line endings: \\n stays LF, \\r\\n stays CRLF.\n- Source files may contain at most 500 lines. Split larger implementations into focused files; append cannot bypass the limit.\n- Set `single_file_override=true` only when the latest direct user message explicitly requires one single file. The accepted override is reported visibly.\n- For any new or completely replaced file with content too large for one call, use `continuation`. Keep each chunk at or below the configured limit. The default is 2,048 UTF-8 bytes, a conservative safety margin for unstable model output rather than a measured hard model limit; operators can set `BLUN_WRITE_CONTINUATION_MAX_BYTES` from 512 through 16,384. End every chunk on a complete line with `\\n`. Set the exact final `expected_lines`; include `expected_sha256` when a source hash is available. Use overwrite and `start_line=1` for the first chunk, then use append for every later chunk and copy the exact `next_start_line` returned by the previous Write result; never continue from a planned boundary. Use consecutive part numbers. The target file remains unchanged until the final line-count and optional SHA-256 checks pass. To discard an unfinished sequence, restart with part 1, overwrite, `start_line=1`, and `reset=true`.\n- Never use continuation to modify an existing file incrementally. Use Edit for incremental changes.\n- Runaway generated JavaScript/TypeScript identifiers are rejected before disk I/O. Regenerate only the affected section as a smaller focused chunk.\n";
 }));
 //#endregion
 //#region ../../packages/agent-core/src/tools/builtin/file/generated-source-health.ts
@@ -258904,7 +258904,22 @@ var init_generated_source_health = __esmMin((() => {
 		".ts",
 		".tsx"
 	]);
-})), S_IFMT, S_IFDIR, WriteInputSchema, WriteTool;
+}));
+//#endregion
+//#region ../../packages/agent-core/src/tools/builtin/file/write.ts
+function resolveWriteContinuationChunkBytes(env = process.env) {
+	const raw = env[CONTINUATION_CHUNK_BYTES_ENV]?.trim();
+	if (raw === void 0 || raw === "") return DEFAULT_CONTINUATION_CHUNK_BYTES;
+	const parsed = Number(raw);
+	if (!Number.isSafeInteger(parsed) || parsed < MIN_CONTINUATION_CHUNK_BYTES || parsed > MAX_CONTINUATION_CHUNK_BYTES) throw new Error(`${CONTINUATION_CHUNK_BYTES_ENV} must be an integer between ${String(MIN_CONTINUATION_CHUNK_BYTES)} and ${String(MAX_CONTINUATION_CHUNK_BYTES)} bytes; received ${JSON.stringify(raw)}.`);
+	return parsed;
+}
+function countCompletedLines(content) {
+	let count = 0;
+	for (const character of content) if (character === "\n") count += 1;
+	return count;
+}
+var S_IFMT, S_IFDIR, DEFAULT_CONTINUATION_CHUNK_BYTES, MIN_CONTINUATION_CHUNK_BYTES, MAX_CONTINUATION_CHUNK_BYTES, CONTINUATION_CHUNK_BYTES_ENV, WriteContinuationSchema, WriteInputSchema, WriteTool;
 var init_write = __esmMin((() => {
 	init_dist$6();
 	init_zod$1();
@@ -258918,11 +258933,24 @@ var init_write = __esmMin((() => {
 	init_lsp_diagnostics();
 	S_IFMT = 61440;
 	S_IFDIR = 16384;
+	DEFAULT_CONTINUATION_CHUNK_BYTES = 2048;
+	MIN_CONTINUATION_CHUNK_BYTES = 512;
+	MAX_CONTINUATION_CHUNK_BYTES = 16384;
+	CONTINUATION_CHUNK_BYTES_ENV = "BLUN_WRITE_CONTINUATION_MAX_BYTES";
+	WriteContinuationSchema = object({
+		part: number$1().int().positive().describe("One-based chunk number. Start with 1 and increment by exactly one."),
+		start_line: number$1().int().positive().describe("One-based line where this chunk starts. Use 1 for part 1; for every later part, copy next_start_line from the preceding tool result instead of using a planned boundary."),
+		expected_lines: number$1().int().positive().describe("Exact completed-line count expected in the final file."),
+		final: boolean$1().describe("Set true only for the last chunk, when the complete file is present."),
+		expected_sha256: string().regex(/^[0-9a-f]{64}$/i).optional().describe("Optional SHA-256 of the complete expected file for byte-for-byte verification."),
+		reset: boolean$1().optional().describe("Set true only with part 1 and overwrite to discard an unfinished staged write.")
+	});
 	WriteInputSchema = object({
 		path: string().describe("Path to the file to create, append to, or completely overwrite. Relative paths resolve against the working directory; a path outside the working directory must be absolute. Missing parent directories are created automatically."),
 		content: string().describe("Raw full file content to write exactly as provided. This does not use the Read/Edit text view."),
 		mode: _enum(["overwrite", "append"]).optional().describe("Write mode. Defaults to overwrite. append adds content to the end exactly as provided and does not add a newline."),
-		single_file_override: boolean$1().optional().describe("Set true only when the latest direct user message explicitly requires one single source file. The tool verifies that request and reports the override visibly.")
+		single_file_override: boolean$1().optional().describe("Set true only when the latest direct user message explicitly requires one single source file. The tool verifies that request and reports the override visibly."),
+		continuation: WriteContinuationSchema.optional().describe("Safe long-write protocol. Split generated files into complete-line chunks within the configured limit (2,048 UTF-8 bytes by default; operator override BLUN_WRITE_CONTINUATION_MAX_BYTES). Part 1 uses overwrite and start_line=1; later parts use append and the exact next_start_line returned by the previous call. The target file is changed only after the final line-count and optional SHA-256 checks pass.")
 	});
 	object({ 
 	/** Number of UTF-8 bytes written to disk by this call. */
@@ -258932,14 +258960,17 @@ bytesWritten: number$1().int().nonnegative() });
 		workspace;
 		history;
 		lsp;
+		maxContinuationChunkBytes;
 		name = "Write";
 		description = write_default;
 		parameters = toInputJsonSchema(WriteInputSchema);
-		constructor(kaos, workspace, history, lsp) {
+		pendingContinuations = /* @__PURE__ */ new Map();
+		constructor(kaos, workspace, history, lsp, maxContinuationChunkBytes = resolveWriteContinuationChunkBytes()) {
 			this.kaos = kaos;
 			this.workspace = workspace;
 			this.history = history;
 			this.lsp = lsp;
+			this.maxContinuationChunkBytes = maxContinuationChunkBytes;
 		}
 		resolveExecution(args) {
 			const path = resolvePathAccessPath(args.path, {
@@ -258962,10 +258993,119 @@ bytesWritten: number$1().int().nonnegative() });
 					pathClass: this.kaos.pathClass(),
 					homeDir: this.kaos.gethome()
 				}),
-				execute: () => this.execution(args, path)
+				execute: (ctx) => this.execution(args, path, ctx)
 			};
 		}
-		async execution(args, safePath) {
+		async execution(args, safePath, ctx) {
+			if (args.continuation !== void 0) return this.continueWrite(args, safePath, ctx);
+			if (this.pendingContinuations.has(safePath)) return {
+				isError: true,
+				output: `Refused to write ${args.path}: a long-write continuation is active for this path. Resume it with the next numbered continuation part. No file was written.`
+			};
+			return this.writeContent(args, safePath);
+		}
+		async continueWrite(args, safePath, ctx) {
+			const continuation = args.continuation;
+			if (continuation === void 0) throw new Error("continuation is required");
+			const mode = args.mode ?? "overwrite";
+			const chunkBytes = Buffer.byteLength(args.content, "utf8");
+			if (chunkBytes > this.maxContinuationChunkBytes) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: chunks may contain at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} UTF-8 bytes (${String(chunkBytes)} received). No content was staged and no file was written.`
+			};
+			if (args.content.length === 0 || !args.content.endsWith("\n")) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: every chunk must end on a complete line with a newline. No content was staged and no file was written.`
+			};
+			if (continuation.reset === true && (continuation.part !== 1 || mode !== "overwrite")) return {
+				isError: true,
+				output: `Refused continuation reset for ${args.path}: reset requires part 1 with mode=overwrite. No content was staged and no file was written.`
+			};
+			if (continuation.reset === true) this.pendingContinuations.delete(safePath);
+			const current = this.pendingContinuations.get(safePath);
+			const expectedPart = current === void 0 ? 1 : current.chunks.length + 1;
+			if (continuation.part !== expectedPart) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected part ${String(expectedPart)}. No content was staged and no file was written.`
+			};
+			const expectedStartLine = (current?.completedLines ?? 0) + 1;
+			if (continuation.start_line !== expectedStartLine) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected start_line ${String(expectedStartLine)} from the actually staged content, received ${String(continuation.start_line)}. No content was staged and no file was written.`
+			};
+			if (continuation.part === 1 && mode !== "overwrite" || continuation.part > 1 && mode !== "append") return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: part 1 must use overwrite and later parts must use append. No content was staged and no file was written.`
+			};
+			if (current !== void 0 && continuation.expected_lines !== current.expectedLines) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected_lines changed from ${String(current.expectedLines)} to ${String(continuation.expected_lines)}. No content was staged and no file was written.`
+			};
+			const expectedSha256 = continuation.expected_sha256?.toLowerCase();
+			if (current?.expectedSha256 !== void 0 && expectedSha256 !== void 0 && expectedSha256 !== current.expectedSha256) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: expected_sha256 changed between parts. No content was staged and no file was written.`
+			};
+			const chunkLines = countCompletedLines(args.content);
+			const completedBefore = current?.completedLines ?? 0;
+			const completedLines = completedBefore + chunkLines;
+			if (completedLines > continuation.expected_lines) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: it would stage ${String(completedLines)} lines, exceeding the expected ${String(continuation.expected_lines)}. No content was staged and no file was written.`
+			};
+			if (!continuation.final && completedLines === continuation.expected_lines) return {
+				isError: true,
+				output: `Refused continuation part ${String(continuation.part)} for ${args.path}: all ${String(completedLines)} expected lines are present but final is false. Retry this part with final=true. No content was staged and no file was written.`
+			};
+			if (continuation.final && completedLines !== continuation.expected_lines) return {
+				isError: true,
+				output: `Refused final continuation part ${String(continuation.part)} for ${args.path}: expected ${String(continuation.expected_lines)} lines but would have ${String(completedLines)}. No content was staged and no file was written.`
+			};
+			const startLine = completedBefore + 1;
+			const boundary = `${String(startLine)}-${String(completedLines)}`;
+			const chunks = [...current?.chunks ?? [], args.content];
+			const boundaries = [...current?.boundaries ?? [], boundary];
+			const totalBytes = (current?.bytes ?? 0) + chunkBytes;
+			const stableExpectedSha256 = current?.expectedSha256 ?? expectedSha256;
+			const staged = {
+				expectedLines: continuation.expected_lines,
+				expectedSha256: stableExpectedSha256,
+				chunks,
+				boundaries,
+				completedLines,
+				bytes: totalBytes
+			};
+			const percent = Math.floor(completedLines / continuation.expected_lines * 100);
+			ctx?.onUpdate?.({
+				kind: "progress",
+				text: `Write continuation ${String(continuation.part)}: lines ${boundary}`,
+				percent
+			});
+			if (!continuation.final) {
+				this.pendingContinuations.set(safePath, staged);
+				return { output: `Write continuation part ${String(continuation.part)} staged lines ${boundary} of ${String(continuation.expected_lines)} (${String(percent)}%, ${String(chunkBytes)} bytes). Target unchanged. Continue with mode=append, part=${String(continuation.part + 1)}, next_start_line=${String(completedLines + 1)}.` };
+			}
+			const content = chunks.join("");
+			const actualSha256 = createHash("sha256").update(content).digest("hex");
+			if (stableExpectedSha256 !== void 0 && actualSha256 !== stableExpectedSha256) return {
+				isError: true,
+				output: `Refused final continuation part ${String(continuation.part)} for ${args.path}: SHA-256 mismatch (expected ${stableExpectedSha256}, got ${actualSha256}). No file was written; the first ${String(current?.completedLines ?? 0)} staged lines remain available for retry.`
+			};
+			const result = await this.writeContent({
+				...args,
+				content,
+				mode: "overwrite",
+				continuation: void 0
+			}, safePath, true);
+			if (result.isError === true) return result;
+			this.pendingContinuations.delete(safePath);
+			const writeOutput = typeof result.output === "string" ? result.output : "Write completed.";
+			return {
+				...result,
+				output: `Write continuation complete: ${String(completedLines)} lines, ${String(totalBytes)} bytes, SHA-256 ${actualSha256}. Chunk boundaries: ${boundaries.join(", ")}. ${writeOutput}`
+			};
+		}
+		async writeContent(args, safePath, allowLargeContent = false) {
 			const mode = args.mode ?? "overwrite";
 			const degenerateIdentifier = findDegenerateGeneratedIdentifier(safePath, args.content);
 			if (degenerateIdentifier !== null) return {
@@ -258991,6 +259131,11 @@ bytesWritten: number$1().int().nonnegative() });
 				isError: true,
 				output: lineLimit.error
 			};
+			const contentBytes = Buffer.byteLength(args.content, "utf8");
+			if (!allowLargeContent && contentBytes > this.maxContinuationChunkBytes) return {
+				isError: true,
+				output: `Refused to write ${args.path}: the content is ${String(contentBytes)} UTF-8 bytes. Long generated writes must use the continuation protocol with complete-line chunks of at most ${this.maxContinuationChunkBytes.toLocaleString("en-US")} bytes. No file was written.`
+			};
 			const parentError = await this.ensureParentDirectory(safePath);
 			if (parentError !== void 0) return {
 				isError: true,
@@ -370083,7 +370228,7 @@ var require_constants$2 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../../../node_modules/node-gyp-build/node-gyp-build.js
+//#region ../../../node_modules/node-gyp-build/node-gyp-build.js
 var require_node_gyp_build$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	var fs$3 = __require("fs");
 	var path$5 = __require("path");
@@ -370239,14 +370384,14 @@ var require_node_gyp_build$1 = /* @__PURE__ */ __commonJSMin(((exports, module)
 	load.compareTuples = compareTuples;
 }));
 //#endregion
-//#region ../../../../node_modules/node-gyp-build/index.js
+//#region ../../../node_modules/node-gyp-build/index.js
 var require_node_gyp_build = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const runtimeRequire = typeof __webpack_require__ === "function" ? __non_webpack_require__ : __require;
 	if (typeof runtimeRequire.addon === "function") module.exports = runtimeRequire.addon.bind(runtimeRequire);
 	else module.exports = require_node_gyp_build$1();
 }));
 //#endregion
-//#region ../../../../node_modules/bufferutil/fallback.js
+//#region ../../../node_modules/bufferutil/fallback.js
 var require_fallback$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* Masks a buffer using the given mask.
@@ -370278,7 +370423,7 @@ var require_fallback$1 = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	};
 }));
 //#endregion
-//#region ../../../../node_modules/bufferutil/index.js
+//#region ../../../node_modules/bufferutil/index.js
 var require_bufferutil = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	try {
 		module.exports = require_node_gyp_build()(__dirname);
@@ -370771,7 +370916,7 @@ var require_permessage_deflate = /* @__PURE__ */ __commonJSMin(((exports, module
 	}
 }));
 //#endregion
-//#region ../../../../node_modules/utf-8-validate/fallback.js
+//#region ../../../node_modules/utf-8-validate/fallback.js
 var require_fallback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	/**
 	* Checks if a given buffer contains only correct UTF-8.
@@ -370801,7 +370946,7 @@ var require_fallback = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	module.exports = isValidUTF8;
 }));
 //#endregion
-//#region ../../../../node_modules/utf-8-validate/index.js
+//#region ../../../node_modules/utf-8-validate/index.js
 var require_utf_8_validate = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	try {
 		module.exports = require_node_gyp_build()(__dirname);
@@ -419855,6 +420000,15 @@ function isBusy(host) {
 //#endregion
 //#region src/tui/commands/loop.ts
 const LOOP_ARGUMENT_HINT = "/loop [interval] [prompt]";
+const LOOP_CREATE_FILLERS = new Set([
+	"mit",
+	"alle",
+	"jede",
+	"jeden",
+	"every",
+	"each"
+]);
+const LOOP_INTERVAL_TOKEN = /^\d+(?:m|h|d)$/i;
 function parseLoopCommand(rawArgs) {
 	const args = rawArgs.trim();
 	if (args.length === 0 || args.toLowerCase() === "status") return { kind: "status" };
@@ -419865,10 +420019,11 @@ function parseLoopCommand(rawArgs) {
 		if (action === "resume") return { kind: "resume" };
 		if (action === "stop") return { kind: "stop" };
 	}
-	const startIndex = action === "start" ? 1 : 0;
+	let startIndex = action === "start" ? 1 : 0;
+	if (LOOP_CREATE_FILLERS.has(tokens[startIndex]?.toLowerCase() ?? "")) startIndex += 1;
 	const interval = tokens[startIndex];
 	const prompt = tokens.slice(startIndex + 1).join(" ").trim();
-	if (interval === void 0 || prompt.length === 0) return { kind: "error" };
+	if (interval === void 0 || !LOOP_INTERVAL_TOKEN.test(interval) || prompt.length === 0) return { kind: "error" };
 	return {
 		kind: "create",
 		interval,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blun-king-cli",
-  "version": "9.1.38",
+  "version": "9.1.39",
   "description": "BLUN CLI - your own AI agent with a Telegram channel. Get it done. With BLUN.",
   "license": "MIT",
   "bin": {