diffing 0.2.0 → 0.3.0

package/dist/{server-lock-CAdqFSfl.mjs → server-lock-Dj9fG9md.mjs}

@@ -1,7 +1,7 @@
-import { basename, isAbsolute, join, resolve } from "node:path";
+import { execFile, execFileSync } from "node:child_process";
+import { basename, join, relative, resolve, sep } 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";
@@ -14,15 +14,23 @@ function decodeAndNormalize(p) {
 	} catch {}
 	return decoded.replace(/\\/g, "/");
 }
-function isSafePath(relativePath, baseDir) {
-	const normalized = decodeAndNormalize(relativePath);
-	if (normalized.includes("..") || normalized.includes("\0") || isAbsolute(normalized)) return false;
+function toSafeRelativePath(filePath, baseDir) {
+	const normalized = decodeAndNormalize(filePath);
+	if (normalized.includes("..") || normalized.includes("\0")) return null;
 	const resolved = resolve(baseDir, normalized);
-	return resolved.startsWith(resolve(baseDir) + "/") || resolved === resolve(baseDir);
+	const resolvedBase = resolve(baseDir);
+	if (!(resolved === resolvedBase || resolved.startsWith(resolvedBase + sep))) 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 splitLines(content) {
+	return content.split(/\r\n|\n|\r/);
+}
 function isBinaryFile(absolutePath) {
 	try {
 		const buffer = readFileSync(absolutePath);
@@ -35,15 +43,16 @@ function isBinaryFile(absolutePath) {
 }
 function getFileContent(filePath, version) {
 	const root = getRepoRoot();
-	if (!isSafePath(filePath, root)) return null;
-	const resolved = resolve(root, filePath);
+	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:${filePath}`], {
+		return execFileSync("git", ["show", `HEAD:${relPath}`], {
 			stdio: "pipe",
 			maxBuffer: 50 * 1024 * 1024
 		});
@@ -134,7 +143,7 @@ async function getUntrackedFilesDiffAsync() {
 			`Binary files /dev/null and b/${file} differ`
 		].join("\n");
 		else try {
-			const lines = (await readFile(absolutePath, "utf-8")).split("\n");
+			const lines = splitLines(await readFile(absolutePath, "utf-8"));
 			const diffLines = lines.map((l) => `+${l}`);
 			return [
 				`diff --git a/${file} b/${file}`,
@@ -292,7 +301,7 @@ function getFilePatch(filePath) {
 	try {
 		const absolutePath = join(getRepoRoot(), filePath);
 		if (isBinaryFile(absolutePath)) return "";
-		const lines = readFileSync(absolutePath, "utf-8").split("\n");
+		const lines = splitLines(readFileSync(absolutePath, "utf-8"));
 		return [
 			`diff --git a/${filePath} b/${filePath}`,
 			"new file mode 100644",
@@ -442,16 +451,266 @@ function getHunkHistory(filePath, deletionStart, deletionCount, revision = "HEAD
 		recentCommits
 	};
 }
+/**
+* Parse the output of `git log --pretty=raw -p` into `CommitInfo[]`.
+*
+* The `raw` format emits one record per commit:
+*
+*   commit <sha>
+*   tree <sha>
+*   parent <sha>            (zero or more; merges have ≥ 2)
+*   author <name> <email> <unix-time> <tz>
+*   committer <name> <email> <unix-time> <tz>
+*   gpgsig -----BEGIN ...   (optional; continuation lines start with a single space)
+*    <indented body>
+*
+*       <indented commit message — 4 spaces of indent>
+*
+*   diff --git a/... b/...  (the per-commit patch; may be empty)
+*   ...
+*
+* Records are separated by blank lines but the unambiguous boundary is the
+* next line beginning with `commit <40-hex>` at column 0.
+*/
+function parseGitShowRaw(raw) {
+	if (!raw) return [];
+	const out = [];
+	const lines = raw.split("\n");
+	const starts = [];
+	for (let i = 0; i < lines.length; i++) if (/^commit [0-9a-f]{40}\b/.test(lines[i])) starts.push(i);
+	if (starts.length === 0) return [];
+	for (let s = 0; s < starts.length; s++) {
+		const begin = starts[s];
+		const end = s + 1 < starts.length ? starts[s + 1] : lines.length;
+		const info = parseSingleCommitRaw(lines.slice(begin, end));
+		if (info) out.push(info);
+	}
+	return out;
+}
+function parseSingleCommitRaw(lines) {
+	const shaMatch = (lines[0] ?? "").match(/^commit ([0-9a-f]{40})/);
+	if (!shaMatch) return null;
+	const sha = shaMatch[1];
+	let i = 1;
+	const parents = [];
+	let authorName = "";
+	let authorEmail = "";
+	let authorDate = "";
+	let committerName = "";
+	let committerEmail = "";
+	let committerDate = "";
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line === "") break;
+		if (line.startsWith(" ")) {
+			i++;
+			continue;
+		}
+		const idx = line.indexOf(" ");
+		const key = idx === -1 ? line : line.slice(0, idx);
+		const value = idx === -1 ? "" : line.slice(idx + 1);
+		switch (key) {
+			case "tree": break;
+			case "parent":
+				if (value) parents.push(value);
+				break;
+			case "author": {
+				const ident = parseIdent(value);
+				authorName = ident.name;
+				authorEmail = ident.email;
+				authorDate = ident.date;
+				break;
+			}
+			case "committer": {
+				const ident = parseIdent(value);
+				committerName = ident.name;
+				committerEmail = ident.email;
+				committerDate = ident.date;
+				break;
+			}
+			default: break;
+		}
+		i++;
+	}
+	if (i < lines.length && lines[i] === "") i++;
+	const msgLines = [];
+	while (i < lines.length) {
+		const line = lines[i];
+		if (line.startsWith("    ")) {
+			msgLines.push(line.slice(4));
+			i++;
+			continue;
+		}
+		if (line === "") {
+			msgLines.push("");
+			i++;
+			continue;
+		}
+		break;
+	}
+	const { subject, body } = splitMessage(msgLines);
+	let patchStart = -1;
+	for (let j = i; j < lines.length; j++) {
+		const line = lines[j];
+		if (line.startsWith("diff --git ") || line.startsWith("Binary files ")) {
+			patchStart = j;
+			break;
+		}
+		if (line === "") continue;
+		break;
+	}
+	const patch = patchStart === -1 ? "" : lines.slice(patchStart).join("\n").replace(/\n+$/, "\n");
+	return {
+		sha,
+		shortSha: sha.slice(0, 7),
+		parents,
+		subject,
+		body,
+		authorName,
+		authorEmail,
+		authorDate,
+		committerName,
+		committerEmail,
+		committerDate,
+		patch
+	};
+}
+/**
+* Parse a `Name <email> <unix-seconds> <±HHMM>` ident line into structured
+* fields. The email is bracketed; the timestamp is split out and converted to
+* ISO 8601 for consumers.
+*/
+function parseIdent(value) {
+	const match = value.match(/^(.*?)\s+<([^>]*)>\s+(\d+)\s+([+-]\d{4})$/);
+	if (!match) return {
+		name: value,
+		email: "",
+		date: ""
+	};
+	const [, name, email, secs, tz] = match;
+	return {
+		name,
+		email,
+		date: unixToIso(Number(secs), tz)
+	};
+}
+function unixToIso(secs, tz) {
+	if (!Number.isFinite(secs)) return "";
+	const sign = tz.startsWith("-") ? -1 : 1;
+	const tzHours = Number(tz.slice(1, 3));
+	const tzMins = Number(tz.slice(3, 5));
+	const offsetMs = sign * (tzHours * 60 + tzMins) * 6e4;
+	const d = new Date(secs * 1e3 + offsetMs);
+	const pad = (n, w = 2) => String(n).padStart(w, "0");
+	return `${d.getUTCFullYear()}-${pad(d.getUTCMonth() + 1)}-${pad(d.getUTCDate())}T${pad(d.getUTCHours())}:${pad(d.getUTCMinutes())}:${pad(d.getUTCSeconds())}${tz.slice(0, 3)}:${tz.slice(3)}`;
+}
+function splitMessage(msgLines) {
+	if (msgLines.length === 0) return {
+		subject: "",
+		body: ""
+	};
+	let start = 0;
+	while (start < msgLines.length && msgLines[start] === "") start++;
+	let stop = msgLines.length;
+	while (stop > start && msgLines[stop - 1] === "") stop--;
+	if (start >= stop) return {
+		subject: "",
+		body: ""
+	};
+	const subject = msgLines[start];
+	let bodyStart = start + 1;
+	if (bodyStart < stop && msgLines[bodyStart] === "") bodyStart++;
+	return {
+		subject,
+		body: msgLines.slice(bodyStart, stop).join("\n")
+	};
+}
+async function getShowDiff(revspecs, pathspecs = []) {
+	if (revspecs.length === 0) return {
+		commits: [],
+		patch: "",
+		truncated: 0
+	};
+	let shaList;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"rev-list",
+			"--no-walk",
+			"--reverse",
+			...revspecs,
+			...pathspecs.length ? ["--", ...pathspecs] : []
+		], {
+			encoding: "utf-8",
+			maxBuffer: 50 * 1024 * 1024
+		});
+		shaList = stdout.split("\n").filter(Boolean);
+	} catch {
+		return {
+			commits: [],
+			patch: "",
+			truncated: 0
+		};
+	}
+	if (shaList.length === 0) return {
+		commits: [],
+		patch: "",
+		truncated: 0
+	};
+	const truncated = Math.max(0, shaList.length - 100);
+	const trimmed = truncated === 0 ? shaList : shaList.slice(0, 100);
+	let raw;
+	try {
+		const { stdout } = await execFileAsync("git", [
+			"log",
+			"--no-walk",
+			"--reverse",
+			"-p",
+			"--pretty=raw",
+			...DIFF_FLAGS,
+			...trimmed,
+			...pathspecs.length ? ["--", ...pathspecs] : []
+		], {
+			encoding: "utf-8",
+			maxBuffer: 200 * 1024 * 1024
+		});
+		raw = stdout;
+	} catch {
+		return {
+			commits: [],
+			patch: "",
+			truncated: 0
+		};
+	}
+	const commits = parseGitShowRaw(raw);
+	return {
+		commits,
+		patch: commits.map((c) => c.patch).filter(Boolean).join("\n"),
+		truncated
+	};
+}
 //#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) {
-	if (comments.length === 0) return "";
+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) ?? [];
@@ -459,10 +718,14 @@ function formatComments(comments, generalComment) {
 		grouped.set(comment.filePath, list);
 	}
 	const lines = [];
-	lines.push("<code-review-comments>");
+	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\".");
@@ -490,7 +753,7 @@ function formatComments(comments, generalComment) {
 	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>");
-	const trimmedGeneral = generalComment?.trim();
+	if (decision) lines.push(`  <decision-summary><![CDATA[${reviewDecisionSummary(decision)}]]></decision-summary>`);
 	if (trimmedGeneral) {
 		lines.push("  <general-comment>");
 		lines.push(`    <![CDATA[${trimmedGeneral}]]>`);
@@ -531,122 +794,6 @@ function formatComments(comments, generalComment) {
 	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");
@@ -688,4 +835,4 @@ function removeServerLock(repoRoot) {
 	} catch {}
 }
 //#endregion
-export { revertHunk as C, listRepoFiles as S, 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 };
+export { toSafeRelativePath as C, isSafePath as S, getUntrackedFilePathsAsync as _, formatComments as a, listRepoFiles as b, getFileContent as c, getMergeStatus as d, getProjectStorageDir as f, getTabSizeForFiles as g, getShowDiff as h, writeServerLock as i, getGitDiffAsync as l, getRepoRoot as m, readServerLock as n, getBranchName as o, getRepoName as p, removeServerLock as r, getCustomGitDiffAsync as s, isLockAlive as t, getHunkHistory as u, gitAddFile as v, revertHunk as x, isGitRepo as y };

package/dist/update-check-DAPFCqpF.mjs

@@ -0,0 +1,129 @@
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/lib/update-check.ts
+/**
+* Strips ANSI escape sequences from a string to compute its visible/display length.
+*/
+function stripAnsi(str) {
+	return str.replace(/\x1b\[[0-9;]*[a-zA-Z]/g, "");
+}
+/**
+* Compare two semver version strings to see if the latest version is newer.
+*/
+function isNewerVersion(current, latest) {
+	const clean = (v) => v.replace(/^v/, "");
+	const cParts = clean(current).split(".").map(Number);
+	const lParts = clean(latest).split(".").map(Number);
+	for (let i = 0; i < 3; i++) {
+		const cVal = cParts[i] ?? 0;
+		const lVal = lParts[i] ?? 0;
+		if (Number.isNaN(cVal) || Number.isNaN(lVal)) continue;
+		if (lVal > cVal) return true;
+		if (lVal < cVal) return false;
+	}
+	return false;
+}
+/**
+* Queries the npm registry asynchronously with a 1-second timeout.
+*/
+async function checkForUpdates(currentVersion) {
+	try {
+		const controller = new AbortController();
+		const id = setTimeout(() => controller.abort(), 1e3);
+		const res = await fetch("https://registry.npmjs.org/diffing/latest", { signal: controller.signal });
+		clearTimeout(id);
+		if (!res.ok) return null;
+		const data = await res.json();
+		if (!data.version) return null;
+		return {
+			hasUpdate: isNewerVersion(currentVersion, data.version),
+			latestVersion: data.version
+		};
+	} catch {
+		return null;
+	}
+}
+/**
+* Prints a beautifully styled console box letting the user know a new version is available.
+*/
+function printUpdateDisclaimer(current, latest) {
+	const borderCol = "\x1B[38;5;220m";
+	const bold = "\x1B[1m";
+	const reset = "\x1B[0m";
+	const boxWidth = 66;
+	const top = borderCol + "╭" + "─".repeat(boxWidth) + "╮\x1B[0m";
+	const bottom = borderCol + "╰" + "─".repeat(boxWidth) + "╯\x1B[0m";
+	const side = borderCol + "│\x1B[0m";
+	const l1 = `🚀  ${bold}Update available!${reset}  v${current} → \x1b[38;5;82mv${latest}${reset}`;
+	const l2 = `Run ${bold}diffing update${reset} to easily upgrade to the latest version.`;
+	const printRow = (content) => {
+		const displayLength = stripAnsi(content).length + (content.includes("🚀") ? 1 : 0);
+		const totalPadding = boxWidth - 4 - displayLength;
+		const pad = " ".repeat(Math.max(0, totalPadding));
+		console.log(`${side}  ${content}${pad}  ${side}`);
+	};
+	console.log();
+	console.log(top);
+	printRow("");
+	printRow(l1);
+	printRow(l2);
+	printRow("");
+	console.log(bottom);
+	console.log();
+}
+/**
+* Executes the update command process.
+*/
+async function runUpdateCommand() {
+	const __dirname = dirname(fileURLToPath(import.meta.url));
+	const pkgPath = existsSync(resolve(__dirname, "..", "package.json")) ? resolve(__dirname, "..", "package.json") : resolve(__dirname, "..", "..", "package.json");
+	const currentVersion = JSON.parse(readFileSync(pkgPath, "utf-8")).version;
+	console.log("Checking for updates...");
+	const updateInfo = await checkForUpdates(currentVersion);
+	if (!updateInfo || !updateInfo.hasUpdate) {
+		console.log(`\x1b[38;5;82mYou are already on the latest version of diffing (v${currentVersion})!\x1b[0m`);
+		return 0;
+	}
+	const latest = updateInfo.latestVersion;
+	console.log(`\n\x1b[38;5;75mUpdating diffing: v${currentVersion} → v${latest}...\x1b[0m\n`);
+	let cmd = "npm";
+	let args = [
+		"install",
+		"-g",
+		"diffing@latest"
+	];
+	try {
+		const { execSync } = await import("node:child_process");
+		execSync("pnpm --version", { stdio: "ignore" });
+		cmd = "pnpm";
+		args = [
+			"add",
+			"-g",
+			"diffing@latest"
+		];
+	} catch {}
+	console.log(`Running: ${cmd} ${args.join(" ")}\n`);
+	const exitCode = await new Promise((res) => {
+		const child = spawn(cmd, args, {
+			stdio: "inherit",
+			shell: true
+		});
+		child.on("close", (code) => {
+			res(code ?? 0);
+		});
+		child.on("error", (err) => {
+			console.error(`Failed to start update process: ${err.message}`);
+			res(1);
+		});
+	});
+	if (exitCode === 0) console.log(`\n\x1b[38;5;82mSuccessfully updated diffing to v${latest}!\x1b[0m\n`);
+	else {
+		console.error(`\n\x1b[38;5;196mFailed to update diffing. Please try running the command manually with sudo if required:\x1b[0m`);
+		console.error(`  sudo ${cmd} ${args.join(" ")}\n`);
+	}
+	return exitCode;
+}
+//#endregion
+export { checkForUpdates, printUpdateDisclaimer, runUpdateCommand };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "diffing",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "description": "local-first CLI for reviewing, navigating, and discussing git diffs with AI",
   "type": "module",
   "license": "MIT",
@@ -26,11 +26,17 @@
     "dist"
   ],
   "scripts": {
-    "build": "vite build && tsdown",
+    "build": "vite build && tsdown && pnpm run build:tui",
+    "build:ts": "vite build && tsdown",
+    "build:tui": "cargo build --release --manifest-path crates/diffing-tui/Cargo.toml",
+    "build:tui:debug": "cargo build --manifest-path crates/diffing-tui/Cargo.toml",
     "changeset": "changeset",
     "dev:client": "vite",
     "dev:server": "tsx src/cli.ts --no-open --port 3433",
-    "test": "vitest run",
+    "dev:tui": "cargo run --release --manifest-path crates/diffing-tui/Cargo.toml --",
+    "test": "vitest run && pnpm run test:tui",
+    "test:ts": "vitest run",
+    "test:tui": "cargo test --manifest-path crates/diffing-tui/Cargo.toml",
     "test:watch": "vitest",
     "prepublishOnly": "pnpm run build",
     "release": "pnpm run build && changeset publish",
@@ -48,10 +54,14 @@
     "@tanstack/react-store": "^0.11.0",
     "editorconfig": "^3.0.2",
     "get-port": "^7.2.0",
-    "highlight.js": "^11.11.1",
     "hono": "^4.7.6",
-    "marked": "^18.0.4",
+    "mermaid": "^11.15.0",
     "open": "^11.0.0",
+    "react-markdown": "^10.1.0",
+    "rehype-highlight": "^7.0.2",
+    "rehype-sanitize": "^6.0.0",
+    "remark-breaks": "^4.0.0",
+    "remark-gfm": "^4.0.1",
     "web-haptics": "0.0.6",
     "zod": "^4.4.3"
   },