@possumtech/rummy 2.1.0 → 2.2.1

package/src/plugins/set/set.js

@@ -1,8 +1,8 @@
 import Entries from "../../agent/Entries.js";
 import { countTokens } from "../../agent/tokens.js";
+import Hedberg, { generatePatch } from "../../lib/hedberg/hedberg.js";
 import File from "../file/file.js";
-import Hedberg, { generatePatch } from "../hedberg/hedberg.js";
-import { storePatternResult } from "../helpers.js";
+import { SUMMARY_MAX_CHARS, storePatternResult } from "../helpers.js";
 import docs from "./setDoc.js";
 
 const VALID_VISIBILITY = { archived: 1, summarized: 1, visible: 1 };
@@ -13,6 +13,18 @@ function isSetProposal(path) {
 	return m?.[1] === "set";
 }
 
+// Cap the size of the current-body context surfaced on conflict. Big
+// enough for typical known:// entries (plans, notes) and a useful slice
+// of files; small enough that a 100k-line file doesn't blow the budget
+// on every conflict. The model can `<get>` the path for the full body.
+const CONFLICT_FEEDBACK_MAX_CHARS = 4000;
+function truncateForFeedback(body) {
+	if (body == null) return null;
+	if (body.length <= CONFLICT_FEEDBACK_MAX_CHARS) return body;
+	const head = body.slice(0, CONFLICT_FEEDBACK_MAX_CHARS);
+	return `${head}\n[truncated; ${body.length - CONFLICT_FEEDBACK_MAX_CHARS} more chars — <get> the path for full body]`;
+}
+
 // biome-ignore lint/suspicious/noShadowRestrictedNames: tool name is "set"
 export default class Set {
 	#core;
@@ -23,13 +35,15 @@ export default class Set {
 		core.on("handler", this.handler.bind(this));
 		core.on("visible", this.full.bind(this));
 		core.on("summarized", this.summary.bind(this));
-		core.on("proposal.prepare", this.#materializeRevisions.bind(this));
 		core.filter("instructions.toolDocs", async (docsMap) => {
 			docsMap.set = docs;
 			return docsMap;
 		});
 		core.filter("proposal.accepting", this.#vetoReadonly.bind(this));
 		core.filter("proposal.content", this.#preferExistingBody.bind(this));
+		// Materialization is shape-coupled (attrs.path + attrs.patched), not
+		// path-coupled. Any plugin emitting a proposal in that shape
+		// (set, cp, future tools) gets fs materialization for free.
 		core.on("proposal.accepted", this.#materializeFile.bind(this));
 	}
 
@@ -58,35 +72,30 @@ export default class Set {
 	}
 
 	async #materializeFile(ctx) {
-		if (!isSetProposal(ctx.path)) return;
 		const { attrs, runId, projectId, projectRoot, db, entries } = ctx;
-		if (!attrs?.path || !attrs?.merge) return;
+		// Shape gate, not path gate: any accepted proposal whose
+		// attributes describe a file materialization (target path +
+		// authoritative patched body) lands a fresh file body and writes
+		// to disk. Lets cp/set/future tools share one materializer.
+		if (!attrs?.path || attrs?.patched == null) return;
 
 		const existing = await entries.getBody(runId, attrs.path);
 		const isNewFile = existing === null;
-		const fileBody = isNewFile ? "" : existing;
-		const blocks = attrs.merge.split(/(?=<<<<<<< SEARCH)/);
-		let patched = fileBody;
-		for (const block of blocks) {
-			const m = block.match(
-				/<<<<<<< SEARCH\n?([\s\S]*?)\n?=======\n?([\s\S]*?)\n?>>>>>>> REPLACE/,
-			);
-			if (!m) continue;
-			if (m[1] === "") {
-				patched = m[2];
-			} else {
-				patched = patched.replace(m[1], m[2]);
-			}
-		}
+		const patched = attrs.patched;
 		const turn = (await db.get_run_by_id.get({ id: runId })).next_turn;
-		// Preserve current visibility; default would wipe an earlier <get>'s promotion.
+		// Visibility precedence: explicit attrs.visibility (mv/cp pass
+		// the model's tag attribute through) > current entry visibility
+		// (preserves an earlier <get>'s promotion) > scheme default.
 		const existingState = await entries.getState(runId, attrs.path);
+		const visibility = attrs.visibility
+			? attrs.visibility
+			: existingState?.visibility;
 		await entries.set({
 			runId,
 			turn,
 			path: attrs.path,
 			body: patched,
-			visibility: existingState?.visibility,
+			visibility,
 		});
 		if (projectRoot) {
 			const { writeFile, mkdir } = await import("node:fs/promises");
@@ -98,7 +107,7 @@ export default class Set {
 			await writeFile(targetPath, patched);
 		}
 		if (isNewFile && projectId) {
-			await File.setConstraint(db, projectId, attrs.path, "active");
+			await File.setConstraint(db, projectId, attrs.path, "add");
 		}
 	}
 
@@ -108,8 +117,27 @@ export default class Set {
 		const visibilityAttr = VALID_VISIBILITY[attrs.visibility]
 			? attrs.visibility
 			: null;
-		const rawSummary = typeof attrs.summary === "string" ? attrs.summary : null;
-		const summaryText = rawSummary ? rawSummary.slice(0, 80) : null;
+		const rawTags = typeof attrs.tags === "string" ? attrs.tags : null;
+		const tagsText = rawTags ? rawTags.slice(0, 80) : null;
+
+		// log:// is the immutable record of what happened. Visibility/metadata
+		// updates are fine (no body); rewriting the body destroys history.
+		// Models reach for this when the Demote example pattern primes
+		// `<set ... visibility="summarized">` and they tack on a body line —
+		// 405 here teaches the shape that's actually allowed.
+		if (attrs.path?.startsWith("log://") && entry.body) {
+			await store.set({
+				runId,
+				turn,
+				loopId,
+				path: entry.resultPath,
+				body: `log:// is immutable. To demote: <set path="${attrs.path}" visibility="summarized"/> (no body).`,
+				state: "failed",
+				outcome: "method_not_allowed",
+				attributes: { path: attrs.path },
+			});
+			return;
+		}
 
 		// Reject invalid visibility on body-less set; otherwise a typo silently wipes the body.
 		if (
@@ -123,7 +151,7 @@ export default class Set {
 				turn,
 				loopId,
 				path: entry.resultPath,
-				body: `Invalid visibility "${attrs.visibility}" on <set path="${attrs.path}"/>. Use visibility="visible|summarized|archived".`,
+				body: `Invalid visibility "${attrs.visibility}"`,
 				state: "failed",
 				outcome: "validation",
 				attributes: { path: attrs.path },
@@ -131,6 +159,48 @@ export default class Set {
 			return;
 		}
 
+		// Refuse parse-error edits (e.g., malformed sed). Without this the
+		// XmlParser would have either silently produced a corrupted edit
+		// or fallen through to body-replace, overwriting the target with
+		// the literal sed text. Surfacing the error gives the model a
+		// concrete signal it can adapt to.
+		if (attrs.error) {
+			await store.set({
+				runId,
+				turn,
+				loopId,
+				path: entry.resultPath,
+				body: attrs.error,
+				state: "failed",
+				outcome: "validation",
+				attributes: { path: attrs.path, error: attrs.error },
+			});
+			return;
+		}
+
+		// Manifest: universal preview gate. Fires before any operational
+		// branch so visibility flips, SEARCH/REPLACE edits, sed substitutions,
+		// pattern writes, and direct writes all support
+		// "list-without-doing" with the same flag.
+		if (attrs.manifest !== undefined && attrs.path) {
+			const matches = await store.getEntriesByPattern(
+				runId,
+				attrs.path,
+				attrs.body,
+			);
+			await storePatternResult(
+				store,
+				runId,
+				turn,
+				"set",
+				attrs.path,
+				attrs.body,
+				matches,
+				{ manifest: true, loopId, attributes: { path: attrs.path } },
+			);
+			return;
+		}
+
 		// Pure visibility/metadata change — no body content
 		if (!entry.body && visibilityAttr && attrs.path) {
 			const target = attrs.path;
@@ -158,12 +228,12 @@ export default class Set {
 					path: match.path,
 					visibility: visibilityAttr,
 				});
-				if (summaryText) {
+				if (tagsText) {
 					await store.set({
 						runId: runId,
 						path: match.path,
 						attributes: {
-							summary: summaryText,
+							tags: tagsText,
 						},
 					});
 				}
@@ -181,42 +251,68 @@ export default class Set {
 			return;
 		}
 
-		// Edit: sed patterns or SEARCH/REPLACE blocks
-		if (attrs.blocks || attrs.search != null) {
-			await this.#processEdit(rummy, entry, attrs);
-		} else if (attrs.manifest && attrs.path) {
-			// Manifest: list paths and token costs without performing the operation.
-			const matches = await store.getEntriesByPattern(
-				runId,
-				attrs.path,
-				attrs.body,
+		// Build the new content. Either from the marker-parsed operation
+		// list (NEW / PREPEND / APPEND / REPLACE / DELETE / SEARCH+REPLACE)
+		// or from the plain body (full-replace shorthand).
+		const target = attrs.path;
+		if (!target) return;
+		let newContent;
+		if (attrs.operations) {
+			const existing = await store.getBody(runId, target);
+			const requiresExisting = attrs.operations.some(
+				(op) => op.op === "search_replace" || op.op === "delete",
 			);
-			await storePatternResult(
-				store,
-				runId,
-				turn,
-				"set",
-				attrs.path,
-				attrs.body,
-				matches,
-				{ manifest: true, loopId },
+			if (requiresExisting && existing === null) {
+				await store.set({
+					runId,
+					turn,
+					loopId,
+					path: entry.resultPath,
+					body: `${target} not found in context`,
+					state: "failed",
+					outcome: "not_found",
+					attributes: {
+						path: target,
+						error: `${target} not found in context`,
+					},
+				});
+				return;
+			}
+			const result = Set.#applyOperations(
+				existing == null ? "" : existing,
+				attrs.operations,
 			);
-			return;
-		} else {
-			// Write content
-			const target = attrs.path;
-			if (!target) return;
+			if (result.error) {
+				await store.set({
+					runId,
+					turn,
+					loopId,
+					path: entry.resultPath,
+					body: existing == null ? "" : existing,
+					state: "failed",
+					outcome: "conflict",
+					attributes: {
+						path: target,
+						error: result.error,
+						attempted: result.attempted,
+						currentBody: truncateForFeedback(existing),
+					},
+				});
+				return;
+			}
+			newContent = result.body;
+		} else if (entry.body) {
+			newContent = entry.body;
+		}
 
+		if (newContent !== undefined) {
 			const scheme = Entries.scheme(target);
 			if (scheme === null) {
-				// File write — diff against existing content
+				// File write — emit a "proposed" entry; #materializeFile
+				// writes to disk on accept.
 				const existing = await store.getBody(runId, target);
-				const oldContent = existing === null ? "" : existing;
-				const newContent = entry.body;
+				const oldContent = existing == null ? "" : existing;
 				const udiff = generatePatch(target, oldContent, newContent);
-				const merge = oldContent
-					? `<<<<<<< SEARCH\n${oldContent}\n=======\n${newContent}\n>>>>>>> REPLACE`
-					: `<<<<<<< SEARCH\n=======\n${newContent}\n>>>>>>> REPLACE`;
 				const beforeTokens = oldContent ? countTokens(oldContent) : 0;
 				const afterTokens = countTokens(newContent);
 				await store.set({
@@ -228,15 +324,17 @@ export default class Set {
 					attributes: {
 						path: target,
 						patch: udiff,
-						merge,
+						patched: newContent,
 						beforeTokens,
 						afterTokens,
-						summary: summaryText,
+						tags: tagsText,
 					},
 					loopId,
 				});
 			} else if (attrs.filter || target.includes("*")) {
-				// Pattern update
+				// Pattern body-update: write the same body to every matching
+				// entry. Operations don't apply here (this is a bulk
+				// metadata-flavored body assignment).
 				const matches = await store.getEntriesByPattern(
 					runId,
 					target,
@@ -245,7 +343,7 @@ export default class Set {
 				await store.set({
 					runId: runId,
 					path: target,
-					body: entry.body,
+					body: newContent,
 					bodyFilter: attrs.filter === undefined ? null : attrs.filter,
 				});
 				await storePatternResult(
@@ -261,12 +359,8 @@ export default class Set {
 			} else {
 				// Direct scheme write; same diff-against-existing shape as file writes.
 				const existing = await store.getBody(runId, target);
-				const oldContent = existing === null ? "" : existing;
-				const newContent = entry.body;
+				const oldContent = existing == null ? "" : existing;
 				const udiff = generatePatch(target, oldContent, newContent);
-				const merge = oldContent
-					? `<<<<<<< SEARCH\n${oldContent}\n=======\n${newContent}\n>>>>>>> REPLACE`
-					: `<<<<<<< SEARCH\n=======\n${newContent}\n>>>>>>> REPLACE`;
 				const beforeTokens = oldContent ? countTokens(oldContent) : 0;
 				const afterTokens = countTokens(newContent);
 
@@ -276,9 +370,8 @@ export default class Set {
 					path: target,
 					body: newContent,
 					state: "resolved",
-					// Scheme writes default visible; the model wrote it.
 					visibility: visibilityAttr ? visibilityAttr : "visible",
-					attributes: summaryText ? { summary: summaryText } : null,
+					attributes: tagsText ? { tags: tagsText } : null,
 					loopId,
 				});
 				await store.set({
@@ -291,10 +384,9 @@ export default class Set {
 					attributes: {
 						path: target,
 						patch: udiff,
-						merge,
 						beforeTokens,
 						afterTokens,
-						summary: summaryText,
+						tags: tagsText,
 					},
 				});
 			}
@@ -311,11 +403,11 @@ export default class Set {
 					visibility: visibilityAttr,
 				});
 			}
-			if (summaryText) {
+			if (tagsText) {
 				await store.set({
 					runId: runId,
 					path: target,
-					attributes: { summary: summaryText },
+					attributes: { tags: tagsText },
 				});
 			}
 		}
@@ -324,270 +416,60 @@ export default class Set {
 	full(entry) {
 		const attrs = entry.attributes;
 		const target = attrs.path || entry.path;
-		if (attrs.error) return `# set ${target}\n${attrs.error}`;
+		if (attrs.error) {
+			const lines = [`# set ${target}`, attrs.error];
+			if (attrs.attempted) {
+				lines.push("", "--- attempted ---", attrs.attempted);
+			}
+			if (attrs.currentBody != null) {
+				lines.push("", `--- current body of ${target} ---`, attrs.currentBody);
+			}
+			return lines.join("\n");
+		}
 		const tokens =
 			attrs.beforeTokens != null
 				? ` ${attrs.beforeTokens}→${attrs.afterTokens} tokens`
 				: "";
-		if (!attrs.merge) return `# set ${target}${tokens}`;
-		return `# set ${target}${tokens}\n${attrs.merge}`;
+		if (!attrs.patch) return `# set ${target}${tokens}`;
+		return `# set ${target}${tokens}\n${attrs.patch}`;
 	}
 
 	summary(entry) {
 		if (!entry.body) return "";
-		// Preserve SEARCH/REPLACE blocks intact; truncation strips before/after the model needs.
-		if (/<<<<<<< SEARCH[\s\S]*>>>>>>> REPLACE/.test(entry.body)) {
-			return entry.body;
-		}
-		const flat = entry.body.replace(/\s+/g, " ").trim();
-		return flat.length <= 80 ? flat : `${flat.slice(0, 77)}...`;
-	}
-
-	async #processEdit(rummy, entry, attrs) {
-		const { entries: store, sequence: turn, runId, loopId } = rummy;
-		const target = attrs.path;
-		const matches = await store.getEntriesByPattern(runId, target, attrs.body);
-
-		if (matches.length === 0) {
-			await store.set({
-				runId,
-				turn,
-				path: entry.resultPath,
-				body: "",
-				state: "failed",
-				outcome: "not_found",
-				attributes: { path: target, error: `${target} not found in context` },
-				loopId,
-			});
-			return;
-		}
-
-		for (const match of matches) {
-			if (match.scheme === null) {
-				// Bare file: apply edit immediately so log carries before/after merge.
-				const canonicalPath = `set://${match.path}`;
-				const revision = Set.#buildRevision(attrs);
-				const existingAttrs = await rummy.getAttributes(canonicalPath);
-				const revisions = existingAttrs?.revisions
-					? existingAttrs.revisions
-					: [];
-				revisions.push(revision);
-				await store.set({
-					runId,
-					turn,
-					path: canonicalPath,
-					body: "",
-					state: "resolved",
-					attributes: { path: match.path, revisions },
-					loopId,
-				});
-				const { patch, searchText, replaceText, warning, error } =
-					Set.#applyRevision(match.body, attrs);
-				const merge =
-					searchText != null
-						? `<<<<<<< SEARCH\n${searchText}\n=======\n${replaceText}\n>>>>>>> REPLACE`
-						: null;
-				const beforeTokens = match.tokens;
-				const afterTokens = patch ? countTokens(patch) : beforeTokens;
-				const logState = error ? "failed" : "resolved";
-				await store.set({
-					runId,
-					turn,
-					path: entry.resultPath,
-					body: merge ?? (patch || `edit to ${match.path}`),
-					state: logState,
-					outcome: error ? "conflict" : null,
-					attributes: {
-						path: match.path,
-						merge,
-						beforeTokens,
-						afterTokens,
-						warning,
-						error,
-					},
-					loopId,
-				});
-				return;
-			}
-
-			const { patch, searchText, replaceText, warning, error } =
-				Set.#applyRevision(match.body, attrs);
-
-			const state = error ? "failed" : "resolved";
-			const outcome = error ? "conflict" : null;
-			const udiff = patch ? generatePatch(match.path, match.body, patch) : null;
-			const merge =
-				searchText != null
-					? `<<<<<<< SEARCH\n${searchText}\n=======\n${replaceText}\n>>>>>>> REPLACE`
-					: null;
-			const beforeTokens = match.tokens;
-			const afterTokens = patch ? countTokens(patch) : beforeTokens;
-
-			// Log entry at log://turn_N/set/<target> records the action.
-			await store.set({
-				runId,
-				turn,
-				path: entry.resultPath,
-				body: patch ?? match.body,
-				state,
-				outcome,
-				attributes: {
-					path: match.path,
-					patch: udiff,
-					merge,
-					beforeTokens,
-					afterTokens,
-					warning,
-					error,
-				},
-				loopId,
-			});
-
-			if (state === "resolved" && patch) {
-				await store.set({
-					runId,
-					turn,
-					path: match.path,
-					body: patch,
-					state: match.state,
-					loopId,
-				});
-			}
-		}
+		// Contract: summarized projections are ≤ SUMMARY_MAX_CHARS. The
+		// merge body for an edit can be many KB; truncate. The model
+		// reads the full body via promotion to visible if it needs the
+		// edit's exact content.
+		return entry.body.slice(0, SUMMARY_MAX_CHARS);
 	}
 
-	async #materializeRevisions({ rummy }) {
-		const { entries: store, sequence: turn, runId, loopId } = rummy;
-		const setEntries = await store.getEntriesByPattern(runId, "set://*");
-
-		for (const entry of setEntries) {
-			const attrs =
-				typeof entry.attributes === "string"
-					? JSON.parse(entry.attributes)
-					: entry.attributes;
-			if (!attrs?.revisions?.length) continue;
-
-			const entryPath = attrs.path;
-			const targetEntry = await store.getEntriesByPattern(runId, entryPath);
-			if (targetEntry.length === 0) continue;
-
-			const original = targetEntry[0].body;
-			let current = original;
-			const mergeBlocks = [];
-			let lastError = null;
-			let lastWarning = null;
-
-			for (const rev of attrs.revisions) {
-				if (!rev) continue;
-				const { patch, searchText, replaceText, warning, error } =
-					Set.#applyRevision(current, rev);
-
-				if (error) lastError = error;
-				else if (patch) current = patch;
-				if (warning) lastWarning = warning;
-
-				if (searchText != null) {
-					mergeBlocks.push(
-						`<<<<<<< SEARCH\n${searchText}\n=======\n${replaceText}\n>>>>>>> REPLACE`,
-					);
+	// Walk the parsed marker operation list against a starting body, returning
+	// the final body or the first error. SEARCH/REPLACE and DELETE go through
+	// Hedberg.replace (fuzzy whitespace match); NEW/REPLACE/PREPEND/APPEND
+	// are direct string operations.
+	static #applyOperations(currentBody, operations) {
+		let body = currentBody;
+		for (const op of operations) {
+			if (op.op === "new" || op.op === "replace") {
+				body = op.content;
+			} else if (op.op === "append") {
+				body = body + op.content;
+			} else if (op.op === "prepend") {
+				body = op.content + body;
+			} else if (op.op === "delete") {
+				const result = Hedberg.replace(body, op.content, "");
+				if (result.error) {
+					return { body, error: result.error, attempted: op.content };
 				}
+				body = result.patch;
+			} else if (op.op === "search_replace") {
+				const result = Hedberg.replace(body, op.search, op.replace);
+				if (result.error) {
+					return { body, error: result.error, attempted: op.search };
+				}
+				body = result.patch;
 			}
-
-			const state = lastError ? "failed" : "proposed";
-			const outcome = lastError ? "conflict" : null;
-			const udiff =
-				current !== original
-					? generatePatch(entryPath, original, current)
-					: null;
-			const merge = mergeBlocks.length > 0 ? mergeBlocks.join("\n") : null;
-			const beforeTokens = targetEntry[0].tokens;
-			const afterTokens = current ? countTokens(current) : beforeTokens;
-
-			await store.set({
-				runId,
-				turn,
-				path: entry.path,
-				body: current,
-				state,
-				outcome,
-				attributes: {
-					path: entryPath,
-					patch: udiff,
-					merge,
-					beforeTokens,
-					afterTokens,
-					warning: lastWarning,
-					error: lastError,
-				},
-				loopId,
-			});
-		}
-	}
-
-	// Missing `replace` = delete the match; normalize to empty string.
-	static #resolveReplace(attrs) {
-		return attrs.replace === undefined ? "" : attrs.replace;
-	}
-
-	static #buildRevision(attrs) {
-		if (attrs.search != null) {
-			return { search: attrs.search, replace: Set.#resolveReplace(attrs) };
-		}
-		if (attrs.blocks?.length > 0) {
-			return { blocks: attrs.blocks };
-		}
-		return null;
-	}
-
-	static #applyRevision(body, attrs) {
-		if (attrs.search != null) {
-			return Hedberg.replace(body, attrs.search, Set.#resolveReplace(attrs), {
-				sed: attrs.sed,
-				flags: attrs.flags,
-			});
-		}
-		if (attrs.blocks?.length > 0 && attrs.blocks[0].search === null) {
-			return {
-				patch: attrs.blocks[0].replace,
-				searchText: null,
-				replaceText: attrs.blocks[0].replace,
-				warning: null,
-				error: null,
-			};
-		}
-		if (body && attrs.blocks?.length > 0) {
-			if (attrs.blocks.length === 1) {
-				const block = attrs.blocks[0];
-				return Hedberg.replace(body, block.search, block.replace, {
-					sed: block.sed,
-					flags: block.flags,
-				});
-			}
-			let current = body;
-			let lastWarning = null;
-			for (const block of attrs.blocks) {
-				const result = Hedberg.replace(current, block.search, block.replace, {
-					sed: block.sed,
-					flags: block.flags,
-				});
-				if (result.error) return result;
-				if (result.warning) lastWarning = result.warning;
-				if (result.patch) current = result.patch;
-			}
-			return {
-				patch: current !== body ? current : null,
-				searchText: null,
-				replaceText: null,
-				warning: lastWarning,
-				error: null,
-			};
 		}
-		return {
-			patch: null,
-			searchText: null,
-			replaceText: null,
-			warning: null,
-			error: null,
-		};
+		return { body, error: null, attempted: null };
 	}
 }