dsh-diff-approval 0.24.1 → 0.26.0

package/lib/index.js

@@ -3021,6 +3021,58 @@ function apply(ctx, config) {
 					}
 				};
 				const isDirectory = info.type === "directory";
+				if (target.exact && isDirectory) return {
+					ok: true,
+					value: {
+						outcome: "not-a-file",
+						added: 0,
+						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,
@@ -3055,7 +3107,6 @@ function apply(ctx, config) {
 						}
 					};
 				}
-				const now = Date.now();
 				const candidates = changes.map((change) => ({
 					id: change.path,
 					sessionId: target.sessionId,
@@ -3093,24 +3144,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";
-				return {
-					ok: true,
-					value: truncated ? {
-						outcome,
-						added,
-						duplicates,
-						truncated
-					} : {
-						outcome,
-						added,
-						duplicates
-					}
-				};
+				return await admitNamed(candidates, isDirectory, truncated);
 			}
 			case "open": {
 				const target = openTargetOf(payload);
@@ -3282,10 +3316,12 @@ function addTargetOf(payload) {
 	if (sessionId === void 0) return void 0;
 	const path = pathFieldOf(payload)?.trim();
 	if (path === void 0 || path === "") return void 0;
+	const record = payload;
 	return {
 		sessionId,
 		path,
-		includeUnchanged: payload.includeUnchanged === true
+		includeUnchanged: record.includeUnchanged === true,
+		exact: record.exact === true
 	};
 }
 /** Narrow a wire payload to one open target: the keep/revert pair plus the action. */

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

@@ -22,6 +22,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

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

@@ -37,6 +37,14 @@ export interface DiscussionQuoteLine {
     old: number | undefined;
     /** New-file number — the second gutter — `undefined` on a removed line. */
     new: number | undefined;
+    /**
+     * Which side of the change the row was on when the thread quoted it: an added line, a removed
+     * one, or context. Kept so the quote can wear the diff's own green/red washes — the reader
+     * recognised those rows by their colour, and a quote that renders them as plain code loses the
+     * thing they were looking at. Absent on a thread quoted before this was recorded, which then
+     * simply draws no wash.
+     */
+    kind?: 'add' | 'del' | 'context';
 }
 /** One discussion bound to a row range. */
 export interface Discussion {
@@ -105,7 +113,9 @@ export interface Discussion {
     /**
      * How many rows the block's body occupies, measured by the caller from what it
      * actually renders (the thread plus the compose row). It is what keeps a
-     * discussion block's height an exact multiple of the code row.
+     * discussion block's height an exact multiple of the thread's own row — which is fixed, not
+     * the code's (see `THREAD_ROW_PX`): a thread is prose and keeps its size whatever the reader
+     * sets the code's line height to.
      */
     bodyRows?: number;
     /** How many older messages the row cap left out of the render. */
@@ -113,32 +123,58 @@ export interface Discussion {
 }
 /** Rows a folded block occupies: its header line. */
 export declare const DISCUSSION_HEADER_ROWS = 1;
-/** Rows the compose area occupies: 0.3 + 1.4 + 0.3 of a code row. */
+/** Rows the compose area occupies: 0.3 + 1.4 + 0.3 of the thread's own row. */
 export declare const DISCUSSION_COMPOSE_ROWS = 2;
 /**
- * The body budget for the turns a block shows: how many rows of older turns it is worth
- * carrying before the diff it annotates is swamped. It is spent in WHOLE turns — see
- * `discussionTail` — so a single turn that needs more than this is shown in full rather
- * than sliced in half (which is what a hard cap on the body's row count did).
- */
-export declare const DISCUSSION_MAX_BODY_ROWS = 12;
-/**
- * The newest turns that fit a size budget, and how many older ones were left out.
- * A thread grows without bound, so the block shows its tail and says what it is
- * hiding rather than clipping silently; the hidden note costs one row of the
- * budget itself. Sizes are in whatever unit the caller budgets in (the panel uses
- * code rows, fractions included, and rounds the total up once).
+ * The newest rounds of a thread, and how many older turns were left out.
+ *
+ * A thread grows without bound, so the block shows its tail and says what it is hiding. The unit
+ * is the round rather than a row budget: a block keeps the last `rounds` questions and
+ * everything said after them, however long those turns are (the count is a preference). That is possible
+ * because the block reserves exactly what it draws (see `discussionRows`), so a long answer is
+ * shown in full instead of being sliced — the row budget this replaces existed to stop an old
+ * thread from swamping the diff, and a round cap does that without ever cutting a turn in half.
  *
  * @param messages - the whole thread, oldest first.
+ * @param rounds - how many rounds to keep (at least one: something has to be visible).
  * @param sizeOf - the size one message needs when rendered (text plus its chrome).
- * @param capRows - the body budget.
  * @returns the messages to render, the count left out, and the size they need.
  */
-export declare function discussionTail(messages: readonly DiscussionMessage[], sizeOf: (message: DiscussionMessage) => number, capRows: number): {
+export declare function discussionRounds(messages: readonly DiscussionMessage[], rounds: number, sizeOf: (message: DiscussionMessage) => number): {
     messages: readonly DiscussionMessage[];
     hidden: number;
     rows: number;
 };
+/** One run of a turn's prose, after its inline Markdown is read. */
+export interface DiscussionRun {
+    /** A literal run, inline `code`, or **strong** emphasis. */
+    kind: 'text' | 'code' | 'strong';
+    /** What the run draws: for `code` and `strong`, the text with its markers gone. */
+    text: string;
+}
+/**
+ * Read one turn's inline Markdown: `code` and **strong**.
+ *
+ * Deliberately tiny. The thread is laid out on the diff's own row grid — one line box per code
+ * row — so nothing here may become a block: no headings, lists, quotes or fenced code. A marker
+ * with no partner, or one spanning a line break, is left exactly as typed, and so is everything
+ * this does not know about.
+ *
+ * @param text - the turn's text.
+ * @returns its runs, in order.
+ */
+export declare function discussionRuns(text: string): DiscussionRun[];
+/**
+ * A turn's text with its inline markers gone: what the runs draw, character for character.
+ *
+ * The row measurement uses this, so the rows a block reserves and the text it draws agree. The
+ * markers are not drawn, and counting them would reserve room for characters nobody sees — which
+ * is exactly the kind of whole-row slack that leaves a blank row in the block.
+ *
+ * @param text - the turn's text.
+ * @returns the same text without its `code` and **strong** markers.
+ */
+export declare function discussionPlainText(text: string): string;
 /**
  * An answer with its blank lines dropped.
  *
@@ -228,6 +264,22 @@ export declare function discussionOverlapping(discussions: readonly Discussion[]
  * @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;
+/**
+ * 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): 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/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;
@@ -50,10 +56,14 @@ export declare const zh: {
     'panel.quickSummon': string;
     'panel.commentMode': string;
     'panel.commentModeDesc': string;
+    'panel.discussionRounds': string;
+    'panel.discussionRoundsDesc': string;
     'panel.quickSummonDesc': string;
     'panel.recordShortcut': string;
     'settings.keybindings': string;
     'settings.keybindingsDesc': string;
+    'settings.comment': string;
+    'settings.commentDesc': string;
     'settings.diffView': string;
     'settings.diffViewDesc': string;
     'settings.diffPreview': string;
@@ -89,14 +99,12 @@ export declare const zh: {
     'action.discussionExpand': string;
     'action.discussionCollapse': string;
     'discussion.placeholder': string;
-    'discussion.placeholderOutdated': string;
     'discussion.marker': string;
     'discussion.promptRule': string;
     'discussion.promptRuleSkill': string;
     'discussion.thinking': string;
     'discussion.queued': string;
-    'discussion.outdated': string;
-    'discussion.quote': string;
+    'discussion.outdatedQuote': string;
     'discussion.hidden': string;
     'discussion.failed': string;
     'discussion.stopped': string;
@@ -106,6 +114,7 @@ export declare const zh: {
     'action.keepAll': string;
     'action.revertAll': string;
     'action.openFile': string;
+    'action.pathField': string;
     'action.revealFile': string;
     'action.busy': string;
     'action.prevDiff': string;
@@ -226,6 +235,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;
@@ -265,10 +280,14 @@ export declare const en: {
     'panel.quickSummon': string;
     'panel.commentMode': string;
     'panel.commentModeDesc': string;
+    'panel.discussionRounds': string;
+    'panel.discussionRoundsDesc': string;
     'panel.quickSummonDesc': string;
     'panel.recordShortcut': string;
     'settings.keybindings': string;
     'settings.keybindingsDesc': string;
+    'settings.comment': string;
+    'settings.commentDesc': string;
     'settings.diffView': string;
     'settings.diffViewDesc': string;
     'settings.diffPreview': string;
@@ -304,14 +323,12 @@ export declare const en: {
     'action.discussionExpand': string;
     'action.discussionCollapse': string;
     'discussion.placeholder': string;
-    'discussion.placeholderOutdated': string;
     'discussion.marker': string;
     'discussion.promptRule': string;
     'discussion.promptRuleSkill': string;
     'discussion.thinking': string;
     'discussion.queued': string;
-    'discussion.outdated': string;
-    'discussion.quote': string;
+    'discussion.outdatedQuote': string;
     'discussion.hidden': string;
     'discussion.failed': string;
     'discussion.stopped': string;
@@ -321,6 +338,7 @@ export declare const en: {
     'action.keepAll': string;
     'action.revertAll': string;
     'action.openFile': string;
+    'action.pathField': string;
     'action.revealFile': string;
     'action.busy': string;
     'action.prevDiff': 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.

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

@@ -30,8 +30,11 @@ export interface DiffApprovalPort {
     refreshVcs(sessionId: SessionId, id: string, includeUntracked: boolean): Promise<DiffApprovalRefreshValue>;
     /** List one workspace directory level (workspace-relative; `''` is the root). */
     browse(sessionId: SessionId, path?: string): Promise<DiffApprovalBrowseValue>;
-    /** Add one named path (a file, or a directory's whole subtree) to the list. */
-    addPath(sessionId: SessionId, path: string, includeUnchanged: boolean): Promise<DiffApprovalAddValue>;
+    /**
+     * Add one named path (a file, or a directory's whole subtree) to the list. With `exact`, the
+     * path must be one regular file: a directory is refused instead of being scanned.
+     */
+    addPath(sessionId: SessionId, path: string, includeUnchanged: boolean, exact?: boolean): Promise<DiffApprovalAddValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open(sessionId: SessionId, id: string, action: DiffApprovalOpenAction): Promise<DiffApprovalOpenValue>;
     /** Keep every pending entry of one session in a single host call (one batch). */

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

@@ -20,6 +20,12 @@ export interface DiffApprovalCover {
  *  composer. */
 export declare const FLOAT_COVER_DEFAULT: DiffApprovalCover;
 /** Default lead rows above a jumped-to diff block (kept small and bounded). */
+/** Rounds of a comment thread a block keeps before it hides the older ones. A round is one
+ *  question and the answer to it. One is the floor (something has to be visible) and the
+ *  ceiling keeps a long thread from swamping the diff it annotates. */
+export declare const DISCUSSION_ROUNDS_DEFAULT = 2;
+export declare const DISCUSSION_ROUNDS_MIN = 1;
+export declare const DISCUSSION_ROUNDS_MAX = 10;
 export declare const NAV_LEAD_ROWS_DEFAULT = 2;
 export declare const NAV_LEAD_ROWS_MIN = 0;
 export declare const NAV_LEAD_ROWS_MAX = 10;
@@ -227,6 +233,13 @@ export declare function setMdMaxWidth(value: number): void;
  * @returns the lead row count.
  */
 export declare function navLeadRows(): number;
+/**
+ * How many rounds of a comment thread the panel keeps.
+ * @returns the configured round count, or the default when nothing valid is stored.
+ */
+export declare function discussionRoundLimit(): number;
+/** Persist the comment thread's round limit. */
+export declare function setDiscussionRoundLimit(value: number): void;
 /** Persist the block-jump lead row count. */
 export declare function setNavLeadRows(value: number): void;
 /** Default quick-summon chord (toggle the review panel open/closed). */

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

@@ -90,7 +90,7 @@ export interface PendingPanelFace {
     /** List one workspace directory level for the add-path dialog. */
     onBrowse: (sessionId: SessionId, path?: string) => Promise<DiffApprovalBrowseValue>;
     /** Add one named path (a file, or a directory's whole subtree) to the list. */
-    onAddPath: (sessionId: SessionId, path: string, includeUnchanged: boolean) => Promise<DiffApprovalAddValue>;
+    onAddPath: (sessionId: SessionId, path: string, includeUnchanged: boolean, exact?: boolean) => Promise<DiffApprovalAddValue>;
     /** Keep every pending entry of one session in a single host call (bulk). */
     onKeepAll: (sessionId: SessionId) => Promise<void>;
     /** Revert every pending entry of one session in a single host call (bulk). */

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

@@ -34,7 +34,7 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     /** List one workspace directory level for the add-path dialog. */
     browse: (sessionId: SessionId, path?: string) => Promise<DiffApprovalBrowseValue>;
     /** Add one named path to the list, then refresh; resolves to what the scan did. */
-    addPath: (sessionId: SessionId, path: string, includeUnchanged: boolean) => Promise<DiffApprovalAddValue>;
+    addPath: (sessionId: SessionId, path: string, includeUnchanged: boolean, exact?: boolean) => Promise<DiffApprovalAddValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
     /** Keep every pending entry of one session in a single host call, then refresh. */

package/lib/types/types.d.ts

@@ -188,6 +188,11 @@ export type DiffApprovalAddOutcome =
  | 'empty'
 /** The path does not exist (or is neither a file nor a directory). */
  | 'missing'
+/**
+ * The caller named one exact file and the path is a directory. Refused before anything is
+ * scanned, so a mistyped path cannot add a whole subtree.
+ */
+ | 'not-a-file'
 /** The path lies outside the session's workspace. */
  | 'outside'
 /** The workspace is not inside a git/svn/p4 checkout. */
@@ -201,6 +206,12 @@ export interface DiffApprovalAddValue {
     added: number;
     /** How many scanned paths were already listed (left untouched). */
     duplicates: number;
+    /**
+     * The entry a single-file add landed as (the one already listed, for a duplicate). Absent
+     * for a directory add, which is about many files. It is what lets a caller that named one
+     * path select the file without waiting for the next list poll.
+     */
+    id?: string | undefined;
     /** Whether the no-change walk hit its file cap, so some files were not added. */
     truncated?: boolean | undefined;
     /** Failure detail for `outcome: 'failed'`. */

package/package.json

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