dsh-diff-approval 0.25.0 → 0.26.0

package/lib/index.js

@@ -3029,6 +3029,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 +3107,6 @@ function apply(ctx, config) {
 						}
 					};
 				}
-				const now = Date.now();
 				const candidates = changes.map((change) => ({
 					id: change.path,
 					sessionId: target.sessionId,
@@ -3101,22 +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";
-				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

@@ -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

@@ -264,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;
@@ -98,8 +104,7 @@ export declare const zh: {
     '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;
@@ -230,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;
@@ -317,8 +328,7 @@ export declare const en: {
     '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;

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/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.25.0",
+  "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",