dsh-diff-approval 0.11.0 → 0.13.0

package/lib/index.js

@@ -1343,18 +1343,12 @@ function apply(ctx, config) {
 				};
 				const accepted = contentRangeOf(entry.newText, blockTarget.block.newStart, blockTarget.block.newEnd);
 				const updatedOld = replaceContentLines(entry.oldText, blockTarget.block.oldStart, blockTarget.block.oldEnd, accepted);
-				let afterEntry;
-				if (updatedOld === entry.newText) {
-					store.remove(blockTarget.sessionId, blockTarget.id);
-					afterEntry = void 0;
-				} else {
-					store.update(blockTarget.sessionId, blockTarget.id, { oldText: updatedOld });
-					afterEntry = {
-						...entry,
-						oldText: updatedOld,
-						updatedAt: Date.now()
-					};
-				}
+				store.update(blockTarget.sessionId, blockTarget.id, { oldText: updatedOld });
+				const afterEntry = {
+					...entry,
+					oldText: updatedOld,
+					updatedAt: Date.now()
+				};
 				pushUndo(blockTarget.sessionId, {
 					id: entry.id,
 					path: entry.path,
@@ -1369,7 +1363,10 @@ function apply(ctx, config) {
 				await persistSession(blockTarget.sessionId);
 				return {
 					ok: true,
-					value: { outcome: "kept" }
+					value: updatedOld === entry.newText ? {
+						outcome: "kept",
+						resolved: true
+					} : { outcome: "kept" }
 				};
 			}
 			case "block-revert": {
@@ -1384,25 +1381,19 @@ function apply(ctx, config) {
 				const restored = contentRangeOf(entry.oldText, blockTarget.block.oldStart, blockTarget.block.oldEnd);
 				const updatedNew = replaceContentLines(entry.newText, blockTarget.block.newStart, blockTarget.block.newEnd, restored);
 				const content = reencodeEol(updatedNew, detectEol(entry.newText));
-				let afterEntry;
-				if (normalizeEol(updatedNew) === normalizeEol(entry.oldText)) {
-					store.remove(blockTarget.sessionId, blockTarget.id);
-					afterEntry = void 0;
-				} else {
-					store.update(blockTarget.sessionId, blockTarget.id, { newText: content });
-					afterEntry = {
-						...entry,
-						newText: content,
-						updatedAt: Date.now()
-					};
-				}
+				store.update(blockTarget.sessionId, blockTarget.id, { newText: content });
+				const afterEntry = {
+					...entry,
+					newText: content,
+					updatedAt: Date.now()
+				};
 				let undo;
 				try {
-					const resolved = await ctx.fs.resolve(entry.path, { signal });
-					if (entry.kind === "create" && content === "") await rm(ctx.fs.processPath(resolved), { force: true });
+					const target = await ctx.fs.resolve(entry.path, { signal });
+					if (entry.kind === "create" && content === "") await rm(ctx.fs.processPath(target), { force: true });
 					else {
-						const preWrite = await ctx.fs.readText(resolved, void 0) ?? entry.newText;
-						await writeRevert(resolved, content, blockTarget.sessionId, signal);
+						const preWrite = await ctx.fs.readText(target, void 0) ?? entry.newText;
+						await writeRevert(target, content, blockTarget.sessionId, signal);
 						undo = {
 							before: {
 								id: entry.id,
@@ -1425,7 +1416,10 @@ function apply(ctx, config) {
 				await persistSession(blockTarget.sessionId);
 				return {
 					ok: true,
-					value: { outcome: "reverted" }
+					value: normalizeEol(updatedNew) === normalizeEol(entry.oldText) ? {
+						outcome: "reverted",
+						resolved: true
+					} : { outcome: "reverted" }
 				};
 			}
 			case "undo": {

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

@@ -1,9 +1,20 @@
 /** Sidebar-foot pending-edit review action and the split review panel it opens. */
+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 { DiffApprovalKey } from './locales.ts';
+import { computeWholeFileDiff } from './whole-file-diff.ts';
+import { highlightLines } from './highlight.ts';
+/** The dsh shell's sidebar auto-collapse breakpoint (ui-layout columns.ts):
+ * below it the sidebar auto-collapses, and the file list floats on the same
+ * 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[];
 /** Full panel props composed by the sidebar footer-action slot. */
 export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'>;
+/** Locale translator used by the panel and its rows. */
+type Translator = (key: DiffApprovalKey, params?: Record<string, unknown>) => string;
 /**
  * Open the DSH settings dialog and switch to this plugin's section. The
  * settings shell keeps its open state and the active section id as
@@ -14,5 +25,40 @@ export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFa
  * @param sectionLabel - the nav label of this plugin's settings section.
  */
 export declare function openSettingsSection(sectionLabel: string): void;
+/** One file's synchronous view: diff rows and change blocks. */
+interface RowModel {
+    diff: ReturnType<typeof computeWholeFileDiff>;
+    /** Maximal runs of changed rows (inclusive row indices); one per modification. */
+    blocks: ChangeBlock[];
+}
+/** One file's deferred syntax-highlight runs, one entry per side. */
+interface HighlightRuns {
+    oldRuns: ReturnType<typeof highlightLines>;
+    newRuns: ReturnType<typeof highlightLines>;
+}
+/** One contiguous run of changed rows, treated as a single modification. */
+interface ChangeBlock {
+    start: number;
+    end: number;
+}
+/** Imperative surface the parent uses to drive block navigation from the
+ *  shared toolbar/keyboard in split mode (its own `focus` is private here). */
+export interface SplitDiffHandle {
+    jump: (direction: -1 | 1) => void;
+    openSearch: () => void;
+}
+/** The two-column (side-by-side) whole-file diff view. */
+export declare const SplitDiff: import("react").ForwardRefExoticComponent<{
+    file: PendingFileDiff;
+    model: RowModel;
+    runs: HighlightRuns | undefined;
+    langWrap: boolean;
+    tabWidthSpaces: number;
+    busy: boolean;
+    t: Translator;
+    onBlockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
+    onBlockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
+} & import("react").RefAttributes<SplitDiffHandle>>;
 /** Render the pending-edit review panel and its unified footer action. */
-export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPasteReference, onUndo, onRedo, onImportVcs, onAckRedoCleared, t, }: PendingPanelProps): import("react").JSX.Element;
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPasteReference, onUndo, onRedo, onImportVcs, onAckRedoCleared, onAckJustResolved, collapseSidebar, t, }: PendingPanelProps): import("react").JSX.Element;
+export {};

package/lib/types/client/conversation-access.d.ts

@@ -0,0 +1,67 @@
+/**
+ * Scope-addressed access to the session's composer draft and pending queue.
+ * Extracted from the plugin entry so the wiring (not just the remap math) is
+ * unit-testable against a faithful fake of the DSH conversation service.
+ * @module dsh-diff-approval/client/conversation-access
+ */
+import type { ClientContext } from '@deepseek-ai/dsh-client-runtime/client';
+import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
+/** One queued message's minimal shape read from the session input state. */
+export interface QueueMessageView {
+    id: string;
+    placement: 'queued' | 'steering' | 'context';
+    content: readonly {
+        type: string;
+        text?: string;
+    }[];
+}
+/** The conversation service slice the reference remap addresses through a session scope. */
+export interface ConversationFace {
+    input: {
+        for(actx: ClientContext): {
+            setDraft(text: string): void;
+            state: {
+                getSnapshot(): {
+                    queue: readonly QueueMessageView[];
+                };
+            };
+        };
+    };
+    updateQueue(itemId: string, action: {
+        kind: 'edit';
+        content: readonly {
+            type: string;
+            text?: string;
+        }[];
+    }): Promise<void>;
+}
+/**
+ * Resolve the current session's scoped conversation face. The scoped context
+ * (`sessions.scope(id)`) carries no `conversation` inject of its own, so reading
+ * it as a property (`actx.conversation`) trips Cordis's inject check and throws
+ * `cannot get property "conversation" without inject`. `actx.get('conversation')`
+ * bypasses that check yet still returns the traceable bound to `actx`, so its
+ * verbs (e.g. `updateQueue`) resolve the right session scope.
+ */
+export declare function resolveConversation(ctx: ClientContext, sessionId: SessionId | undefined): {
+    actx: ClientContext;
+    conversation: ConversationFace;
+} | undefined;
+/** Draft/queue verbs bound to the current session, resolved lazily per call. */
+export interface ConversationAccess {
+    /** Write the current session's composer draft. */
+    writeDraft: (text: string) => void;
+    /** Read the current session's still-queued messages (queued placement only). */
+    readQueue: () => readonly QueueMessageView[];
+    /** Apply an edit mutation to one queued message's full content. */
+    writeQueue: (itemId: string, content: readonly {
+        type: string;
+        text?: string;
+    }[]) => void;
+}
+/**
+ * Build the per-call-resolved draft/queue accessor. `sessionId` is a function
+ * so the accessor always addresses the *current* session, even though it is
+ * handed to the remap sync once.
+ */
+export declare function conversationAccess(ctx: ClientContext, sessionId: () => SessionId | undefined): ConversationAccess;

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

@@ -4,7 +4,8 @@ export type { PendingPanelProps } from './PendingPanel.tsx';
 export type { PendingDiffSnapshot, PendingPanelFace } from './slots.ts';
 export type { DiffApprovalKey } from './locales.ts';
 export { DIFF_APPROVAL_CHANNEL } from './port.ts';
-/** Required services: locale, slots, the wire channel, and the current session. */
+/** Required services: locale, slots, the wire channel, the current session, and
+ * the layout controller (this plugin collapses the sidebar before its modal opens). */
 export declare const inject: string[];
 /**
  * Mount the pending-edit review panel.

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

@@ -24,9 +24,15 @@ export declare const zh: {
     'panel.importUntrackedDesc': string;
     'panel.tabWidth': string;
     'panel.tabWidthDesc': string;
+    'panel.splitMode': string;
+    'panel.splitModeDesc': string;
+    'panel.quickSummon': string;
+    'panel.quickSummonDesc': string;
+    'panel.recordShortcut': string;
     'settings.tabLabel': string;
     'row.create': string;
     'row.failed': string;
+    'row.dismiss': string;
     'row.added': string;
     'row.removed': string;
     'action.keep': string;
@@ -62,6 +68,8 @@ export declare const zh: {
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
+    'panel.resolvedAsk': string;
+    'panel.keepInList': string;
 };
 /** Translation keys owned by the pending-edit review namespace. */
 export type DiffApprovalKey = keyof typeof zh;
@@ -95,9 +103,15 @@ export declare const en: {
     'panel.importUntrackedDesc': string;
     'panel.tabWidth': string;
     'panel.tabWidthDesc': string;
+    'panel.splitMode': string;
+    'panel.splitModeDesc': string;
+    'panel.quickSummon': string;
+    'panel.quickSummonDesc': string;
+    'panel.recordShortcut': string;
     'settings.tabLabel': string;
     'row.create': string;
     'row.failed': string;
+    'row.dismiss': string;
     'row.added': string;
     'row.removed': string;
     'action.keep': string;
@@ -133,4 +147,6 @@ export declare const en: {
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
+    'panel.resolvedAsk': string;
+    'panel.keepInList': string;
 };

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

@@ -5,6 +5,8 @@
  * the panel.
  * @module dsh-diff-approval/client/reference
  */
+/** The marker that replaces a reference's line number when its lines are gone. */
+export declare const LINE_MISSING_LABEL = "LINE_MISSING";
 /**
  * Last path segment of a file path, any separator style.
  * @param path - the path to shorten.
@@ -30,11 +32,39 @@ export declare function referencePathOf(path: string, workspacePath: string | un
  */
 export declare function lineRangeLabel(start: number, end: number): string;
 /**
- * Build the clipboard text for a selected line range.
+ * Build the clipboard text for a selected line range, wrapped in parentheses so
+ * the reference reads as one unambiguous token (and can be matched precisely).
  * @param path - the selected file's path.
  * @param workspacePath - the current workspace root, or `undefined`.
  * @param start - first selected line number.
  * @param end - last selected line number.
- * @returns the `path:range` reference text.
+ * @returns the `(path:range)` reference text.
  */
 export declare function referenceOf(path: string, workspacePath: string | undefined, start: number, end: number): string;
+/**
+ * Map one referenced line range from `oldContent` coordinates to `newContent`
+ * coordinates. Lines that survive (unchanged context) map to their new line
+ * numbers, and the surviving lines' min/max span is returned. When every line
+ * in the range was removed, returns `undefined` (the reference is expired).
+ * @param oldContent - the file content the reference was made against.
+ * @param newContent - the file content now.
+ * @param start - first referenced line (1-based, inclusive).
+ * @param end - last referenced line (1-based, inclusive).
+ * @returns the surviving range, or `undefined` when nothing survives.
+ */
+export declare function remapReferenceRange(oldContent: string, newContent: string, start: number, end: number): {
+    start: number;
+    end: number;
+} | undefined;
+/**
+ * Rewrite every `(referencePath:line)` / `(referencePath:start-end)` occurrence
+ * in `text`, remapping each range from `oldContent` to `newContent`. A range
+ * whose lines all survived becomes the new range; one whose lines were all
+ * removed becomes `(referencePath:LINE_MISSING)`.
+ * @param text - the free text (composer draft, queued message) to rewrite.
+ * @param referencePath - the file's reference path (workspace-relative or absolute).
+ * @param oldContent - the file content the references were made against.
+ * @param newContent - the file content now.
+ * @returns the rewritten text.
+ */
+export declare function remapReferences(text: string, referencePath: string, oldContent: string, newContent: string): string;

package/lib/types/client/remap-sync.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Reference remapping sync: track each pending file's last-seen content and,
+ * when it changes (an agent edit, a block revert, or an external adoption),
+ * rewrite stale references in the current composer draft and the pending queue.
+ * Pure orchestration over the pending store; the actual line remapping lives in
+ * `reference.ts`.
+ * @module dsh-diff-approval/client/remap-sync
+ */
+import type { PendingDiffStore } from './store.ts';
+/** One queued message's minimal content block; text blocks carry `text`, and every other kind passes through verbatim. */
+interface QueueBlock {
+    type: string;
+    text?: string;
+}
+/** A queued message's minimal shape for reference remapping. */
+interface QueueMessage {
+    id: string;
+    content: readonly QueueBlock[];
+}
+/** One remapping sync's inputs; `readDraft`/`writeDraft` address the current composer. */
+export interface ReferenceRemapOpts {
+    store: PendingDiffStore;
+    /** Read the current composer draft text (undefined when there is none). */
+    readDraft: () => string | undefined;
+    /** Write the current composer draft text. */
+    writeDraft: (text: string) => void;
+    /** Read the current session's still-queued messages (full content blocks). */
+    readQueue: () => readonly QueueMessage[];
+    /** Apply an edit mutation to one queued message's full content. */
+    writeQueue: (itemId: string, content: readonly QueueBlock[]) => void;
+}
+/**
+ * Subscribe to the pending store and remap references as each file's content
+ * changes. The first observation of a file only seeds the baseline; a later
+ * `newText` change remaps (draft + queue) and advances the baseline. Files that
+ * leave the list drop their baseline so a future re-appearance re-baselines.
+ * @param opts - the sync inputs.
+ * @returns an unsubscribe function plus a direct remap verb for whole-file reverts.
+ */
+export declare function attachReferenceRemap(opts: ReferenceRemapOpts): {
+    unsubscribe: () => void;
+    remapFile: (path: string, oldText: string, newText: string) => void;
+};
+export {};

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

@@ -36,3 +36,32 @@ export declare function setWrapEnabled(lang: string, value: boolean): void;
 export declare function tabWidth(): number;
 /** Persist the diff's tab width (in spaces). */
 export declare function setTabWidth(value: number): void;
+/**
+ * Whether the whole-file diff view uses the two-column (side-by-side) layout.
+ * Default off (single column): the unified diff. Only an explicit `'1'` enables
+ * split mode.
+ * @returns whether the split (two-column) diff view is used.
+ */
+export declare function splitMode(): boolean;
+/** Persist the split-view preference. */
+export declare function setSplitMode(value: boolean): void;
+/** Default quick-summon chord (toggle the review panel open/closed). */
+export declare const DEFAULT_QUICK_SUMMON = "Ctrl+D";
+/**
+ * The quick-summon chord. Stored as `Modifier+...+Key`; falls back to
+ * {@link DEFAULT_QUICK_SUMMON}.
+ * @returns the chord string.
+ */
+export declare function quickSummonKey(): string;
+/** Persist the quick-summon chord. */
+export declare function setQuickSummonKey(value: string): void;
+/**
+ * Whether a keyboard event matches a chord string like `Ctrl+D`. Modifier
+ * names are matched case-insensitively (`Ctrl`/`Control`, `Alt`/`Option`,
+ * `Shift`, `Meta`/`Cmd`/`Command`/`Win`); the final part is the key. Exact
+ * modifier set is required (extra modifiers do not match).
+ * @param event - the keydown event.
+ * @param shortcut - the chord string.
+ * @returns whether the event matches.
+ */
+export declare function matchesShortcut(event: KeyboardEvent, shortcut: string): boolean;

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

@@ -20,6 +20,9 @@ export interface PendingDiffSnapshot {
      * superseded the redo history; the panel surfaces it once (deferred if the
      * panel is closed) via a bottom-right notice. */
     redoCleared?: boolean;
+    /** Latched file id whose last block just resolved; the panel prompts once to
+     * remove-or-keep it, then acknowledges to clear the latch. */
+    justResolved?: string | undefined;
 }
 /** The injected face the panel component receives from the plugin body. */
 export interface PendingPanelFace {
@@ -49,4 +52,9 @@ export interface PendingPanelFace {
     onImportVcs: (sessionId: SessionId, includeUntracked: boolean) => Promise<VcsImportValue>;
     /** Acknowledge the redo-cleared notice so it is only surfaced once. */
     onAckRedoCleared: () => void;
+    /** Acknowledge the just-resolved prompt so it is only surfaced once. */
+    onAckJustResolved: () => void;
+    /** Collapse the DSH sidebar (no-op when already collapsed) before the modal
+     * opens or fullscreens, so an expanded sidebar can't overlap the modal. */
+    collapseSidebar: () => void;
 }

package/lib/types/client/split-diff.d.ts

@@ -0,0 +1,51 @@
+/**
+ * Side-by-side (split) diff model: the unified whole-file diff rows are
+ * regrouped into line-aligned pairs for a two-column "before | current" view.
+ * Pure derivation; the view owns rendering. A context row becomes a pair with
+ * both sides, a deletion a left-only pair, an addition a right-only pair, and
+ * an adjacent deletion/addition run is paired line-by-line into a single
+ * replacement pair so the two columns line up.
+ * @module dsh-diff-approval/client/split-diff
+ */
+import type { WholeFileDiffRow } from './whole-file-diff.ts';
+/** One side of a split pair: text plus its 1-based line number (absent on a pure add). */
+export interface SplitSide {
+    /** The side's source line content, without the terminating newline. */
+    text: string;
+    /** 1-based line number on this side, or undefined. */
+    line: number | undefined;
+}
+/** One aligned left/right pair of the split view. */
+export interface SplitPair {
+    /** What the pair is: unchanged, deleted (left only), added (right only), or a replaced line. */
+    kind: 'context' | 'del' | 'add' | 'replace';
+    /** The old (left) side; absent on a pure addition. */
+    left: SplitSide | undefined;
+    /** The new (right) side; absent on a pure deletion. */
+    right: SplitSide | undefined;
+}
+/** The derived split view: aligned pairs plus the row→pair index map. */
+export interface SplitDiff {
+    /** Aligned pairs in file order. */
+    pairs: SplitPair[];
+    /** Original whole-file row index → pair index, so block ranges keep working. */
+    pairOfRow: ReadonlyMap<number, number>;
+}
+/**
+ * Regroup the whole-file rows into aligned split pairs, pairing a deletion run
+ * with a following addition run line-by-line (so a replaced line is one pair),
+ * and leaving a stray deletion or addition as a one-sided pair.
+ * @param rows - the whole-file diff rows.
+ * @returns the split pairs plus the row→pair index map.
+ */
+export declare function computeSideBySideDiff(rows: readonly WholeFileDiffRow[]): SplitDiff;
+/**
+ * Pair indices whose left or right text contains the query (case-insensitive).
+ * A pair counts once however many times the query appears, so split search
+ * highlights the whole pair on both columns and a single "current" pair is
+ * stepped through — not each individual left/right occurrence.
+ * @param pairs - the split pairs.
+ * @param query - the query text; an empty query matches nothing.
+ * @returns matching pair indices, in file order.
+ */
+export declare function searchPairs(pairs: readonly SplitPair[], query: string): number[];

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

@@ -34,6 +34,8 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     reset: () => void;
     /** Acknowledge a redo-cleared notice so the panel surfaces it only once. */
     clearRedoCleared: () => void;
+    /** Acknowledge the just-resolved prompt so it is only surfaced once. */
+    clearJustResolved: () => void;
 }
 /**
  * Create the store over the review-channel port.

package/lib/types/types.d.ts

@@ -103,4 +103,7 @@ export interface DiffApprovalActionValue {
     outcome: DiffApprovalActionOutcome;
     /** Entry id the undo/redo affected; absent for a no-op or a non-undo action. */
     id?: string | undefined;
+    /** Set when a block keep/revert just cleared the entry's last remaining
+     * block (the entry stays listed with no pending diff). */
+    resolved?: boolean | undefined;
 }

package/package.json

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