dsh-diff-approval 0.31.0 → 0.32.0

package/lib/index.js

@@ -3855,6 +3855,53 @@ async function listVcsChanges(input) {
 	}
 }
 /**
+* Read one file's BASELINE content — the version every branch above reads to build a change's
+* `oldText`: git's last commit (`HEAD`, when the scan could not see the change), svn's `BASE`, p4's
+* `#have`. The commands are the same ones those branches run, so a caller that needs one file's
+* pre-change content outside a scan (the per-file refresh's "was this committed?" check) does not
+* invent a second way to ask the same question — or a second set of failure modes to reason about.
+*
+* The two answers stay distinguishable, exactly as they do in a scan: a baseline that carries no
+* version of the path is {@link VcsBaseline} `none` (git is the only branch that can report it,
+* through {@link readGitBlob}'s own absence pattern), while a read that FAILED — a refused command,
+* a timeout, a missing client — throws, because "could not read" is not "there is nothing there".
+*
+* @param kind - the VCS to read.
+* @param root - the repository/checkout/client root, as {@link detectVcsRoot} found it.
+* @param absolutePath - the file's absolute path (inside the root's tree).
+* @param shell - the deployment's shell executor.
+* @param signal - the caller's abort signal.
+* @returns the baseline content, or `none` when the baseline has no version of the path.
+* @throws when the baseline read failed for any other reason.
+*/
+async function readVcsBaseline(kind, root, absolutePath, shell, signal) {
+	switch (kind) {
+		case "git": {
+			const blob = await readGitBlob(root, "HEAD", relative(root, resolve(absolutePath)).split(sep).join("/"), shell, signal);
+			return blob.found ? {
+				state: "file",
+				text: blob.text
+			} : { state: "none" };
+		}
+		case "svn": try {
+			return {
+				state: "file",
+				text: await runShell(shell, `svn cat -r BASE ${shq(absolutePath)}`, root, signal)
+			};
+		} catch (error) {
+			throw new Error(`could not read ${absolutePath} at BASE: ${errorMessage$1(error)}`);
+		}
+		case "p4": try {
+			return {
+				state: "file",
+				text: await runShell(shell, `p4 print -q ${shq(absolutePath)}#have`, root, signal)
+			};
+		} catch (error) {
+			throw new Error(`could not read ${absolutePath}#have: ${errorMessage$1(error)}`);
+		}
+	}
+}
+/**
 * Parse `major.minor.patch`, and NOTHING else.
 *
 * Deliberately strict, because the alternative is a bogus "newer": a pre-release
@@ -4227,6 +4274,29 @@ function normalizeEol(text) {
 function contentEqual(a, b) {
 	return contentLinesOf(normalizeEol(a)).join("\n") === contentLinesOf(normalizeEol(b)).join("\n");
 }
+/**
+* Whether one entry's change is COMMITTED: its content on disk equals its content at the VCS
+* baseline.
+*
+* Read off the same helpers a scan uses — {@link readVcsBaseline} runs the very commands
+* `listVcsChanges` runs to build a change's `oldText` (git `HEAD`, svn `BASE`, p4 `#have`) — and
+* compared with {@link contentEqual}, the tolerance the whole-file diff already uses. A baseline
+* that carries no version of the path (a file the scan cannot see because it was never
+* committed-and-modified) is NOT "committed": it answers false, exactly like a baseline whose
+* content differs. Anything that failed to read throws, for the caller to read as "not proven".
+*
+* @param root - the detected VCS root.
+* @param kind - the VCS to read the baseline from.
+* @param path - the entry's absolute file path.
+* @param shell - the deployment's shell executor.
+* @param signal - the caller's abort signal.
+* @returns whether the on-disk content is the baseline's.
+*/
+async function committedChange(root, kind, path, shell, signal) {
+	const baseline = await readVcsBaseline(kind, root, path, shell, signal);
+	if (baseline.state !== "file") return false;
+	return contentEqual(await readFile(path, "utf8"), baseline.text);
+}
 /** Re-encode `text`'s line endings to `eol` (its content is unchanged). */
 function reencodeEol(text, eol) {
 	const normalized = normalizeEol(text);
@@ -6723,10 +6793,19 @@ function apply(ctx, config) {
 					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 === void 0) {
+					let committed = false;
+					try {
+						committed = await committedChange(root.root, root.kind, entry.path, shell, signal);
+					} catch {}
+					return {
+						ok: true,
+						value: committed ? {
+							outcome: "committed",
+							resolved: true
+						} : { outcome: "no-change" }
+					};
+				}
 				if (change.earlierVersion === entry.earlierVersion && change.oldText === entry.oldText && change.newText === entry.newText) return {
 					ok: true,
 					value: { outcome: "unchanged" }

package/lib/types/client/PendingPanel.d.ts

@@ -195,8 +195,12 @@ export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
     discussions?: readonly Discussion[];
     /** Draws one thread's card at the width this view gives it (see `DiscussionBlock`). */
     renderDiscussion?: (discussion: Discussion, bodyWidth: number, split: boolean) => ReactNode;
+    /** The keep/revert actions for the current selection, when the panel offers them for it. */
+    selectionKeepRevert?: ReactNode;
     /** The comment action for the current selection, when the panel offers one for it. */
     selectionComment?: ReactNode;
+    /** Whether a selection drag is running: the frame then stays up but takes no pointer events. */
+    selectionDragging?: boolean | undefined;
     /** The changed-line runs the overview ruler draws, in whole-file row indices. */
     rulerRuns: readonly RulerRun[];
     /** The go-to popup, which this view centres on its own box (see `gotoDialog`). */

package/lib/types/client/discussion.d.ts

@@ -363,7 +363,7 @@ export declare function frameNamesNoCurrentLine(quoteLines: readonly DiscussionQ
 export declare function frameCoversRemovedRow(quoteLines: readonly DiscussionQuoteLine[] | undefined): boolean;
 /** What the selection frame shows for the current selection. */
 export interface SelectionFrameActions {
-    /** Whether keep/revert apply (the selection fully covers change blocks). */
+    /** Whether keep/revert apply (the selection touches a change, whole block or part of one). */
     keepRevert: boolean;
     /** Whether a new discussion may be started on this range. */
     comment: boolean;
@@ -373,11 +373,11 @@ export interface SelectionFrameActions {
 /**
  * Decide the selection frame's contents.
  *
- * Keep/revert needs covered change blocks; commenting needs a range that has no
+ * Keep/revert needs the selection to touch a change; commenting needs a range that has no
  * discussion yet. A frame with neither would be an empty floating box, so it is
  * not rendered at all.
  *
- * @param options - whether change blocks are covered, and whether this range already has a discussion.
+ * @param options - whether the selection touches a change, and whether this range already has a discussion.
  * @returns the three flags the caller branches on.
  */
 export declare function selectionFrame(options: {

package/lib/types/client/locales.d.ts

@@ -228,8 +228,13 @@ export declare const zh: {
     'panel.refreshDone': string;
     'panel.refreshUnchanged': string;
     'panel.refreshNone': string;
+    'panel.refreshCommitted': string;
     'panel.refreshUntrackedHint': string;
     'panel.refreshFailed': string;
+    'panel.batchRefreshVcsAsk': string;
+    'panel.refreshManyDone': string;
+    'panel.refreshManyMixed': string;
+    'panel.refreshManyFailed': string;
     'action.addPath': string;
     'panel.addTitle': string;
     'panel.addPathPlaceholder': string;
@@ -492,8 +497,13 @@ export declare const en: {
     'panel.refreshDone': string;
     'panel.refreshUnchanged': string;
     'panel.refreshNone': string;
+    'panel.refreshCommitted': string;
     'panel.refreshUntrackedHint': string;
     'panel.refreshFailed': string;
+    'panel.batchRefreshVcsAsk': string;
+    'panel.refreshManyDone': string;
+    'panel.refreshManyMixed': string;
+    'panel.refreshManyFailed': string;
     'action.addPath': string;
     'panel.addTitle': string;
     'panel.addPathPlaceholder': string;

package/lib/types/client/whole-file-diff.d.ts

@@ -33,6 +33,21 @@ export interface ChangeBlock {
 }
 /** Split a row list into maximal runs of non-context rows. */
 export declare function changeBlocksOf(diff: WholeFileDiff): ChangeBlock[];
+/**
+ * The change region a row range sits in, widened to whole runs: from the first row of the run `start`
+ * belongs to, to the last row of the run `end` belongs to. A row range that names one side of a change —
+ * one line of a replacement, or the additions alone — grows to cover that change's removals as well, which
+ * is what a reader pointing at it means. Rows that are context stand alone (a run is a maximal non-context
+ * run), so a range that touches no change is returned as it is.
+ * @param rows - the whole-file diff rows.
+ * @param start - the range's first row.
+ * @param end - the range's last row.
+ * @returns the widened row range.
+ */
+export declare function changeRunSpanOf(rows: readonly WholeFileDiffRow[], start: number, end: number): {
+    start: number;
+    end: number;
+};
 /**
  * One diff block's old/new line ranges, 1-based inclusive, for block-level
  * keep/revert. A side with no lines (a pure addition or deletion) is empty; its
@@ -46,6 +61,33 @@ export declare function changeBlocksOf(diff: WholeFileDiff): ChangeBlock[];
  * @returns the old and new line ranges.
  */
 export declare function blockRangesOf(rows: readonly WholeFileDiffRow[], block: ChangeBlock): DiffApprovalBlockRange;
+/** One side-by-side pair: the whole-file row index each side holds, when it has one. */
+export interface DiffPairRows {
+    old?: number;
+    new?: number;
+}
+/**
+ * One side-by-side pair's old/new line ranges, 1-based inclusive, for pair-level keep/revert. A pair is
+ * one old line against one new line, so each side contributes a single line; a side the pair does not
+ * have (an unpaired insertion or removal) is the empty range at that side's insertion point, read off the
+ * row before the pair — the same rule `blockRangesOf` applies to a side with no lines at all.
+ * @param rows - the whole-file diff rows.
+ * @param pair - the rows the pair holds.
+ * @returns the old and new line ranges, or undefined for a pair that holds no row.
+ */
+export declare function pairRangeOf(rows: readonly WholeFileDiffRow[], pair: DiffPairRows): DiffApprovalBlockRange | undefined;
+/**
+ * The old/new ranges keep/revert act on for the pairs a side-by-side selection names, in the order they
+ * must be sent. Pairs of context rows are dropped (nothing to act on). When the changed pairs occupy one
+ * contiguous span of the row list with no other changed row inside it, ONE range covers them all: one
+ * host call, one undo step, and the same range a whole-block action would send. Otherwise each pair gets
+ * its own range, ordered from the BOTTOM of the file up, so a splice never moves the line numbers of a
+ * pair still to be applied.
+ * @param rows - the whole-file diff rows.
+ * @param pairs - the pairs the selection names, in row order.
+ * @returns one range, several, or none when the selection carries no change.
+ */
+export declare function pairsRangeOf(rows: readonly WholeFileDiffRow[], pairs: readonly DiffPairRows[]): DiffApprovalBlockRange[];
 /**
  * Compute the whole-file view between two contents. The context budget is the
  * side lengths, so every hunk covers the file and unchanged lines survive as

package/lib/types/types.d.ts

@@ -301,6 +301,9 @@ export type DiffApprovalRefreshOutcome =
  | 'unchanged'
 /** The file has no local VCS change (untracked-and-excluded, or already clean). */
  | 'no-change'
+/** The scan saw no change AND the file's content equals its VCS baseline: the change is
+ *  committed, so the entry's diff is a keep away from being out of date. */
+ | 'committed'
 /** No pending entry existed for the id. */
  | 'missing'
 /** The workspace is not inside a git/svn/p4 checkout. */
@@ -308,6 +311,9 @@ export type DiffApprovalRefreshOutcome =
 /** Value returned by the channel's vcs-refresh endpoint. */
 export interface DiffApprovalRefreshValue {
     outcome: DiffApprovalRefreshOutcome;
+    /** Set when the refresh already settled the entry (the `committed` outcome keeps it, with no
+     *  diff left); absent for every outcome that leaves the decision to the panel. */
+    resolved?: boolean | undefined;
 }
 /** Value returned by the channel's keep and revert endpoints. */
 export interface DiffApprovalActionValue {

package/lib/types/vcs.d.ts

@@ -105,6 +105,18 @@ export interface VcsImportInput {
     readText: VcsFileReader;
     signal?: AbortSignal | undefined;
 }
+/** What a revision has to say about one path: its content, or that the path has no version at all.
+ * A FAILED read is neither: it throws (see {@link readVcsBaseline}). */
+export type VcsBaseline = 
+/** The baseline carries this path; `text` is its content there. */
+{
+    state: 'file';
+    text: string;
+}
+/** The baseline has no version of this path (a creation — there is nothing to restore). */
+ | {
+    state: 'none';
+};
 /**
  * Find the VCS enclosing `start` by walking up the directory tree: the first
  * directory (deepest) holding a marker wins, with git > svn > p4 when several
@@ -121,4 +133,25 @@ export declare function detectVcsRoot(start: string): VcsRoot | undefined;
  * @returns the changes; an absent/unusable VCS surfaces as a thrown error.
  */
 export declare function listVcsChanges(input: VcsImportInput): Promise<VcsChange[]>;
+/**
+ * Read one file's BASELINE content — the version every branch above reads to build a change's
+ * `oldText`: git's last commit (`HEAD`, when the scan could not see the change), svn's `BASE`, p4's
+ * `#have`. The commands are the same ones those branches run, so a caller that needs one file's
+ * pre-change content outside a scan (the per-file refresh's "was this committed?" check) does not
+ * invent a second way to ask the same question — or a second set of failure modes to reason about.
+ *
+ * The two answers stay distinguishable, exactly as they do in a scan: a baseline that carries no
+ * version of the path is {@link VcsBaseline} `none` (git is the only branch that can report it,
+ * through {@link readGitBlob}'s own absence pattern), while a read that FAILED — a refused command,
+ * a timeout, a missing client — throws, because "could not read" is not "there is nothing there".
+ *
+ * @param kind - the VCS to read.
+ * @param root - the repository/checkout/client root, as {@link detectVcsRoot} found it.
+ * @param absolutePath - the file's absolute path (inside the root's tree).
+ * @param shell - the deployment's shell executor.
+ * @param signal - the caller's abort signal.
+ * @returns the baseline content, or `none` when the baseline has no version of the path.
+ * @throws when the baseline read failed for any other reason.
+ */
+export declare function readVcsBaseline(kind: VcsKind, root: string, absolutePath: string, shell: ShellExecutorLike, signal: AbortSignal | undefined): Promise<VcsBaseline>;
 export {};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.31.0",
+  "version": "0.32.0",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",