diffing 0.2.0 → 0.2.1

package/dist/server-lock-DpCrvL-Z.mjs

@@ -0,0 +1,714 @@
+import { basename, join, relative, resolve } from "node:path";
+import { mkdirSync, readFileSync, rmSync, writeFileSync } from "node:fs";
+import { promisify } from "node:util";
+import { execFile, execFileSync } from "node:child_process";
+import { readFile } from "node:fs/promises";
+import { homedir } from "node:os";
+import { createHash } from "node:crypto";
+import { parseSync } from "editorconfig";
+//#region src/lib/path.ts
+function decodeAndNormalize(p) {
+	let decoded = p;
+	try {
+		decoded = decodeURIComponent(p);
+	} catch {}
+	return decoded.replace(/\\/g, "/");
+}
+function toSafeRelativePath(filePath, baseDir) {
+	const normalized = decodeAndNormalize(filePath);
+	if (normalized.includes("..") || normalized.includes("\0")) return null;
+	const resolved = resolve(baseDir, normalized);
+	const resolvedBase = resolve(baseDir);
+	if (!(resolved.startsWith(resolvedBase + "/") || resolved === resolvedBase)) return null;
+	return relative(resolvedBase, resolved);
+}
+function isSafePath(relativePath, baseDir) {
+	return toSafeRelativePath(relativePath, baseDir) !== null;
+}
+//#endregion
+//#region src/lib/git.ts
+const execFileAsync = promisify(execFile);
+function isBinaryFile(absolutePath) {
+	try {
+		const buffer = readFileSync(absolutePath);
+		const bytesToCheck = Math.min(buffer.length, 8192);
+		for (let i = 0; i < bytesToCheck; i++) if (buffer[i] === 0) return true;
+		return false;
+	} catch {
+		return true;
+	}
+}
+function getFileContent(filePath, version) {
+	const root = getRepoRoot();
+	const relPath = toSafeRelativePath(filePath, root);
+	if (!relPath) return null;
+	const resolved = resolve(root, relPath);
+	if (version === "new") try {
+		return readFileSync(resolved);
+	} catch {
+		return null;
+	}
+	try {
+		return execFileSync("git", ["show", `HEAD:${relPath}`], {
+			stdio: "pipe",
+			maxBuffer: 50 * 1024 * 1024
+		});
+	} catch {
+		return null;
+	}
+}
+let cachedRepoRoot = null;
+const editorConfigCache = /* @__PURE__ */ new Map();
+function isGitRepo() {
+	try {
+		execFileSync("git", ["rev-parse", "--is-inside-work-tree"], { stdio: "pipe" });
+		return true;
+	} catch {
+		return false;
+	}
+}
+function getRepoRoot() {
+	if (cachedRepoRoot !== null) return cachedRepoRoot;
+	cachedRepoRoot = execFileSync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" }).trim();
+	return cachedRepoRoot;
+}
+function getRepoName() {
+	return basename(getRepoRoot());
+}
+function getBranchName() {
+	try {
+		return execFileSync("git", [
+			"rev-parse",
+			"--abbrev-ref",
+			"HEAD"
+		], {
+			stdio: "pipe",
+			encoding: "utf-8"
+		}).trim();
+	} catch {
+		return "";
+	}
+}
+const DIFF_FLAGS = ["--no-ext-diff", "--no-color"];
+function getTabSizeForFiles(filePaths) {
+	const root = getRepoRoot();
+	const result = {};
+	for (const filePath of filePaths) try {
+		const config = parseSync(join(root, filePath), { cache: editorConfigCache });
+		const size = config.tab_width ?? (config.indent_size === "tab" ? void 0 : config.indent_size);
+		if (typeof size === "number") result[filePath] = size;
+	} catch {}
+	return result;
+}
+async function getRepoRootAsync() {
+	if (cachedRepoRoot !== null) return cachedRepoRoot;
+	try {
+		const { stdout } = await execFileAsync("git", ["rev-parse", "--show-toplevel"], { encoding: "utf-8" });
+		cachedRepoRoot = stdout.trim();
+		return cachedRepoRoot;
+	} catch {
+		return "";
+	}
+}
+async function getUntrackedFilePathsAsync() {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		const trimmed = stdout.trim();
+		return trimmed ? trimmed.split("\n") : [];
+	} catch {
+		return [];
+	}
+}
+async function getUntrackedFilesDiffAsync() {
+	const root = await getRepoRootAsync();
+	const filePaths = await getUntrackedFilePathsAsync();
+	if (filePaths.length === 0) return "";
+	const patches = [];
+	const fileDiffPromises = filePaths.map(async (file) => {
+		const absolutePath = join(root, file);
+		if (isBinaryFile(absolutePath)) return [
+			`diff --git a/${file} b/${file}`,
+			"new file mode 100644",
+			"index 0000000..0000001",
+			`Binary files /dev/null and b/${file} differ`
+		].join("\n");
+		else try {
+			const lines = (await readFile(absolutePath, "utf-8")).split("\n");
+			const diffLines = lines.map((l) => `+${l}`);
+			return [
+				`diff --git a/${file} b/${file}`,
+				"new file mode 100644",
+				"index 0000000..0000001",
+				"--- /dev/null",
+				`+++ b/${file}`,
+				`@@ -0,0 +1,${lines.length} @@`,
+				...diffLines
+			].join("\n");
+		} catch {
+			return "";
+		}
+	});
+	const results = await Promise.all(fileDiffPromises);
+	for (const r of results) if (r) patches.push(r);
+	return patches.length > 0 ? "\n" + patches.join("\n") : "";
+}
+async function getCustomGitDiffAsync(args) {
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"diff",
+			...DIFF_FLAGS,
+			...args
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		return stdout;
+	} catch {
+		return "";
+	}
+}
+async function getGitDiffAsync(options = {}) {
+	const unstagedPromise = execFileAsync("git", ["diff", ...DIFF_FLAGS], {
+		encoding: "utf-8",
+		maxBuffer: 50 * 1024 * 1024
+	}).then(({ stdout }) => stdout).catch(() => "");
+	const stagedPromise = options.staged ? execFileAsync("git", [
+		"diff",
+		...DIFF_FLAGS,
+		"--staged"
+	], {
+		encoding: "utf-8",
+		maxBuffer: 50 * 1024 * 1024
+	}).then(({ stdout }) => stdout).catch(() => "") : Promise.resolve("");
+	const untrackedPromise = options.untracked ? getUntrackedFilesDiffAsync() : Promise.resolve("");
+	const [unstaged, staged, untrackedPatch] = await Promise.all([
+		unstagedPromise,
+		stagedPromise,
+		untrackedPromise
+	]);
+	const parts = [];
+	if (unstaged) parts.push(unstaged);
+	if (staged) parts.push(staged);
+	if (untrackedPatch) parts.push(untrackedPatch);
+	return parts.join("\n");
+}
+/**
+* Lists every file the working tree knows about (tracked + untracked,
+* excluding standard-ignored paths). Used by the Phase D file viewer to
+* power a path picker.
+*/
+function listRepoFiles() {
+	try {
+		const tracked = execFileSync("git", ["ls-files"], {
+			encoding: "utf-8",
+			maxBuffer: 100 * 1024 * 1024
+		}).trim();
+		const untracked = execFileSync("git", [
+			"ls-files",
+			"--others",
+			"--exclude-standard"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 100 * 1024 * 1024
+		}).trim();
+		const set = /* @__PURE__ */ new Set();
+		for (const list of [tracked, untracked]) {
+			if (!list) continue;
+			for (const line of list.split("\n")) if (line) set.add(line);
+		}
+		return [...set].sort();
+	} catch {
+		return [];
+	}
+}
+/**
+* Reports whether the repo is currently in the middle of a merge and which
+* files have unresolved conflicts. Used by the Phase C merge-conflict UI to
+* decide when to render the @pierre/diffs UnresolvedFile component.
+*/
+function getMergeStatus() {
+	let root;
+	try {
+		root = getRepoRoot();
+	} catch {
+		return {
+			inMerge: false,
+			conflicts: []
+		};
+	}
+	const mergeHead = join(root, ".git", "MERGE_HEAD");
+	let inMerge = false;
+	try {
+		readFileSync(mergeHead);
+		inMerge = true;
+	} catch {
+		inMerge = false;
+	}
+	let conflicts = [];
+	try {
+		const out = execFileSync("git", [
+			"diff",
+			"--name-only",
+			"--diff-filter=U"
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		}).trim();
+		conflicts = out ? out.split("\n") : [];
+	} catch {
+		conflicts = [];
+	}
+	return {
+		inMerge: inMerge || conflicts.length > 0,
+		conflicts
+	};
+}
+function gitAddFile(filePath) {
+	execFileSync("git", [
+		"add",
+		"--",
+		filePath
+	], { stdio: "pipe" });
+}
+/**
+* Returns a unified diff for a single working-tree file (covers unstaged
+* and untracked changes). Used by the Phase E hunk-revert flow to derive
+* the exact patch text we need to `git apply --reverse`.
+*/
+function getFilePatch(filePath) {
+	try {
+		const unstaged = execFileSync("git", [
+			"diff",
+			...DIFF_FLAGS,
+			"--",
+			filePath
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		if (unstaged) return unstaged;
+	} catch {}
+	try {
+		const absolutePath = join(getRepoRoot(), filePath);
+		if (isBinaryFile(absolutePath)) return "";
+		const lines = readFileSync(absolutePath, "utf-8").split("\n");
+		return [
+			`diff --git a/${filePath} b/${filePath}`,
+			"new file mode 100644",
+			"index 0000000..0000001",
+			"--- /dev/null",
+			`+++ b/${filePath}`,
+			`@@ -0,0 +1,${lines.length} @@`,
+			...lines.map((l) => `+${l}`)
+		].join("\n");
+	} catch {
+		return "";
+	}
+}
+/**
+* Extracts the Nth hunk text from a single-file patch. Returns the lines
+* from `@@ ... @@` through the line before the next `@@` (or EOF).
+*/
+function extractHunk(patch, hunkIndex) {
+	const lines = patch.split("\n");
+	const hunkStarts = [];
+	for (let i = 0; i < lines.length; i++) if (lines[i].startsWith("@@ ")) hunkStarts.push(i);
+	if (hunkIndex < 0 || hunkIndex >= hunkStarts.length) return null;
+	const start = hunkStarts[hunkIndex];
+	const end = hunkIndex + 1 < hunkStarts.length ? hunkStarts[hunkIndex + 1] : lines.length;
+	return lines.slice(start, end).join("\n");
+}
+/** Header lines that the per-file patch needs in order for `git apply` to
+* recognize the target. Stops just before the first `@@` hunk header. */
+function extractPatchHeader(patch) {
+	const lines = patch.split("\n");
+	const out = [];
+	for (const line of lines) {
+		if (line.startsWith("@@ ")) break;
+		out.push(line);
+	}
+	return out.join("\n");
+}
+/**
+* Reverts a single hunk from the working tree by piping a minimal patch to
+* `git apply --reverse`. Throws if git rejects the apply (typically because
+* the file has shifted since the diff was rendered).
+*/
+function revertHunk(filePath, hunkIndex) {
+	const patch = getFilePatch(filePath);
+	if (!patch) throw new Error("No diff available for this file");
+	const header = extractPatchHeader(patch);
+	const hunk = extractHunk(patch, hunkIndex);
+	if (!hunk) throw new Error(`Hunk ${hunkIndex} not found`);
+	execFileSync("git", [
+		"apply",
+		"--reverse",
+		"-"
+	], {
+		input: `${header}\n${hunk}\n`,
+		stdio: [
+			"pipe",
+			"pipe",
+			"pipe"
+		]
+	});
+}
+function getProjectStorageDir(customRepoRoot) {
+	const root = customRepoRoot || getRepoRoot();
+	const hash = createHash("sha256").update(root).digest("hex").slice(0, 8);
+	const repoName = basename(root);
+	return join(homedir(), ".diffing", `${repoName}-${hash}`);
+}
+/**
+* Retrieves git blame for deleted lines and recent log history for the file,
+* providing context on what commit introduced the deleted code.
+*/
+function getHunkHistory(filePath, deletionStart, deletionCount, revision = "HEAD") {
+	if (!isSafePath(filePath, getRepoRoot())) throw new Error("Forbidden file path");
+	const blame = [];
+	if (deletionCount > 0) try {
+		const lines = execFileSync("git", [
+			"blame",
+			"--date=format:%Y-%m-%d",
+			"-L",
+			`${deletionStart},+${deletionCount}`,
+			revision,
+			"--",
+			filePath
+		], {
+			encoding: "utf-8",
+			maxBuffer: 10 * 1024 * 1024
+		}).split("\n");
+		const commitHashes = /* @__PURE__ */ new Set();
+		for (const line of lines) {
+			if (!line.trim()) continue;
+			const match = line.match(/^(\^?[0-9a-fA-F]+) \((.*?) (\d{4}-\d{2}-\d{2}) (\d+)\)(?: (.*))?$/);
+			if (match) {
+				const [_, commit, author, date, lineNum, content] = match;
+				const cleanCommit = commit.startsWith("^") ? commit.slice(1) : commit;
+				blame.push({
+					commit: cleanCommit,
+					author: author.trim(),
+					date,
+					line: parseInt(lineNum, 10),
+					content: content || "",
+					summary: ""
+				});
+				commitHashes.add(cleanCommit);
+			}
+		}
+		const commitSummaries = {};
+		for (const hash of commitHashes) try {
+			commitSummaries[hash] = execFileSync("git", [
+				"show",
+				"-s",
+				"--format=%s",
+				hash
+			], { encoding: "utf-8" }).trim();
+		} catch {
+			commitSummaries[hash] = "Unknown commit";
+		}
+		for (const entry of blame) entry.summary = commitSummaries[entry.commit] || "Unknown commit";
+	} catch (err) {
+		console.warn("Failed to get git blame for hunk history:", err.message);
+	}
+	const recentCommits = [];
+	try {
+		const logOut = execFileSync("git", [
+			"log",
+			"-n",
+			"5",
+			"--date=format:%Y-%m-%d",
+			"--format=%h|%an|%ad|%s",
+			"--",
+			filePath
+		], { encoding: "utf-8" });
+		for (const line of logOut.split("\n")) {
+			if (!line.trim()) continue;
+			const [hash, author, date, summary] = line.split("|");
+			if (hash && author && date && summary) recentCommits.push({
+				hash,
+				author: author.trim(),
+				date,
+				summary: summary.trim()
+			});
+		}
+	} catch (err) {
+		console.warn("Failed to get git log for hunk history:", err.message);
+	}
+	return {
+		blame,
+		recentCommits
+	};
+}
+//#endregion
+//#region src/lib/comment-format.ts
+/** Plain-language guidance the agent should act on, derived from the verdict. */
+function reviewDecisionSummary(decision) {
+	switch (decision) {
+		case "approved": return "The reviewer APPROVED these changes. Address any open comments below, then proceed — the overall direction is good.";
+		case "changes-requested": return "The reviewer REQUESTED EDITS. Address every open comment below and apply the requested changes before considering this review done.";
+		case "rejected": return "The reviewer REJECTED these changes. Do NOT keep building on this approach; reconsider it in light of the comments below before continuing.";
+	}
+}
+/**
+* Render review comments as the `<code-review-comments>` XML envelope used to
+* hand a review to an AI agent. Shared by the UI clipboard button
+* (`useComments.formatAllComments`), the server's `/api/review/send` handoff,
+* and the `diffing` CLI/MCP so every channel emits byte-identical output.
+*
+* A review may carry a headline `decision` (approve / request edits / reject)
+* and/or an overall comment, so the envelope is emitted even with zero inline
+* comments — letting a reviewer submit a verdict without annotating any line.
+*/
+function formatComments(comments, generalComment, decision) {
+	const trimmedGeneral = generalComment?.trim();
+	if (comments.length === 0 && !decision && !trimmedGeneral) return "";
+	const grouped = /* @__PURE__ */ new Map();
+	for (const comment of comments) {
+		const list = grouped.get(comment.filePath) ?? [];
+		list.push(comment);
+		grouped.set(comment.filePath, list);
+	}
+	const lines = [];
+	lines.push(decision ? `<code-review-comments decision="${decision}">` : "<code-review-comments>");
+	lines.push("  <instructions>");
+	lines.push("    You are an AI coding assistant. You are receiving a structured list of code review comments to address in the repository.");
+	lines.push("    For each file, review the inline comments and apply the changes requested.");
+	if (decision) {
+		lines.push("    - The \"decision\" attribute on the root element is the reviewer's headline verdict: \"approved\", \"changes-requested\", or \"rejected\".");
+		lines.push("    - <decision-summary> tells you, in plain language, what to do next based on that verdict.");
+	}
+	lines.push("    - Target lines are specified by the \"line\" attribute (e.g. line=\"10\" or line=\"10-15\").");
+	lines.push("    - \"side\" indicates whether the comment is on \"additions\" (added/modified lines) or \"deletions\" (deleted/old lines).");
+	lines.push("    - \"status\" indicates whether the comment is \"open\" or \"resolved\". Only address comments with status=\"open\".");
+	lines.push("    - The <code> block contains the specific code context at the reviewed lines, prefixed with \"+\" or \"-\".");
+	lines.push("    - The <body> tag contains the review feedback or request.");
+	lines.push("    - If developers have replied to the comment, their discussion is captured under the <replies> element.");
+	lines.push("    - The comment \"id\" attribute can be used to reference or update the comment via API if available.");
+	lines.push("");
+	lines.push("    HOW TO REPLY OR ASK FOR CLARIFICATION:");
+	lines.push("    If you need to ask for clarification, explain what you did, or reply to any comment:");
+	lines.push("");
+	lines.push("    Option A: Via the diffing CLI or MCP (Preferred — port-agnostic, no copy-paste)");
+	lines.push("      diffing reply <comment-id> --body \"Your response\" --model \"<your-model-name>\"");
+	lines.push("      diffing resolve <comment-id>");
+	lines.push("    (Or the equivalent MCP tools: reply_to_comment, resolve_comment.)");
+	lines.push("");
+	lines.push("    Option B: Via the local HTTP API (if you know the running port)");
+	lines.push("      POST http://localhost:<port>/api/comments/<comment-id>/replies");
+	lines.push("      Payload: { \"body\": \"Your response or clarification request here\", \"model\": \"<your-model-name>\" }");
+	lines.push("      PUT  http://localhost:<port>/api/comments/<comment-id>  Payload: { \"status\": \"resolved\" }");
+	lines.push("");
+	lines.push("    Option C: Via Text Response (Offline / Chat Copy-Paste)");
+	lines.push("    If you do not have local API access, output your comments/replies inside a structured XML block at the end of your response:");
+	lines.push("      <comment-replies>");
+	lines.push("        <reply to=\"<comment-id>\" model=\"<your-model-name>\"><![CDATA[Your reply or clarification request here]]></reply>");
+	lines.push("      </comment-replies>");
+	lines.push("  </instructions>");
+	if (decision) lines.push(`  <decision-summary><![CDATA[${reviewDecisionSummary(decision)}]]></decision-summary>`);
+	if (trimmedGeneral) {
+		lines.push("  <general-comment>");
+		lines.push(`    <![CDATA[${trimmedGeneral}]]>`);
+		lines.push("  </general-comment>");
+	}
+	for (const [filePath, fileComments] of grouped) {
+		lines.push(`  <file path="${filePath}">`);
+		for (const comment of fileComments) {
+			const lineAttr = comment.lineNumber === 0 ? "file" : comment.startLineNumber && comment.startLineNumber !== comment.lineNumber ? `${comment.startLineNumber}-${comment.lineNumber}` : `${comment.lineNumber}`;
+			const isoDate = new Date(comment.createdAt).toISOString();
+			lines.push(`    <comment id="${comment.id}" line="${lineAttr}" side="${comment.side}" status="${comment.status}" created-at="${isoDate}">`);
+			if (comment.lineNumber !== 0) {
+				const prefix = comment.side === "additions" ? "+" : "-";
+				const isMultiLine = comment.lineContent && comment.lineContent.includes("\n");
+				let codeVal = "";
+				if (isMultiLine) codeVal = `\n${comment.lineContent.split("\n").map((l) => `${prefix} ${l}`).join("\n")}\n`;
+				else codeVal = `${prefix} ${comment.lineContent}`;
+				lines.push(`      <code><![CDATA[${codeVal}]]></code>`);
+			}
+			lines.push(`      <body><![CDATA[${comment.body}]]></body>`);
+			if (comment.replies && comment.replies.length > 0) {
+				lines.push("      <replies>");
+				for (const reply of comment.replies) {
+					const replyIsoDate = new Date(reply.createdAt).toISOString();
+					const roleAttr = reply.role ? ` role="${reply.role}"` : " role=\"agent\"";
+					const modelAttr = reply.model ? ` model="${reply.model}"` : "";
+					lines.push(`        <reply id="${reply.id}" created-at="${replyIsoDate}"${roleAttr}${modelAttr}>`);
+					lines.push(`          <![CDATA[${reply.body}]]>`);
+					lines.push("        </reply>");
+				}
+				lines.push("      </replies>");
+			}
+			lines.push("    </comment>");
+		}
+		lines.push("  </file>");
+	}
+	lines.push("</code-review-comments>");
+	return lines.join("\n");
+}
+//#endregion
+//#region src/lib/plan-format.ts
+/**
+* Serialize a reviewed plan into the `<plan-review>` XML envelope handed back to
+* a waiting agent. The diff-review counterpart is {@link formatComments}; this
+* keeps the two handoffs structurally consistent so an agent learns one shape.
+*
+* Shared by the server's `/api/plan-review/await` handoff, the `diffing plan`
+* CLI, and the MCP server so every channel emits byte-identical output.
+*/
+function escapeAttr(value) {
+	return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
+/** Human-readable guidance the agent should act on, derived from the verdict. */
+function decisionSummary(decision) {
+	switch (decision) {
+		case "approved": return "The reviewer APPROVED this plan. Proceed with implementation exactly as described, taking any inline comments into account.";
+		case "rejected": return "The reviewer REJECTED this plan. Do NOT proceed. Reconsider the approach based on the comments; only continue once a new plan is approved.";
+		case "changes-requested": return "The reviewer REQUESTED CHANGES. Revise the plan to address every open comment below, then resubmit the updated plan for re-review (do not start implementation yet).";
+		default: return "This plan has not been decided yet. Wait for the reviewer to approve, reject, or request changes.";
+	}
+}
+/**
+* Resolve the line label for a plan comment: `plan` for whole-plan notes,
+* `12-15` for a multi-line selection, otherwise the single line number.
+*/
+function lineLabel(comment) {
+	if (comment.lineNumber === 0) return "plan";
+	if (comment.startLineNumber && comment.startLineNumber !== comment.lineNumber) return `${comment.startLineNumber}-${comment.lineNumber}`;
+	return `${comment.lineNumber}`;
+}
+function formatPlanReview(plan) {
+	const lines = [];
+	lines.push("<plan-review>");
+	lines.push("  <instructions>");
+	lines.push("    You are an AI coding assistant receiving a human review of a plan you submitted.");
+	lines.push("    - The \"decision\" attribute is the headline verdict: \"approved\", \"rejected\", \"changes-requested\", or \"pending\".");
+	lines.push("    - <decision-summary> tells you, in plain language, what to do next based on that verdict.");
+	lines.push("    - <decision-comment> is the reviewer's overall note (may be absent).");
+	lines.push("    - <plan-body> is the exact markdown of the plan being reviewed. Inline comments target lines within it.");
+	lines.push("    - Each <comment> targets a line (\"line=42\"), a range (\"line=12-15\"), or the whole plan (\"line=plan\").");
+	lines.push("      \"section\" names the nearest markdown heading for context. Only address comments with status=\"open\".");
+	lines.push("    - <context> contains the exact plan text the comment is anchored to.");
+	lines.push("");
+	lines.push("    HOW TO RESPOND:");
+	lines.push("    - If approved: proceed with the work.");
+	lines.push("    - If changes-requested: revise the plan and resubmit it for another review round.");
+	lines.push("    - If rejected: stop and rethink; do not implement.");
+	lines.push("    Prefer the diffing CLI or MCP (port-agnostic, no copy-paste):");
+	lines.push("      diffing plan reply <comment-id> --body \"...\" --model \"<your-model-name>\"");
+	lines.push("      diffing plan resolve <comment-id>");
+	lines.push("      diffing plan submit <revised-plan.md> --id <plan-id>   # resubmit a new version for re-review");
+	lines.push("    (Or the equivalent MCP tools: reply_to_plan_comment, resolve_plan_comment, submit_plan.)");
+	lines.push("  </instructions>");
+	const decidedAttr = plan.decidedAt ? ` decided-at="${new Date(plan.decidedAt).toISOString()}"` : "";
+	lines.push(`  <plan id="${escapeAttr(plan.id)}" title="${escapeAttr(plan.title)}" version="${plan.version}" decision="${plan.decision}"${decidedAttr}>`);
+	lines.push(`    <decision-summary><![CDATA[${decisionSummary(plan.decision)}]]></decision-summary>`);
+	const trimmedDecisionComment = plan.decisionComment?.trim();
+	if (trimmedDecisionComment) lines.push(`    <decision-comment><![CDATA[${trimmedDecisionComment}]]></decision-comment>`);
+	lines.push(`    <plan-body><![CDATA[${plan.body}]]></plan-body>`);
+	const comments = plan.comments ?? [];
+	if (comments.length > 0) {
+		lines.push("    <comments>");
+		for (const comment of comments) {
+			const sectionAttr = comment.sectionTitle ? ` section="${escapeAttr(comment.sectionTitle)}"` : "";
+			const isoDate = new Date(comment.createdAt).toISOString();
+			lines.push(`      <comment id="${escapeAttr(comment.id)}" line="${lineLabel(comment)}"${sectionAttr} status="${comment.status}" created-at="${isoDate}">`);
+			if (comment.lineNumber !== 0 && comment.lineContent) lines.push(`        <context><![CDATA[${comment.lineContent}]]></context>`);
+			lines.push(`        <body><![CDATA[${comment.body}]]></body>`);
+			if (comment.replies && comment.replies.length > 0) {
+				lines.push("        <replies>");
+				for (const reply of comment.replies) {
+					const replyIsoDate = new Date(reply.createdAt).toISOString();
+					const roleAttr = reply.role ? ` role="${reply.role}"` : " role=\"agent\"";
+					const modelAttr = reply.model ? ` model="${escapeAttr(reply.model)}"` : "";
+					lines.push(`          <reply id="${escapeAttr(reply.id)}" created-at="${replyIsoDate}"${roleAttr}${modelAttr}>`);
+					lines.push(`            <![CDATA[${reply.body}]]>`);
+					lines.push("          </reply>");
+				}
+				lines.push("        </replies>");
+			}
+			lines.push("      </comment>");
+		}
+		lines.push("    </comments>");
+	}
+	lines.push("  </plan>");
+	lines.push("</plan-review>");
+	return lines.join("\n");
+}
+/**
+* Find the nearest markdown ATX heading at or above a 1-based line, so a comment
+* can record which section of the plan it belongs to. Returns the heading text
+* without the leading `#`s, or undefined when the line precedes any heading.
+*/
+function sectionTitleForLine(body, lineNumber) {
+	if (lineNumber < 1) return void 0;
+	const lines = body.split("\n");
+	const end = Math.min(lineNumber, lines.length);
+	for (let i = end - 1; i >= 0; i--) {
+		const match = /^\s{0,3}(#{1,6})\s+(.*?)\s*#*\s*$/.exec(lines[i]);
+		if (match) return match[2].trim();
+	}
+}
+/**
+* Snapshot the plan text spanned by a 1-based, inclusive [start, end] line
+* range, used as the `lineContent` anchor when a comment is created without one
+* (e.g. posted by an agent over the API).
+*/
+function extractPlanLines(body, startLine, endLine) {
+	if (startLine < 1) return "";
+	const lines = body.split("\n");
+	const from = Math.max(1, startLine);
+	const to = Math.min(endLine, lines.length);
+	if (to < from) return "";
+	return lines.slice(from - 1, to).join("\n");
+}
+//#endregion
+//#region src/lib/server-lock.ts
+function lockPath(repoRoot) {
+	return join(getProjectStorageDir(repoRoot), "server.json");
+}
+function writeServerLock(lock) {
+	const path = lockPath(lock.repoRoot);
+	mkdirSync(join(path, ".."), { recursive: true });
+	writeFileSync(path, JSON.stringify(lock, null, 2), "utf-8");
+}
+function readServerLock(repoRoot) {
+	try {
+		const raw = readFileSync(lockPath(repoRoot), "utf-8");
+		const lock = JSON.parse(raw);
+		if (typeof lock.port !== "number" || typeof lock.pid !== "number") return null;
+		return lock;
+	} catch {
+		return null;
+	}
+}
+/**
+* True if the process named by the lock is still alive and the lock belongs to
+* this repo. `process.kill(pid, 0)` sends no signal — it just probes existence.
+*/
+function isLockAlive(lock) {
+	try {
+		process.kill(lock.pid, 0);
+	} catch {
+		return false;
+	}
+	try {
+		return lock.repoRoot === getRepoRoot();
+	} catch {
+		return true;
+	}
+}
+function removeServerLock(repoRoot) {
+	try {
+		rmSync(lockPath(repoRoot), { force: true });
+	} catch {}
+}
+//#endregion
+export { revertHunk as C, listRepoFiles as S, toSafeRelativePath as T, getRepoRoot as _, extractPlanLines as a, gitAddFile as b, formatComments as c, getFileContent as d, getGitDiffAsync as f, getRepoName as g, getProjectStorageDir as h, writeServerLock as i, getBranchName as l, getMergeStatus as m, readServerLock as n, formatPlanReview as o, getHunkHistory as p, removeServerLock as r, sectionTitleForLine as s, isLockAlive as t, getCustomGitDiffAsync as u, getTabSizeForFiles as v, isSafePath as w, isGitRepo as x, getUntrackedFilePathsAsync as y };