dsh-diff-approval 0.25.0 → 0.27.0

package/lib/index.js

@@ -1114,9 +1114,20 @@ async function writeJson(file, value) {
 		throw error;
 	}
 }
+/**
+* The directory a path names, in the platform's own spelling.
+*
+* `node:path` rather than a scan for the last `/`: on Windows the storage root is
+* `C:\Users\<user>\.dsh\diff-approval\workspaces`, which contains no forward slash at all — the
+* scan answered `.`, the `mkdir` before every write became a no-op, and the write itself threw
+* ENOENT, so no pending change was ever persisted there (the failure only reached a logger
+* warning). Both separators have to be understood, and only the platform knows which they are.
+*
+* @param file - the file whose directory is wanted.
+* @returns that directory, or `.` for a bare file name.
+*/
 function dirName(file) {
-	const index = file.lastIndexOf("/");
-	return index < 0 ? "." : file.slice(0, index);
+	return dirname(file);
 }
 /**
 * File-backed pending entries, one global file keyed by path.
@@ -1928,7 +1939,7 @@ function apply(ctx, config) {
 				if (entries.length > 0) store.hydrate(entries);
 				if (migratedLegacy) await persistence.save(store.all());
 			} catch (error) {
-				ctx.logger.warn(`diff-approval: loading persisted state failed: ${errorMessage(error)}`);
+				ctx.logger.error(`diff-approval: loading persisted state failed, so the list starts empty: ${errorMessage(error)}`);
 			}
 		})();
 		return loadPromise;
@@ -2396,6 +2407,9 @@ function apply(ctx, config) {
 	let persistScheduled = false;
 	let lastPersistAt = 0;
 	let persistTimer;
+	/** The last persist failure reported, so a writer that keeps failing says so once (cleared by a
+	*  write that works, which is what makes a later, different failure report again). */
+	let persistFailureReported;
 	/** Actually write the (dirty) store to disk; one coalesced write. */
 	async function flushPersist() {
 		if (!persistDirty) return;
@@ -2404,8 +2418,13 @@ function apply(ctx, config) {
 		try {
 			await ensureLoaded();
 			await persistence.save(store.all());
+			persistFailureReported = void 0;
 		} catch (error) {
-			ctx.logger.warn(`diff-approval: persisting pending changes failed: ${errorMessage(error)}`);
+			const message = errorMessage(error);
+			if (persistFailureReported !== message) {
+				persistFailureReported = message;
+				ctx.logger.error(`diff-approval: persisting pending changes failed, so the list will not survive a restart: ${message}`);
+			}
 		}
 	}
 	/** Mark the store dirty and schedule one throttled, coalesced write. Pass
@@ -3029,6 +3048,50 @@ function apply(ctx, config) {
 						duplicates: 0
 					}
 				};
+				/**
+				* Admit what the add found and answer the wire value. Shared by the two ways in — the
+				* one file a reader named, and the scan of a path — so a named file is listed, counted
+				* and identified exactly like a scanned one.
+				*
+				* @param candidates - the entries to admit (already built, in order).
+				* @param directory - whether the named path was a directory (its own outcome wording).
+				* @param cut - whether the walk hit its cap.
+				* @returns the channel's answer for this add.
+				*/
+				const admitNamed = async (candidates, directory, cut) => {
+					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" : directory ? "empty" : "unchanged";
+					const single = directory ? void 0 : fresh[0] ?? store.list(target.sessionId).find((entry) => pathIdentity(entry.path) === pathIdentity(absolute));
+					return {
+						ok: true,
+						value: {
+							outcome,
+							added,
+							duplicates,
+							...single === void 0 ? {} : { id: single.id },
+							...cut ? { truncated: true } : {}
+						}
+					};
+				};
+				const now = Date.now();
+				if (target.exact) {
+					const existing = store.list(target.sessionId).find((entry) => pathIdentity(entry.path) === pathIdentity(absolute));
+					if (existing !== void 0) return await admitNamed([existing], false, false);
+					const content = await readTextOrNone(absolute, signal);
+					return await admitNamed(content === void 0 ? [] : [{
+						id: absolute,
+						sessionId: target.sessionId,
+						path: absolute,
+						kind: "edit",
+						oldText: content,
+						newText: content,
+						updatedAt: now,
+						sessionIds: [target.sessionId]
+					}], false, false);
+				}
 				const root = detectVcsRoot(workspace.path);
 				if (root === void 0) return {
 					ok: true,
@@ -3063,7 +3126,6 @@ function apply(ctx, config) {
 						}
 					};
 				}
-				const now = Date.now();
 				const candidates = changes.map((change) => ({
 					id: change.path,
 					sessionId: target.sessionId,
@@ -3101,22 +3163,7 @@ function apply(ctx, config) {
 						});
 					}
 				}
-				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";
-				const single = isDirectory ? void 0 : fresh[0] ?? store.list(target.sessionId).find((entry) => pathIdentity(entry.path) === pathIdentity(absolute));
-				return {
-					ok: true,
-					value: {
-						outcome,
-						added,
-						duplicates,
-						...single === void 0 ? {} : { id: single.id },
-						...truncated ? { truncated: true } : {}
-					}
-				};
+				return await admitNamed(candidates, isDirectory, truncated);
 			}
 			case "open": {
 				const target = openTargetOf(payload);

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

@@ -1,13 +1,27 @@
 /** Sidebar-foot pending-edit review action and the split review panel it opens. */
+import type { ReactNode } from 'react';
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { DiffApprovalBlockRange, PendingFileDiff } from '../types.ts';
 import type { PendingPanelFace } from './slots.ts';
 import type { Translator } from './locales.ts';
 import { computeWholeFileDiff } from './whole-file-diff.ts';
+import type { Discussion } from './discussion.ts';
 import type { ChangeBlock, IntraRun } from './whole-file-diff.ts';
 import type { HighlightSides } from './highlight.ts';
 import type { VisibleLines } from './windowed-highlight.ts';
+/**
+ * File-list pane width bounds for the manual split drag, in px.
+ *
+ * The floor is the width the pane's bulk footer needs to keep its three labels on ONE line
+ * (全部保留 / 全部回退 / 添加). Each is a `.action` — 12px text, 12px of side padding and a
+ * hairline, so 26px of chrome — laid out in `.bulkActions` (6px gaps, and its own 8px right inset)
+ * inside `.fileList`'s 8px side padding and 1px border: 74 + 6 + 74 + 6 + 66 + 8 + 17 = 251px, and
+ * a hair of slack on top. Narrower than that the row shrinks its buttons until the labels wrap onto
+ * two lines, which makes the pane's most-used controls two rows tall in the narrowest case — so the
+ * floor is not just a drag limit, it is the width at which the footer is still itself.
+ */
+export declare const MIN_LIST_WIDTH_PX = 260;
 /** Normalize a path for comparison: forward slashes, no trailing slash. */
 export declare function normalizeDiffPath(p: string): string;
 /** Whether a produced-file chip path and a pending file path refer to the same
@@ -22,6 +36,30 @@ export declare function diffPathsMatch(chipPath: string, filePath: string, works
  * breakpoint so the two stay consistent. */
 export declare const SIDEBAR_AUTO_COLLAPSE_PX = 1024;
 export declare function wrapInto(text: string, widthPx: number, measure: (t: string) => number, tabPx: number): string[];
+/**
+ * Wrap one line of a turn the way the browser lays it out: the prose by character, each inline-code
+ * chip as one box that cannot be broken.
+ *
+ * `wrapInto` walks characters and nothing else, which is right for the code view and wrong here:
+ * a turn's chip is an inline-flex box (the chat's own inline code, see `.discussionCode`), so half
+ * of a chip never lands on the next line — it moves over whole, and the text after it starts after
+ * the box rather than inside it. Measuring the chip as ordinary text therefore reserves the wrong
+ * number of rows on exactly the lines that carry one, and a row too few is a clipped last line.
+ *
+ * The prose segments are wrapped by `wrapInto` itself, so a line with a chip in it breaks its words
+ * and its spaces exactly where a line without one does; only the chips are placed as boxes.
+ *
+ * @param line - the line's text, markers and all: the runs are read the way the render reads them.
+ * @param room - the width the line wraps in.
+ * @param measure - the prose measurer.
+ * @param chipWidth - the width of one chip's BOX (its text in the chip's own font, plus its padding
+ *   and its hairline).
+ * @param tabPx - one tab stop, in px.
+ * @returns the row count for the line.
+ */
+export declare function wrapChipRows(line: string, room: number, measure: (text: string) => number, chipWidth: (text: string) => number, tabPx: number): number;
+/** Create a measurer bound to `font`; falls back to a rough char estimate. */
+export declare function makeMeasurer(font: string | undefined): ((text: string) => number) | undefined;
 /** Full panel props composed by the sidebar footer-action slot. */
 export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'> & PendingPanelDockProps;
 /** How the panel is hosted when it is not the footer's floating overlay: the
@@ -85,6 +123,7 @@ interface RowRange {
  *  shared toolbar/keyboard in split mode (its own `focus` is private here). */
 export interface SplitDiffHandle {
     jump: (direction: -1 | 1, wrapGuard?: boolean, singleToast?: boolean) => void;
+    land: (row: number, toCard?: boolean, flash?: boolean) => void;
     openSearch: () => void;
     toggleSearch: () => void;
     closeSearch: () => boolean;
@@ -110,6 +149,12 @@ export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
     /** Report which source lines this view is showing, so the parent's windowed
      *  highlighter follows this view's own scroller (it has its own virtual window). */
     onVisibleLines: (visible: VisibleLines) => void;
+    /** The threads this file carries, laid out: each hangs under the pair its anchor ends in. */
+    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 comment action for the current selection, when the panel offers one for it. */
+    selectionComment?: ReactNode;
 } & import("react").RefAttributes<SplitDiffHandle>>;
 /**
  * Reconstruct the plain text of the current selection so auto-wrap's visual

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

@@ -70,6 +70,17 @@ export interface Discussion {
      * outdated and the quote is what the reader is shown to know what it had been about.
      */
     quote?: string;
+    /**
+     * The quoted rows with one row of context on each side, as they read when the thread was created.
+     *
+     * The fingerprint a later rebuild matches the thread against. `quote` alone is too weak to say
+     * whether the code is still there: a comment on a common line — a closing brace, a blank line —
+     * found that line somewhere else in the file, followed it, and stayed live however thoroughly the
+     * code under its numbers had been rewritten. The context is what tells a genuine move from that
+     * coincidence. Absent on threads recorded before it was kept, which then falls back to matching
+     * the quote alone.
+     */
+    quoteContext?: string;
     /**
      * The gutter numbers of `quote`'s lines, in the same order, so an outdated block can lay the
      * quote out exactly as the file lays code out. See `DiscussionQuoteLine`.
@@ -118,6 +129,16 @@ export interface Discussion {
      * sets the code's line height to.
      */
     bodyRows?: number;
+    /**
+     * The wrap setting `bodyRows` was counted with, carried by the caller so the quote the
+     * block draws reads the very value its rows were reserved from. Set together with
+     * `bodyRows` and never on its own; an outdated block reserves the quote's rows in code
+     * rows scaled to the thread's grid (see `layoutDiscussion`), and a quote that wrapped
+     * while its rows were counted unwrapped — or the other way round — leaves the block
+     * exactly as tall as the difference, air that the bottom-anchored writing row shows as
+     * a hole in the middle of the thread.
+     */
+    quoteWrap?: boolean;
     /** How many older messages the row cap left out of the render. */
     hidden?: number;
 }
@@ -263,7 +284,23 @@ export declare function discussionOverlapping(discussions: readonly Discussion[]
  * @param rowCount - how many rows the current model has.
  * @returns the re-anchored discussion (the same object when nothing moved).
  */
-export declare function remapDiscussion(discussion: Discussion, lineOf: (row: number) => number | undefined, textOf: (row: number) => string, rowCount: number): Discussion;
+export declare function remapDiscussion(discussion: Discussion, lineOf: (row: number) => number | undefined, textOf: (row: number) => string, rowCount: number, hasNewLine?: (row: number) => boolean): Discussion;
+/**
+ * Re-anchor a whole file's blocks in one pass.
+ *
+ * Each block is re-anchored exactly as `remapDiscussion` does it — same rules, same identities,
+ * same "nothing moved, same object back" contract — but the row windows every quote is looked up
+ * in are joined ONCE for the whole list. A rebuild (a keep, an edit, a switched file) runs this
+ * over every block a file has, and joining the rows per block is what made the pass cost grow with
+ * the number of comments on a long file.
+ *
+ * @param discussions - the blocks to re-anchor.
+ * @param lineOf - the new-file line number of a row, or `undefined` for a row that has none.
+ * @param textOf - the text of a row, for the quote comparison.
+ * @param rowCount - how many rows the current model has.
+ * @returns the re-anchored blocks, in the order they came in.
+ */
+export declare function remapDiscussions(discussions: readonly Discussion[], lineOf: (row: number) => number | undefined, textOf: (row: number) => string, rowCount: number, hasNewLine?: (row: number) => boolean): readonly Discussion[];
 /** What the selection frame shows for the current selection. */
 export interface SelectionFrameActions {
     /** Whether keep/revert apply (the selection fully covers change blocks). */

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

@@ -95,6 +95,16 @@ export interface TabRegistryFace {
             order: number;
             title: () => string;
             description?: () => string;
+            /**
+             * Glyph drawn before the title. The package types this as
+             * `ComponentType<IconProps>`; declared structurally so the build stays off
+             * that package's version line — the shape is what the seat reads, and
+             * leaving it out is why this panel's guide row had no mark of its own.
+             */
+            icon?: (props: {
+                size?: number;
+                className?: string;
+            }) => unknown;
         }[];
     }): () => void;
 }

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

@@ -11,6 +11,12 @@ export declare const zh: {
     'panel.readFailed': string;
     'panel.group.current': string;
     'panel.group.others': string;
+    'panel.tabs': string;
+    'panel.tab.pending': string;
+    'panel.tab.comments': string;
+    'panel.commentsEmpty': string;
+    'panel.commentOutdated': string;
+    'panel.commentEmptyTitle': string;
     'panel.aria': string;
     'panel.stats': string;
     'panel.blockPosition': string;
@@ -54,6 +60,11 @@ export declare const zh: {
     'panel.discussionRoundsDesc': string;
     'panel.quickSummonDesc': string;
     'panel.recordShortcut': string;
+    'panel.key.goto': string;
+    'action.goto': string;
+    'action.gotoGo': string;
+    'action.gotoCancel': string;
+    'panel.gotoMissing': string;
     'settings.keybindings': string;
     'settings.keybindingsDesc': string;
     'settings.comment': string;
@@ -98,8 +109,8 @@ export declare const zh: {
     'discussion.promptRuleSkill': string;
     'discussion.thinking': string;
     'discussion.queued': string;
-    'discussion.outdated': string;
-    'discussion.quote': string;
+    'discussion.answering': string;
+    'discussion.outdatedQuote': string;
     'discussion.hidden': string;
     'discussion.failed': string;
     'discussion.stopped': string;
@@ -175,6 +186,8 @@ export declare const zh: {
     'status.missing': string;
     'panel.resolvedAsk': string;
     'panel.keepInList': string;
+    'panel.removalQuiet': string;
+    'panel.removalQuietHint': string;
     'panel.fileKeptAsk': string;
     'panel.fileRevertedAsk': string;
     'panel.confirmFileRemove': string;
@@ -230,6 +243,12 @@ export declare const en: {
     'panel.readFailed': string;
     'panel.group.current': string;
     'panel.group.others': string;
+    'panel.tabs': string;
+    'panel.tab.pending': string;
+    'panel.tab.comments': string;
+    'panel.commentsEmpty': string;
+    'panel.commentOutdated': string;
+    'panel.commentEmptyTitle': string;
     'panel.aria': string;
     'panel.stats': string;
     'panel.blockPosition': string;
@@ -273,6 +292,11 @@ export declare const en: {
     'panel.discussionRoundsDesc': string;
     'panel.quickSummonDesc': string;
     'panel.recordShortcut': string;
+    'panel.key.goto': string;
+    'action.goto': string;
+    'action.gotoGo': string;
+    'action.gotoCancel': string;
+    'panel.gotoMissing': string;
     'settings.keybindings': string;
     'settings.keybindingsDesc': string;
     'settings.comment': string;
@@ -317,8 +341,8 @@ export declare const en: {
     'discussion.promptRuleSkill': string;
     'discussion.thinking': string;
     'discussion.queued': string;
-    'discussion.outdated': string;
-    'discussion.quote': string;
+    'discussion.answering': string;
+    'discussion.outdatedQuote': string;
     'discussion.hidden': string;
     'discussion.failed': string;
     'discussion.stopped': string;
@@ -394,6 +418,8 @@ export declare const en: {
     'status.missing': string;
     'panel.resolvedAsk': string;
     'panel.keepInList': string;
+    'panel.removalQuiet': string;
+    'panel.removalQuietHint': string;
     'panel.fileKeptAsk': string;
     'panel.fileRevertedAsk': string;
     'panel.confirmFileRemove': string;

package/lib/types/client/panel-memory.d.ts

@@ -14,6 +14,13 @@
  * @module dsh-diff-approval/client/panel-memory
  */
 import type { Discussion } from './discussion.ts';
+/**
+ * Fired on `window` whenever a session's threads change. The threads are written by the file
+ * detail (which owns them) and read by the list pane (whose comments tab shows them all), so the
+ * event is what keeps the two in step: a reader who posts a comment sees it in the list at once
+ * instead of on the next poll.
+ */
+export declare const COMMENTS_CHANGED_EVENT = "dsh-diff-approval:comments-changed";
 /**
  * The comment threads a session's panel is holding.
  * @param sessionId - the session, if any.
@@ -27,6 +34,32 @@ export declare function rememberedDiscussions(sessionId: string | undefined): Re
  * @param byFile - the threads, by pending entry id.
  */
 export declare function rememberDiscussions(sessionId: string | undefined, byFile: Readonly<Record<string, readonly Discussion[]>>): void;
+/**
+ * End one comment, wherever it came from.
+ *
+ * The threads belong to the file detail, which writes them here on every change — but the list
+ * pane shows them all and ends them too, and it has no way to reach into another component's
+ * state. So the list asks the memory, and the detail reads the memory back on the event this
+ * fires (see `COMMENTS_CHANGED_EVENT`): one record, one action, whichever pane the reader used.
+ *
+ * @param sessionId - the session the panel is reviewing; nothing is forgotten without one.
+ * @param fileId - the pending entry the thread hangs in.
+ * @param discussionId - the thread to end; an id that is not there changes nothing.
+ */
+export declare function forgetDiscussion(sessionId: string | undefined, fileId: string, discussionId: string): void;
+/**
+ * Whether the reader asked not to be asked again about removing one file.
+ * @param sessionId - the session the panel is reviewing; nothing is quiet without one.
+ * @param fileId - the pending entry the question was about.
+ * @returns true when the action should run without the question.
+ */
+export declare function removalAskQuiet(sessionId: string | undefined, fileId: string): boolean;
+/**
+ * Stop asking whether one file should leave the list, for the rest of this page.
+ * @param sessionId - the session the panel is reviewing; nothing is recorded without one.
+ * @param fileId - the pending entry the question was about.
+ */
+export declare function quietenRemovalAsk(sessionId: string | undefined, fileId: string): void;
 /**
  * Remember that a session's panel was left showing one file, and where in it.
  * @param sessionId - the session the panel was reviewing; nothing is recorded

package/package.json

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