dsh-diff-approval 0.19.2 → 0.20.0

package/lib/index.js

@@ -138,6 +138,18 @@ var PendingDiffStore = class {
 		return true;
 	}
 	/**
+	* Admit one entry into the list without the change guard {@link fold} applies.
+	* A listed entry may carry no diff at all: a path the user added by hand has
+	* no local change until one appears, and a fully-resolved file has already
+	* folded its diff away. This is the guard-free put {@link restore} performs,
+	* named for its other caller.
+	* @param entry - the entry to insert or replace by path.
+	* @returns whether the store changed.
+	*/
+	insert(entry) {
+		return this.restore(entry);
+	}
+	/**
 	* Merge persisted entries into the store, one per path after folding. A live
 	* entry wins over a persisted one only when its time is newer (folders are
 	* applied in capture order, so a later persisted capture is strictly newer).
@@ -440,6 +452,18 @@ function isPathInside(absolutePath, root) {
 	if (path === base) return true;
 	return path.startsWith(base + sep);
 }
+/**
+* Whether one changed path belongs to the scan: inside the workspace, and inside
+* the narrowed `scope` when the caller set one.
+* @param absolutePath - the changed file's absolute path.
+* @param workspaceRoot - the session's workspace root.
+* @param scope - one path to restrict the scan to, or undefined for all of it.
+* @returns whether the change is in scope.
+*/
+function inScanScope(absolutePath, workspaceRoot, scope) {
+	if (!isPathInside(absolutePath, workspaceRoot)) return false;
+	return scope === void 0 || isPathInside(absolutePath, scope);
+}
 /** The VCS marker of one directory, or undefined when it holds none. */
 function markerOf(directory) {
 	if (existsSync(resolve(directory, ".git"))) return "git";
@@ -511,12 +535,12 @@ function parseGitPorcelainZ(output) {
 }
 /** Enumerate the workspace's local changes in a git checkout. */
 async function gitChanges(input) {
-	const { root, workspaceRoot, includeUntracked, shell, readText, signal } = input;
+	const { root, workspaceRoot, includeUntracked, scope, shell, readText, signal } = input;
 	const stdout = await runShell(shell, "git -c status.renames=false status --porcelain=v1 -z --untracked-files=all", root, signal);
 	const changes = [];
 	for (const { xy, rel } of parseGitPorcelainZ(stdout)) {
 		const absolute = resolve(root, rel);
-		if (!isPathInside(absolute, workspaceRoot)) continue;
+		if (!inScanScope(absolute, workspaceRoot, scope)) continue;
 		if (xy === "??") {
 			if (!includeUntracked) continue;
 			const newText = await readText(absolute) ?? "";
@@ -559,7 +583,7 @@ function xmlUnescape(value) {
 }
 /** Enumerate the workspace's local changes in an svn working copy. */
 async function svnChanges(input) {
-	const { root, workspaceRoot, includeUntracked, shell, readText, signal } = input;
+	const { root, workspaceRoot, includeUntracked, scope, shell, readText, signal } = input;
 	const stdout = await runShell(shell, "svn status --xml", root, signal);
 	const changes = [];
 	const entryPattern = /<entry[^>]*path="([^"]*)"[^>]*>\s*<wc-status[^>]*item="([^"]*)"/g;
@@ -568,7 +592,7 @@ async function svnChanges(input) {
 		const rel = xmlUnescape(match[1]);
 		const item = match[2];
 		const absolute = resolve(root, rel);
-		if (!isPathInside(absolute, workspaceRoot)) continue;
+		if (!inScanScope(absolute, workspaceRoot, scope)) continue;
 		if (item === "modified" || item === "deleted") {
 			let oldText = "";
 			try {
@@ -623,7 +647,7 @@ function p4ChangeOf(line) {
 * not yet opened for add; off keeps to already-opened files (`p4 opened`) so
 * the scan — which can be slow — is skipped. */
 async function p4Changes(input) {
-	const { root, workspaceRoot, includeUntracked, shell, readText, signal } = input;
+	const { root, workspaceRoot, includeUntracked, scope, shell, readText, signal } = input;
 	const stdout = await runShell(shell, includeUntracked ? "p4 status" : "p4 opened", root, signal);
 	const changes = [];
 	for (const line of stdout.split("\n")) {
@@ -632,7 +656,7 @@ async function p4Changes(input) {
 		const local = (await runShell(shell, `p4 where ${shq(opened.depot)}`, root, signal)).trim().split(/\s+/).pop();
 		if (local === void 0 || local.length === 0) continue;
 		const absolute = resolve(local);
-		if (!isPathInside(absolute, workspaceRoot)) continue;
+		if (!inScanScope(absolute, workspaceRoot, scope)) continue;
 		const deleted = opened.action === "delete" || opened.action === "move/delete";
 		const created = opened.action === "add" || opened.action === "move/add";
 		const newText = deleted ? "" : await readText(absolute) ?? "";
@@ -808,6 +832,50 @@ function writeOutcomeOf(value) {
 function errorMessage(error) {
 	return error instanceof Error ? error.message : String(error);
 }
+/** Directories one browse level hides: VCS/build noise a review list never wants.
+*  The path box can still reach them by typing the path outright. */
+const BROWSE_HIDDEN_NAMES = /* @__PURE__ */ new Set([".git", "node_modules"]);
+/** Cap on one browse level's children: the panel renders a list, not a dump of a
+*  huge directory, and it reports `truncated` rather than silently cutting. */
+const BROWSE_ENTRY_CAP = 500;
+/** Cap on the files one no-change walk reads: ticking the box on a directory
+*  asks for "everything under here", which must not mean reading a whole tree
+*  (every file's text) inside one call. */
+const ADD_UNCHANGED_CAP = 300;
+/**
+* One absolute path as a workspace-relative path with `/` separators, or
+* `undefined` when it lies outside the root. `''` is the root itself.
+* @param root - the workspace root.
+* @param absolute - the path to express relative to it.
+* @returns the relative path, or undefined when outside.
+*/
+function workspaceRelativeOf(root, absolute) {
+	const rel = relative(resolve(root), resolve(absolute));
+	if (rel === "") return "";
+	if (isAbsolute(rel)) return void 0;
+	const parts = rel.split(/[\\/]/);
+	if (parts[0] === "..") return void 0;
+	return parts.join("/");
+}
+/**
+* Resolve one caller-supplied path against the workspace root. A relative path
+* is taken as workspace-relative; an absolute one must still land inside.
+* @param root - the workspace root.
+* @param input - the caller's path (absolute or workspace-relative).
+* @returns the absolute path, or undefined when it escapes the workspace.
+*/
+function resolveInsideWorkspace(root, input) {
+	const absolute = isAbsolute(input) ? resolve(input) : resolve(root, input);
+	return workspaceRelativeOf(root, absolute) === void 0 ? void 0 : absolute;
+}
+/** The workspace-relative parent of a relative directory path (`''` at the root). */
+/** Fold one path for comparison: absolute, `/`-separated, case-folded on Windows.
+*  Entries are keyed by the path spelling their capture carried (a tool's display
+*  path or a scan's absolute one), so an equality test has to normalize first. */
+function pathIdentity(absolute) {
+	const unified = resolve(absolute).split(/[\\/]/).join("/");
+	return process.platform === "win32" ? unified.toLowerCase() : unified;
+}
 /** Narrow a tool-execution-shaped value to its name, call id, and agent. */
 function actorOf(value) {
 	if (typeof value !== "object" || value === null) return void 0;
@@ -1091,6 +1159,138 @@ function apply(ctx, config) {
 		};
 	}
 	/**
+	* Fold a batch of entries into one session's list as a single undoable action.
+	* Nothing touches the files, so the batch is undone by restoring each affected
+	* path's pre-fold entry (or removing it when the path was not listed), which is
+	* what the import and the hand-add path both want.
+	* @param sessionId - the session whose list gains the entries.
+	* @param entries - the entries to fold, in capture order.
+	* @param admitNoDiff - also admit entries that carry no diff at all (the
+	*        guard-free insert), which is how a hand-added clean path is listed.
+	* @returns how many entries landed; 0 leaves the store, persistence, and the
+	*          undo queue untouched.
+	*/
+	async function foldBatch(sessionId, entries, admitNoDiff = false) {
+		await ensureLoaded();
+		const before = new Map(store.list(sessionId).map((entry) => [entry.path, entry]));
+		let folded = 0;
+		const changedPaths = [];
+		for (const entry of entries) if (entry.oldText === entry.newText ? admitNoDiff && store.insert(entry) : store.fold(entry)) {
+			folded += 1;
+			changedPaths.push(entry.path);
+		}
+		if (folded === 0) return 0;
+		persistSession(true);
+		const after = new Map(store.list(sessionId).map((entry) => [entry.path, entry]));
+		const batchBefore = [];
+		const batchAfter = [];
+		for (const path of changedPaths) {
+			const final = after.get(path);
+			if (final === void 0) continue;
+			const pre = before.get(path);
+			batchAfter.push({
+				id: final.id,
+				path,
+				entry: final,
+				fileText: void 0
+			});
+			batchBefore.push({
+				id: final.id,
+				path,
+				entry: pre,
+				fileText: void 0
+			});
+		}
+		if (batchBefore.length > 0) pushUndo(sessionId, {
+			id: batchBefore[0].id,
+			path: batchBefore[0].path,
+			entry: void 0,
+			fileText: void 0,
+			batch: batchBefore
+		}, {
+			id: batchAfter[0].id,
+			path: batchAfter[0].path,
+			entry: void 0,
+			fileText: void 0,
+			batch: batchAfter
+		});
+		return folded;
+	}
+	/**
+	* One path's text, or `undefined` when it is absent or not readable as text
+	* (a binary, an unreadable permission). An empty file reads as `''`, which is
+	* a value: a listed entry may carry no content at all.
+	* @param absolute - the path to read.
+	* @param signal - caller lifetime.
+	* @returns the text, or undefined.
+	*/
+	async function readTextOrNone(absolute, signal) {
+		try {
+			return await ctx.fs.readText(await ctx.fs.resolve(absolute, { signal }), signal);
+		} catch {
+			return;
+		}
+	}
+	/**
+	* Every regular file under one directory, with its text. Breadth-first in the
+	* backend's name order, hiding the browse's noise names, skipping whatever is
+	* not readable as text, and stopping at {@link ADD_UNCHANGED_CAP} files so
+	* "include paths with no change" cannot read an unbounded tree in one call.
+	* Symlinked directories are followed once, so a cycle ends rather than loops.
+	* @param root - the resolved directory target to walk.
+	* @param rootAbsolute - that directory's absolute path.
+	* @param signal - caller lifetime.
+	* @returns the files found and whether the cap cut the walk short.
+	*/
+	async function collectFilesUnder(root, rootAbsolute, signal) {
+		const files = [];
+		const visited = /* @__PURE__ */ new Set();
+		if (typeof root.targetKey === "string" && root.targetKey !== "") visited.add(root.targetKey);
+		const queue = [{
+			absolute: rootAbsolute,
+			target: root
+		}];
+		while (queue.length > 0) {
+			const current = queue.shift();
+			if (current === void 0) break;
+			let children;
+			try {
+				children = await ctx.fs.listDir(current.target, signal);
+			} catch {
+				continue;
+			}
+			for (const child of children) {
+				if (BROWSE_HIDDEN_NAMES.has(child.name)) continue;
+				const absolute = resolve(current.absolute, child.name);
+				if (child.type === "directory") {
+					const key = child.target.targetKey;
+					if (typeof key === "string" && key !== "") {
+						if (visited.has(key)) continue;
+						visited.add(key);
+					}
+					queue.push({
+						absolute,
+						target: child.target
+					});
+					continue;
+				}
+				if (child.type !== "file") continue;
+				if (files.length >= ADD_UNCHANGED_CAP) return {
+					files,
+					truncated: true
+				};
+				files.push({
+					path: absolute,
+					content: await readTextOrNone(absolute, signal)
+				});
+			}
+		}
+		return {
+			files,
+			truncated: false
+		};
+	}
+	/**
 	* The workspace whose session account holds `sessionId`. Web sessions are
 	* attached to a workspace at creation, so an unowned session is the
 	* memory-only edge (its entries never persist).
@@ -1298,6 +1498,33 @@ function apply(ctx, config) {
 						value: { outcome: "missing" }
 					};
 				}
+				if (payload.keepListed === true) {
+					store.update(target.id, { oldText: entry.newText });
+					const afterEntry = {
+						...entry,
+						oldText: entry.newText,
+						updatedAt: Date.now()
+					};
+					pushUndo(target.sessionId, {
+						id: entry.path,
+						path: entry.path,
+						entry,
+						fileText: void 0
+					}, {
+						id: entry.path,
+						path: entry.path,
+						entry: afterEntry,
+						fileText: void 0
+					});
+					persistSession(true);
+					return {
+						ok: true,
+						value: {
+							outcome: "kept",
+							resolved: true
+						}
+					};
+				}
 				store.remove(target.id);
 				pushUndo(target.sessionId, {
 					id: entry.path,
@@ -1334,6 +1561,34 @@ function apply(ctx, config) {
 				} catch (error) {
 					return rpcError(`revert failed: ${errorMessage(error)}`);
 				}
+				if (payload.keepListed === true) {
+					const content = undo?.after.fileText ?? "";
+					store.update(target.id, { newText: content });
+					const afterEntry = {
+						...entry,
+						newText: content,
+						updatedAt: Date.now()
+					};
+					if (undo !== void 0) pushUndo(target.sessionId, {
+						id: entry.path,
+						path: entry.path,
+						entry,
+						fileText: undo.before.fileText
+					}, {
+						id: entry.path,
+						path: entry.path,
+						entry: afterEntry,
+						fileText: content
+					});
+					persistSession(true);
+					return {
+						ok: true,
+						value: {
+							outcome: "reverted",
+							resolved: true
+						}
+					};
+				}
 				store.remove(target.id);
 				if (undo !== void 0) pushUndo(target.sessionId, undo.before, undo.after);
 				persistSession(true);
@@ -1623,67 +1878,256 @@ function apply(ctx, config) {
 				} catch (error) {
 					return rpcError(`import failed: ${errorMessage(error)}`);
 				}
+				return {
+					ok: true,
+					value: {
+						imported: await foldBatch(sessionId, changes.map((change) => ({
+							id: change.path,
+							sessionId,
+							path: change.path,
+							kind: change.kind,
+							oldText: change.oldText,
+							newText: change.newText,
+							updatedAt: Date.now(),
+							sessionIds: [sessionId]
+						}))),
+						detected: true
+					}
+				};
+			}
+			case "vcs-refresh": {
+				const target = targetOf(payload);
+				if (target === void 0) return rpcError("sessionId and id must be non-empty strings");
 				await ensureLoaded();
-				const before = new Map(store.list(sessionId).map((entry) => [entry.path, entry]));
-				let imported = 0;
-				const changedPaths = [];
-				for (const change of changes) {
-					const entry = {
-						id: change.path,
-						sessionId,
-						path: change.path,
-						kind: change.kind,
-						oldText: change.oldText,
-						newText: change.newText,
-						updatedAt: Date.now(),
-						sessionIds: [sessionId]
-					};
-					if (store.fold(entry)) {
-						imported += 1;
-						changedPaths.push(change.path);
+				const entry = store.get(target.id);
+				if (entry === void 0) return {
+					ok: true,
+					value: { outcome: "missing" }
+				};
+				const workspace = workspaceOf(target.sessionId);
+				if (workspace === void 0) return rpcError("refresh unavailable: the session has no workspace");
+				const root = detectVcsRoot(workspace.path);
+				if (root === void 0) return {
+					ok: true,
+					value: { outcome: "no-vcs" }
+				};
+				const shell = ctx.get("shell");
+				if (shell === void 0) return rpcError("refresh unavailable: the deployment has no shell executor");
+				let changes;
+				try {
+					changes = await listVcsChanges({
+						kind: root.kind,
+						root: root.root,
+						workspaceRoot: workspace.path,
+						includeUntracked: payload.includeUntracked === true,
+						scope: entry.path,
+						shell,
+						readText: (path) => readFile(path, "utf8").catch(() => void 0),
+						signal
+					});
+				} catch (error) {
+					return rpcError(`refresh failed: ${errorMessage(error)}`);
+				}
+				const change = changes.find((candidate) => pathIdentity(candidate.path) === pathIdentity(entry.path));
+				if (change === void 0) return {
+					ok: true,
+					value: { outcome: "no-change" }
+				};
+				if (change.kind === entry.kind && change.oldText === entry.oldText && change.newText === entry.newText) return {
+					ok: true,
+					value: { outcome: "unchanged" }
+				};
+				const refreshed = {
+					...entry,
+					kind: change.kind,
+					oldText: change.oldText,
+					newText: change.newText,
+					updatedAt: Date.now()
+				};
+				store.restore(refreshed);
+				pushUndo(target.sessionId, {
+					id: entry.path,
+					path: entry.path,
+					entry,
+					fileText: void 0
+				}, {
+					id: entry.path,
+					path: entry.path,
+					entry: refreshed,
+					fileText: void 0
+				});
+				persistSession(true);
+				return {
+					ok: true,
+					value: { outcome: "refreshed" }
+				};
+			}
+			case "list-path": {
+				const sessionId = sessionOf(payload);
+				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				const workspace = workspaceOf(sessionId);
+				if (workspace === void 0) return rpcError("browse unavailable: the session has no workspace");
+				const requested = pathFieldOf(payload) ?? "";
+				const absolute = resolveInsideWorkspace(workspace.path, requested);
+				if (absolute === void 0) return rpcError("browse failed: the path is outside the workspace");
+				let children;
+				try {
+					const target = await ctx.fs.resolve(absolute, { signal });
+					const info = await ctx.fs.stat(target, signal);
+					if (info === void 0 || info.type !== "directory") return rpcError("browse failed: not a directory");
+					children = await ctx.fs.listDir(target, signal);
+				} catch (error) {
+					return rpcError(`browse failed: ${errorMessage(error)}`);
+				}
+				const entries = [];
+				for (const child of children) {
+					if (BROWSE_HIDDEN_NAMES.has(child.name)) continue;
+					const childAbsolute = resolve(absolute, child.name);
+					if (workspaceRelativeOf(workspace.path, childAbsolute) === void 0) continue;
+					entries.push({
+						name: child.name,
+						type: child.type === "directory" ? "directory" : child.type === "file" ? "file" : "other",
+						path: childAbsolute,
+						size: child.type === "file" ? child.size : void 0
+					});
+				}
+				entries.sort((left, right) => {
+					const rank = (value) => value.type === "directory" ? 0 : 1;
+					const byKind = rank(left) - rank(right);
+					return byKind !== 0 ? byKind : left.name.localeCompare(right.name, void 0, {
+						numeric: true,
+						sensitivity: "base"
+					});
+				});
+				const truncated = entries.length > BROWSE_ENTRY_CAP;
+				return {
+					ok: true,
+					value: {
+						path: absolute,
+						entries: truncated ? entries.slice(0, BROWSE_ENTRY_CAP) : entries,
+						truncated
 					}
+				};
+			}
+			case "add-path": {
+				const target = addTargetOf(payload);
+				if (target === void 0) return rpcError("sessionId and path must be non-empty strings");
+				const workspace = workspaceOf(target.sessionId);
+				if (workspace === void 0) return rpcError("add unavailable: the session has no workspace");
+				const absolute = resolveInsideWorkspace(workspace.path, target.path);
+				if (absolute === void 0) return {
+					ok: true,
+					value: {
+						outcome: "outside",
+						added: 0,
+						duplicates: 0
+					}
+				};
+				await ensureLoaded();
+				let info;
+				try {
+					const target = await ctx.fs.resolve(absolute, { signal });
+					info = await ctx.fs.stat(target, signal);
+				} catch (error) {
+					return rpcError(`add failed: ${errorMessage(error)}`);
 				}
-				if (imported > 0) {
-					persistSession();
-					const after = new Map(store.list(sessionId).map((entry) => [entry.path, entry]));
-					const batchBefore = [];
-					const batchAfter = [];
-					for (const path of changedPaths) {
-						const final = after.get(path);
-						if (final === void 0) continue;
-						const pre = before.get(path);
-						batchAfter.push({
-							id: final.id,
-							path,
-							entry: final,
-							fileText: void 0
-						});
-						batchBefore.push({
-							id: final.id,
-							path,
-							entry: pre,
-							fileText: void 0
-						});
+				if (info === void 0 || info.type === "other") return {
+					ok: true,
+					value: {
+						outcome: "missing",
+						added: 0,
+						duplicates: 0
 					}
-					if (batchBefore.length > 0) pushUndo(sessionId, {
-						id: batchBefore[0].id,
-						path: batchBefore[0].path,
-						entry: void 0,
-						fileText: void 0,
-						batch: batchBefore
-					}, {
-						id: batchAfter[0].id,
-						path: batchAfter[0].path,
-						entry: void 0,
-						fileText: void 0,
-						batch: batchAfter
+				};
+				const isDirectory = info.type === "directory";
+				const root = detectVcsRoot(workspace.path);
+				if (root === void 0) return {
+					ok: true,
+					value: {
+						outcome: "no-vcs",
+						added: 0,
+						duplicates: 0
+					}
+				};
+				const shell = ctx.get("shell");
+				if (shell === void 0) return rpcError("add unavailable: the deployment has no shell executor");
+				let changes;
+				try {
+					changes = await listVcsChanges({
+						kind: root.kind,
+						root: root.root,
+						workspaceRoot: workspace.path,
+						includeUntracked: true,
+						scope: absolute,
+						shell,
+						readText: (path) => readFile(path, "utf8").catch(() => void 0),
+						signal
 					});
+				} catch (error) {
+					return {
+						ok: true,
+						value: {
+							outcome: "failed",
+							added: 0,
+							duplicates: 0,
+							message: errorMessage(error)
+						}
+					};
 				}
+				const now = Date.now();
+				const candidates = changes.map((change) => ({
+					id: change.path,
+					sessionId: target.sessionId,
+					path: change.path,
+					kind: change.kind,
+					oldText: change.oldText,
+					newText: change.newText,
+					updatedAt: now,
+					sessionIds: [target.sessionId]
+				}));
+				let truncated = false;
+				if (target.includeUnchanged) {
+					const scanned = new Set(candidates.map((entry) => pathIdentity(entry.path)));
+					const found = isDirectory ? await collectFilesUnder(await ctx.fs.resolve(absolute, { signal }), absolute, signal) : {
+						files: [{
+							path: absolute,
+							content: await readTextOrNone(absolute, signal)
+						}],
+						truncated: false
+					};
+					truncated = found.truncated;
+					for (const file of found.files) {
+						if (file.content === void 0) continue;
+						if (scanned.has(pathIdentity(file.path))) continue;
+						scanned.add(pathIdentity(file.path));
+						candidates.push({
+							id: file.path,
+							sessionId: target.sessionId,
+							path: file.path,
+							kind: "edit",
+							oldText: file.content,
+							newText: file.content,
+							updatedAt: now,
+							sessionIds: [target.sessionId]
+						});
+					}
+				}
+				const listed = new Set(store.list(target.sessionId).map((entry) => pathIdentity(entry.path)));
+				const fresh = candidates.filter((entry) => !listed.has(pathIdentity(entry.path)));
+				const duplicates = candidates.length - fresh.length;
+				const added = await foldBatch(target.sessionId, fresh, true);
+				const outcome = added > 0 ? "added" : duplicates > 0 ? "duplicate" : isDirectory ? "empty" : "unchanged";
 				return {
 					ok: true,
-					value: {
-						imported,
-						detected: true
+					value: truncated ? {
+						outcome,
+						added,
+						duplicates,
+						truncated
+					} : {
+						outcome,
+						added,
+						duplicates
 					}
 				};
 			}
@@ -1845,6 +2289,24 @@ function previewImageTargetOf(payload) {
 		path
 	};
 }
+/** One payload's optional `path` field; absent (or not a string) is undefined. */
+function pathFieldOf(payload) {
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
+	const path = payload.path;
+	return typeof path === "string" ? path : void 0;
+}
+/** Narrow a wire payload to one hand-added path. */
+function addTargetOf(payload) {
+	const sessionId = sessionOf(payload);
+	if (sessionId === void 0) return void 0;
+	const path = pathFieldOf(payload)?.trim();
+	if (path === void 0 || path === "") return void 0;
+	return {
+		sessionId,
+		path,
+		includeUnchanged: payload.includeUnchanged === true
+	};
+}
 /** Narrow a wire payload to one open target: the keep/revert pair plus the action. */
 function openTargetOf(payload) {
 	const target = targetOf(payload);