diffing 0.6.0 → 0.7.0

package/dist/comment-format-DG_PAehC.mjs

@@ -0,0 +1,117 @@
+//#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.";
+		case "comment-only": return "The reviewer chose COMMENT-ONLY mode. You MUST NOT edit any files. Only reply to the comments below — answer questions, provide clarification, or discuss. The general comment (if any) is your prompt for the chat.";
+	}
+}
+/**
+* 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 / comment-only)
+* 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, mode) {
+	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 sortedFilePaths = [...grouped.keys()].sort((a, b) => a.localeCompare(b));
+	const modeAttr = mode && mode !== "standard" ? ` mode="${mode}"` : "";
+	const lines = [];
+	lines.push(decision ? `<code-review-comments decision="${decision}"${modeAttr}>` : `<code-review-comments${modeAttr}>`);
+	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.");
+	if (mode === "comment-only") lines.push("    ⚠️ COMMENT-ONLY MODE: You MUST NOT edit any files. Your only task is to reply to the comments below — answer questions, provide clarification, or discuss. The general comment (if present) is your prompt for this chat.");
+	else 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\", \"rejected\", or \"comment-only\".");
+		lines.push("    - <decision-summary> tells you, in plain language, what to do next based on that verdict.");
+	}
+	if (mode) lines.push(`    - The "mode" attribute on the root element controls your behavior: "standard" (apply edits) or "comment-only" (reply only, no edits).`);
+	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("    - Optional severity=\"blocking|nit|question|praise\":");
+	lines.push("        blocking = must fix before considering the review done;");
+	lines.push("        nit = optional polish; question = needs an answer; praise = positive (no change required).");
+	lines.push("      Omit severity (or severity=\"none\") means untriaged — treat as a normal request.");
+	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 of sortedFilePaths) {
+		const fileComments = grouped.get(filePath);
+		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();
+			const severityAttr = comment.severity && comment.severity !== "none" ? ` severity="${comment.severity}"` : "";
+			lines.push(`    <comment id="${comment.id}" line="${lineAttr}" side="${comment.side}" status="${comment.status}"${severityAttr} 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
+export { reviewDecisionSummary as n, formatComments as t };

package/dist/completions-ZSKYvW06.mjs

@@ -0,0 +1,126 @@
+//#region src/lib/completions.ts
+/**
+* Shell completion scripts for bash / zsh / fish.
+*/
+const SUBCOMMANDS = [
+	"await-review",
+	"reply",
+	"resolve",
+	"unresolve",
+	"comment",
+	"comments",
+	"url",
+	"mcp",
+	"plan",
+	"update",
+	"gh",
+	"doctor",
+	"show",
+	"completion",
+	"progress"
+];
+const PLAN_ACTIONS = [
+	"submit",
+	"await",
+	"list",
+	"show",
+	"versions",
+	"reply",
+	"resolve"
+];
+const GH_ACTIONS = [
+	"status",
+	"pr-fetch",
+	"pr-review",
+	"pr-list-comments"
+];
+const GLOBAL_FLAGS = [
+	"--help",
+	"--version",
+	"--web",
+	"--terminal",
+	"--tui",
+	"--no-open",
+	"--port",
+	"--host",
+	"--staged",
+	"--cached",
+	"--gh-pr"
+];
+function bashCompletion() {
+	return `# diffing bash completion
+_diffing() {
+  local cur prev words cword
+  _init_completion || return
+  case "\${words[1]}" in
+    plan) COMPREPLY=( $(compgen -W "${PLAN_ACTIONS.join(" ")}" -- "$cur") ) ;;
+    gh) COMPREPLY=( $(compgen -W "${GH_ACTIONS.join(" ")}" -- "$cur") ) ;;
+    completion) COMPREPLY=( $(compgen -W "bash zsh fish" -- "$cur") ) ;;
+    comments) COMPREPLY=( $(compgen -W "--open --json --format" -- "$cur") ) ;;
+    *)
+      if [[ "$cur" == -* ]]; then
+        COMPREPLY=( $(compgen -W "${GLOBAL_FLAGS.join(" ")}" -- "$cur") )
+      else
+        COMPREPLY=( $(compgen -W "${SUBCOMMANDS.join(" ")}" -- "$cur") )
+      fi
+      ;;
+  esac
+}
+complete -F _diffing diffing
+`;
+}
+function zshCompletion() {
+	return `#compdef diffing
+_diffing() {
+  local -a commands
+  commands=(
+    'await-review:Block until human sends review'
+    'reply:Reply to a comment'
+    'resolve:Resolve a comment'
+    'comments:Dump comments'
+    'url:Print server URL'
+    'mcp:Run MCP server'
+    'plan:Plan review commands'
+    'update:Upgrade diffing'
+    'gh:GitHub PR commands'
+    'doctor:Diagnose setup'
+    'show:Show commit(s) like git show'
+    'completion:Print shell completions'
+  )
+  _arguments -C \\
+    '1: :->cmd' \\
+    '*::arg:->args'
+  case $state in
+    cmd) _describe 'command' commands ;;
+    args)
+      case $words[1] in
+        plan) _values 'plan action' ${PLAN_ACTIONS.map((a) => `'${a}'`).join(" ")} ;;
+        gh) _values 'gh action' ${GH_ACTIONS.map((a) => `'${a}'`).join(" ")} ;;
+        completion) _values 'shell' bash zsh fish ;;
+      esac
+      ;;
+  esac
+}
+compdef _diffing diffing
+`;
+}
+function fishCompletion() {
+	return [
+		"complete -c diffing -f",
+		...SUBCOMMANDS.map((s) => `complete -c diffing -n "__fish_use_subcommand" -a ${s}`),
+		...GLOBAL_FLAGS.map((f) => `complete -c diffing -n "__fish_use_subcommand" -l ${f.replace(/^--/, "")}`),
+		...PLAN_ACTIONS.map((a) => `complete -c diffing -n "__fish_seen_subcommand_from plan" -a ${a}`),
+		...GH_ACTIONS.map((a) => `complete -c diffing -n "__fish_seen_subcommand_from gh" -a ${a}`),
+		"complete -c diffing -n \"__fish_seen_subcommand_from completion\" -a \"bash zsh fish\""
+	].join("\n") + "\n";
+}
+function completionFor(shell) {
+	switch (shell.toLowerCase()) {
+		case "bash": return bashCompletion();
+		case "zsh": return zshCompletion();
+		case "fish": return fishCompletion();
+		default: return null;
+	}
+}
+//#endregion
+export { completionFor };

package/dist/diff-fingerprint-CWa-soYD.mjs

@@ -0,0 +1,78 @@
+//#region src/lib/diff-fingerprint.ts
+/**
+* Per-file fingerprints of a unified diff, used to detect "what changed
+* since the last review handoff" without storing full patch text.
+*/
+/** Stable FNV-1a 32-bit hex hash of a string. */
+function hashString(input) {
+	let h = 2166136261;
+	for (let i = 0; i < input.length; i++) {
+		h ^= input.charCodeAt(i);
+		h = Math.imul(h, 16777619);
+	}
+	return (h >>> 0).toString(16).padStart(8, "0");
+}
+/**
+* Split a multi-file unified diff into path → raw file-diff text.
+* Paths are taken from the `b/` side of `diff --git a/... b/...` headers
+* (or the first path for pure deletions).
+*/
+function splitUnifiedDiffByFile(patch) {
+	const map = /* @__PURE__ */ new Map();
+	if (!patch.trim()) return map;
+	const lines = patch.split(/\r?\n/);
+	let currentPath = null;
+	let buf = [];
+	const flush = () => {
+		if (currentPath != null && buf.length > 0) map.set(currentPath, buf.join("\n"));
+		currentPath = null;
+		buf = [];
+	};
+	for (const line of lines) {
+		const m = /^diff --git a\/(.+?) b\/(.+)$/.exec(line);
+		if (m) {
+			flush();
+			currentPath = m[2] === "/dev/null" ? m[1] : m[2];
+			buf = [line];
+			continue;
+		}
+		if (currentPath != null) buf.push(line);
+	}
+	flush();
+	return map;
+}
+/** path → content fingerprint for every file in the patch. */
+function fingerprintDiffFiles(patch) {
+	const parts = splitUnifiedDiffByFile(patch);
+	const out = {};
+	for (const [path, text] of parts) out[path] = hashString(text);
+	return out;
+}
+/**
+* Compare two fingerprint maps. Returns sorted path lists.
+*/
+function diffSinceLast(previous, current) {
+	const prev = previous ?? {};
+	const prevKeys = new Set(Object.keys(prev));
+	const currKeys = new Set(Object.keys(current));
+	const changed = [];
+	const added = [];
+	const removed = [];
+	for (const path of currKeys) if (!prevKeys.has(path)) added.push(path);
+	else if (prev[path] !== current[path]) changed.push(path);
+	for (const path of prevKeys) if (!currKeys.has(path)) removed.push(path);
+	changed.sort((a, b) => a.localeCompare(b));
+	added.sort((a, b) => a.localeCompare(b));
+	removed.sort((a, b) => a.localeCompare(b));
+	return {
+		changed,
+		added,
+		removed
+	};
+}
+/** Union of changed + added — the files a reviewer should re-check. */
+function filesToReviewSinceLast(delta) {
+	return [...delta.changed, ...delta.added].sort((a, b) => a.localeCompare(b));
+}
+//#endregion
+export { diffSinceLast, filesToReviewSinceLast, fingerprintDiffFiles };

package/dist/doctor-q6oA64hm.mjs

@@ -0,0 +1,195 @@
+import { r as getSearchStatus, t as loadSettings } from "./settings-BVnzGFL7.mjs";
+import { a as detectGhCli, d as readGithubToken } from "./github-HfIlIS-J.mjs";
+import { i as readServerLock, r as isLockAlive } from "./server-lock-uqSdDYeR.mjs";
+import { t as findTuiBinary } from "./find-tui-binary-CRpbYXLC.mjs";
+import { execFileSync } from "node:child_process";
+import { join } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+//#region src/lib/doctor.ts
+/**
+* `diffing doctor` — diagnostic checks for a healthy local review setup.
+* Pure-ish helpers so the CLI can print a clean report without side effects
+* beyond read-only probes.
+*/
+function tryGitTopLevel(cwd) {
+	try {
+		return execFileSync("git", [
+			"-C",
+			cwd,
+			"rev-parse",
+			"--show-toplevel"
+		], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		}).trim();
+	} catch {
+		return null;
+	}
+}
+async function runDoctor(options) {
+	const cwd = options.cwd ?? process.cwd();
+	const checks = [];
+	const repoRoot = tryGitTopLevel(cwd);
+	if (repoRoot) checks.push({
+		id: "git",
+		label: "Git repository",
+		level: "ok",
+		detail: repoRoot
+	});
+	else checks.push({
+		id: "git",
+		label: "Git repository",
+		level: "error",
+		detail: `${cwd} is not inside a Git repository`
+	});
+	if (repoRoot) {
+		const lock = readServerLock(repoRoot);
+		if (!lock) checks.push({
+			id: "server",
+			label: "Review server",
+			level: "warn",
+			detail: "No active server lock (run `diffing` to start one)"
+		});
+		else if (!isLockAlive(lock, repoRoot)) checks.push({
+			id: "server",
+			label: "Review server",
+			level: "warn",
+			detail: `Stale lock for pid ${lock.pid} — will be replaced on next start`
+		});
+		else {
+			const url = lock.port > 0 ? `http://${lock.host}:${lock.port}` : `mode=${lock.mode ?? "web"}`;
+			checks.push({
+				id: "server",
+				label: "Review server",
+				level: "ok",
+				detail: `${url} (pid ${lock.pid}, mode ${lock.mode ?? "web"})`
+			});
+		}
+	}
+	try {
+		const gh = await detectGhCli();
+		if (gh.available && gh.authenticated) checks.push({
+			id: "gh",
+			label: "GitHub CLI (gh)",
+			level: "ok",
+			detail: gh.user ? `authenticated as ${gh.user}` : "authenticated"
+		});
+		else if (gh.available) {
+			const token = readGithubToken();
+			checks.push({
+				id: "gh",
+				label: "GitHub CLI (gh)",
+				level: token ? "warn" : "warn",
+				detail: token ? "gh present but not authenticated; $GITHUB_TOKEN is set (token fallback for submit)" : "gh present but not authenticated — run `gh auth login` for PR mode"
+			});
+		} else {
+			const token = readGithubToken();
+			checks.push({
+				id: "gh",
+				label: "GitHub CLI (gh)",
+				level: token ? "warn" : "warn",
+				detail: token ? "gh not found; $GITHUB_TOKEN is set (submit-only token path)" : "gh not found and no $GITHUB_TOKEN — PR mode unavailable"
+			});
+		}
+	} catch (err) {
+		checks.push({
+			id: "gh",
+			label: "GitHub CLI (gh)",
+			level: "warn",
+			detail: err?.message ?? "failed to probe gh"
+		});
+	}
+	try {
+		const status = await getSearchStatus();
+		if (status.available) checks.push({
+			id: "search",
+			label: "Native search (fff)",
+			level: "ok",
+			detail: status.indexedFiles != null ? `available · ~${status.indexedFiles} indexed files` : "available"
+		});
+		else checks.push({
+			id: "search",
+			label: "Native search (fff)",
+			level: "warn",
+			detail: status.error || "unavailable on this platform (graceful degradation)"
+		});
+	} catch (err) {
+		checks.push({
+			id: "search",
+			label: "Native search (fff)",
+			level: "warn",
+			detail: err?.message ?? "probe failed"
+		});
+	}
+	const tuiPath = options.cliImportMetaUrl ? findTuiBinary(options.cliImportMetaUrl) : findTuiBinary(import.meta.url);
+	checks.push({
+		id: "tui",
+		label: "TUI binary",
+		level: tuiPath ? "ok" : "warn",
+		detail: tuiPath ?? "not found (optional — web UI is the supported path)"
+	});
+	try {
+		const settings = loadSettings();
+		checks.push({
+			id: "settings",
+			label: "User settings",
+			level: "ok",
+			detail: `theme=${settings.theme} density=${settings.density} · ${join(homedir(), ".config", "diffing", "settings.json")}`
+		});
+	} catch (err) {
+		checks.push({
+			id: "settings",
+			label: "User settings",
+			level: "error",
+			detail: err?.message ?? "failed to load settings.json"
+		});
+	}
+	if (repoRoot) try {
+		const { getProjectStorageDir } = await import("./git-DaP_1rVy.mjs");
+		const dir = getProjectStorageDir();
+		const marker = join(dir, "repo_path.txt");
+		if (existsSync(marker)) {
+			const recorded = readFileSync(marker, "utf-8").trim();
+			checks.push({
+				id: "storage",
+				label: "Project storage",
+				level: "ok",
+				detail: `${dir} (repo_path=${recorded || "n/a"})`
+			});
+		} else checks.push({
+			id: "storage",
+			label: "Project storage",
+			level: "ok",
+			detail: `${dir} (will be created on first use)`
+		});
+	} catch (err) {
+		checks.push({
+			id: "storage",
+			label: "Project storage",
+			level: "warn",
+			detail: err?.message ?? "could not resolve storage dir"
+		});
+	}
+	return {
+		checks,
+		ok: !checks.some((c) => c.level === "error")
+	};
+}
+function formatDoctorReport(report) {
+	const icon = (level) => level === "ok" ? "✓" : level === "warn" ? "!" : "✗";
+	const lines = ["diffing doctor", "─────────────"];
+	for (const c of report.checks) {
+		lines.push(`${icon(c.level)} ${c.label}`);
+		lines.push(`  ${c.detail}`);
+	}
+	lines.push("");
+	lines.push(report.ok ? "Overall: OK" : "Overall: issues found (see errors above)");
+	return lines.join("\n");
+}
+//#endregion
+export { formatDoctorReport, runDoctor };

package/dist/find-tui-binary-CRpbYXLC.mjs

@@ -0,0 +1,52 @@
+import { execFileSync } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { dirname, isAbsolute, resolve } from "node:path";
+import { existsSync } from "node:fs";
+//#region src/lib/find-tui-binary.ts
+/**
+* Locate the `diffing-tui` native binary. Looks, in order:
+*   1. Sibling of the calling module (`dist/diffing-tui[.exe]` after build).
+*   2. `bin/diffing-tui[.exe]` next to the package root.
+*   3. `target/release/diffing-tui[.exe]` next to the package root
+*      (cargo release build).
+*   4. `target/debug/diffing-tui[.exe]` next to the package root
+*      (cargo debug build — the common case during development, especially
+*      on Windows where release builds are slow).
+*   5. `$PATH` lookup via `which` / `where`.
+*
+* Returns the absolute path of the first match, or `null` if none are found.
+*
+* `callerUrl` is the `import.meta.url` of the caller — pass `import.meta.url`
+* from `cli.ts`. Exposed as a parameter so unit tests can pin the search
+* root to a known location instead of depending on the test runner's CWD.
+*/
+function findTuiBinary(callerUrl) {
+	const ext = process.platform === "win32" ? ".exe" : "";
+	const here = dirname(fileURLToPath(callerUrl));
+	const candidates = [
+		resolve(here, `diffing-tui${ext}`),
+		resolve(here, "..", "bin", `diffing-tui${ext}`),
+		resolve(here, "..", "target", "release", `diffing-tui${ext}`),
+		resolve(here, "..", "..", "target", "release", `diffing-tui${ext}`),
+		resolve(here, "..", "target", "debug", `diffing-tui${ext}`),
+		resolve(here, "..", "..", "target", "debug", `diffing-tui${ext}`)
+	];
+	for (const c of candidates) if (existsSync(c)) return c;
+	try {
+		const out = execFileSync(process.platform === "win32" ? "where" : "which", ["diffing-tui"], {
+			encoding: "utf-8",
+			stdio: [
+				"ignore",
+				"pipe",
+				"ignore"
+			]
+		}).trim();
+		if (out) {
+			const first = out.split(/\r?\n/)[0]?.trim();
+			if (first && isAbsolute(first)) return first;
+		}
+	} catch {}
+	return null;
+}
+//#endregion
+export { findTuiBinary as t };