dsh-diff-approval 0.5.0 → 0.7.0

package/lib/index.js

@@ -108,6 +108,28 @@ var PendingDiffStore = class {
 		for (const [key, indexedId] of this.pathIndex) if (indexedId === id) this.pathIndex.delete(key);
 		return true;
 	}
+	/**
+	* Advance one entry's tracked content after a block-level keep/revert. The
+	* entry keeps its id and path; only the given side's text and capture time
+	* move. When the caller decides the sides now match, it removes the entry
+	* instead of updating it.
+	* @param sessionId - the owning session.
+	* @param id - the entry id.
+	* @param patch - the side to advance (`oldText` for keep, `newText` for revert).
+	* @returns whether the entry changed.
+	*/
+	update(sessionId, id, patch) {
+		const key = entryKey(sessionId, id);
+		const entry = this.entries.get(key);
+		if (entry === void 0) return false;
+		const next = {
+			...entry,
+			...patch,
+			updatedAt: Date.now()
+		};
+		this.entries.set(key, next);
+		return true;
+	}
 	/** Total entry count across all sessions. */
 	get size() {
 		return this.entries.size;
@@ -760,7 +782,10 @@ function apply(ctx, config) {
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
 				return {
 					ok: true,
-					value: { files: await listWithState(await workspaceEntries(sessionId)) }
+					value: {
+						files: await listWithState(await workspaceEntries(sessionId)),
+						workspacePath: workspaceOf(sessionId)?.path
+					}
 				};
 			}
 			case "keep": {
@@ -797,6 +822,51 @@ function apply(ctx, config) {
 					value: { outcome: "reverted" }
 				};
 			}
+			case "block-keep": {
+				const blockTarget = blockTargetOf(payload);
+				if (blockTarget === void 0) return rpcError("sessionId, id, and block must be valid");
+				await ensureLoaded(blockTarget.sessionId);
+				const entry = store.get(blockTarget.sessionId, blockTarget.id);
+				if (entry === void 0) return {
+					ok: true,
+					value: { outcome: "missing" }
+				};
+				const accepted = contentRangeOf(entry.newText, blockTarget.block.newStart, blockTarget.block.newEnd);
+				const updatedOld = replaceContentLines(entry.oldText, blockTarget.block.oldStart, blockTarget.block.oldEnd, accepted);
+				if (updatedOld === entry.newText) store.remove(blockTarget.sessionId, blockTarget.id);
+				else store.update(blockTarget.sessionId, blockTarget.id, { oldText: updatedOld });
+				await persistSession(blockTarget.sessionId);
+				return {
+					ok: true,
+					value: { outcome: "kept" }
+				};
+			}
+			case "block-revert": {
+				const blockTarget = blockTargetOf(payload);
+				if (blockTarget === void 0) return rpcError("sessionId, id, and block must be valid");
+				await ensureLoaded(blockTarget.sessionId);
+				const entry = store.get(blockTarget.sessionId, blockTarget.id);
+				if (entry === void 0) return {
+					ok: true,
+					value: { outcome: "missing" }
+				};
+				const restored = contentRangeOf(entry.oldText, blockTarget.block.oldStart, blockTarget.block.oldEnd);
+				const updatedNew = replaceContentLines(entry.newText, blockTarget.block.newStart, blockTarget.block.newEnd, restored);
+				try {
+					const resolved = await ctx.fs.resolve(entry.path, { signal });
+					if (entry.kind === "create" && updatedNew === "") await rm(ctx.fs.processPath(resolved), { force: true });
+					else await ctx.fs.writeText(resolved, updatedNew, void 0, signal);
+				} catch (error) {
+					return rpcError(`block revert failed: ${errorMessage(error)}`);
+				}
+				if (updatedNew === entry.oldText) store.remove(blockTarget.sessionId, blockTarget.id);
+				else store.update(blockTarget.sessionId, blockTarget.id, { newText: updatedNew });
+				await persistSession(blockTarget.sessionId);
+				return {
+					ok: true,
+					value: { outcome: "reverted" }
+				};
+			}
 			case "open": {
 				const target = openTargetOf(payload);
 				if (target === void 0) return rpcError("sessionId, id, and action must be valid");
@@ -836,6 +906,73 @@ function sessionOf(payload) {
 	const value = payload.sessionId;
 	return typeof value === "string" && value.length > 0 ? SessionId(value) : void 0;
 }
+/** The content lines of `text`, matching the diff's line numbering (a single
+trailing newline is a terminator, not an extra empty line). */
+function contentLinesOf(text) {
+	if (text === "") return [];
+	const lines = text.split("\n");
+	if (lines[lines.length - 1] === "") lines.pop();
+	return lines;
+}
+/** Rebuild text from content lines, keeping `original`'s trailing-newline convention. */
+function fromContentLines(original, lines) {
+	if (lines.length === 0) return "";
+	return lines.join("\n") + (original.endsWith("\n") ? "\n" : "");
+}
+/** The content lines [start..end] (1-based inclusive) of `text`; empty when start > end. */
+function contentRangeOf(text, start, end) {
+	if (start > end) return [];
+	return contentLinesOf(text).slice(start - 1, end);
+}
+/**
+* Replace the content lines [start..end] (1-based) of `text` with `replacement`
+* lines. An empty range (`start > end`) inserts before line `start`. Out-of-range
+* bounds clamp; the trailing-newline convention of `text` is preserved.
+*/
+function replaceContentLines(text, start, end, replacement) {
+	const lines = contentLinesOf(text);
+	const count = lines.length;
+	if (start > end) {
+		const at = Math.min(Math.max(start, 1), count + 1);
+		return fromContentLines(text, [
+			...lines.slice(0, at - 1),
+			...replacement,
+			...lines.slice(at - 1)
+		]);
+	}
+	const s = Math.min(Math.max(start, 1), count + 1);
+	const e = Math.min(Math.max(end, 1), count);
+	if (s > e) return text;
+	return fromContentLines(text, [
+		...lines.slice(0, s - 1),
+		...replacement,
+		...lines.slice(e)
+	]);
+}
+/** Narrow a wire payload to one block keep/revert target. */
+function blockTargetOf(payload) {
+	const target = targetOf(payload);
+	if (target === void 0) return void 0;
+	if (typeof payload !== "object" || payload === null || Array.isArray(payload)) return void 0;
+	const block = payload.block;
+	if (typeof block !== "object" || block === null || Array.isArray(block)) return void 0;
+	const { oldStart, oldEnd, newStart, newEnd } = block;
+	if (![
+		oldStart,
+		oldEnd,
+		newStart,
+		newEnd
+	].every((value) => typeof value === "number" && Number.isFinite(value))) return void 0;
+	return {
+		...target,
+		block: {
+			oldStart,
+			oldEnd,
+			newStart,
+			newEnd
+		}
+	};
+}
 /** Narrow a wire payload to one keep/revert target. */
 function targetOf(payload) {
 	const sessionId = sessionOf(payload);

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

@@ -4,4 +4,4 @@ import type { PendingPanelFace } from './slots.ts';
 /** Full panel props composed by the sidebar footer-action slot. */
 export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFace<PendingPanelFace> & PropsLocale<'diff-approval'>;
 /** Render the pending-edit review panel and its unified footer action. */
-export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onOpen, t, }: PendingPanelProps): import("react").JSX.Element;
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, t, }: PendingPanelProps): import("react").JSX.Element;

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

@@ -10,7 +10,9 @@ export declare const zh: {
     'panel.group.others': string;
     'panel.aria': string;
     'panel.stats': string;
+    'panel.blockPosition': string;
     'panel.selectHint': string;
+    'panel.searchPlaceholder': string;
     'panel.missing': string;
     'panel.missingHint': string;
     'panel.createHint': string;
@@ -29,6 +31,7 @@ export declare const zh: {
     'action.langAuto': string;
     'action.langAutoDetected': string;
     'action.langSelect': string;
+    'action.search': string;
     'action.expand': string;
     'action.exitFullscreen': string;
     'action.close': string;
@@ -54,7 +57,9 @@ export declare const en: {
     'panel.group.others': string;
     'panel.aria': string;
     'panel.stats': string;
+    'panel.blockPosition': string;
     'panel.selectHint': string;
+    'panel.searchPlaceholder': string;
     'panel.missing': string;
     'panel.missingHint': string;
     'panel.createHint': string;
@@ -73,6 +78,7 @@ export declare const en: {
     'action.langAuto': string;
     'action.langAutoDetected': string;
     'action.langSelect': string;
+    'action.search': string;
     'action.expand': string;
     'action.exitFullscreen': string;
     'action.close': string;

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

@@ -5,17 +5,21 @@
  * @module dsh-diff-approval/client/port
  */
 import type { ClientConnectionRpc, SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { DiffApprovalActionValue, DiffApprovalOpenAction, DiffApprovalOpenValue, PendingFileDiff } from '../types.ts';
+import type { DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue } from '../types.ts';
 /** The channel the host half registers and this port calls. */
 export declare const DIFF_APPROVAL_CHANNEL = "/diff-approval";
 /** This package's business verbs over the review channel. */
 export interface DiffApprovalPort {
-    /** Read one session's pending entries, oldest capture first. */
-    list(sessionId: SessionId): Promise<PendingFileDiff[]>;
+    /** Read one session's pending entries (plus its workspace root), oldest capture first. */
+    list(sessionId: SessionId): Promise<DiffApprovalListValue>;
     /** Keep one operation. */
     keep(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
     /** Revert one operation. */
     revert(sessionId: SessionId, id: string): Promise<DiffApprovalActionValue>;
+    /** Keep one diff block (accept its change into the tracked baseline). */
+    blockKeep(sessionId: SessionId, id: string, block: DiffApprovalBlockRange): Promise<DiffApprovalActionValue>;
+    /** Revert one diff block (restore its old lines in the file). */
+    blockRevert(sessionId: SessionId, id: string, block: DiffApprovalBlockRange): Promise<DiffApprovalActionValue>;
     /** Open one file with its default application or reveal it in the folder. */
     open(sessionId: SessionId, id: string, action: DiffApprovalOpenAction): Promise<DiffApprovalOpenValue>;
 }

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

@@ -1,10 +1,10 @@
 /**
- * Reference labels for the selection toolbar: a file name plus a 1-based line
- * range, using the short name when unambiguous and the full path otherwise.
- * Pure derivation so the display rule is unit-testable without the panel.
+ * Reference labels for the selection toolbar: a workspace-relative path (or
+ * the absolute path when the file is outside the workspace) plus a 1-based
+ * line range. Pure derivation so the display rule is unit-testable without
+ * the panel.
  * @module dsh-diff-approval/client/reference
  */
-import type { PendingFileDiff } from '../types.ts';
 /**
  * Last path segment of a file path, any separator style.
  * @param path - the path to shorten.
@@ -12,13 +12,15 @@ import type { PendingFileDiff } from '../types.ts';
  */
 export declare function basenameOf(path: string): string;
 /**
- * The path shown in a copied reference: the short name when no other listed
- * file shares it, the full path otherwise.
+ * The path embedded in a copied reference: workspace-relative (forward
+ * slashes) when the file lives inside the current workspace, the absolute
+ * path otherwise. A bare file name is never enough — a reference must resolve
+ * to exactly one file.
  * @param path - the selected file's path.
- * @param files - every currently listed pending file.
- * @returns the display path for a copied reference.
+ * @param workspacePath - the current workspace root, or `undefined`.
+ * @returns the reference path.
  */
-export declare function copyDisplayPath(path: string, files: readonly PendingFileDiff[]): string;
+export declare function referencePathOf(path: string, workspacePath: string | undefined): string;
 /**
  * Format one line range as a reference suffix: a single line number, or the
  * inclusive range when the selection spans more than one line.
@@ -30,9 +32,9 @@ export declare function lineRangeLabel(start: number, end: number): string;
 /**
  * Build the clipboard text for a selected line range.
  * @param path - the selected file's path.
- * @param files - every currently listed pending file.
+ * @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.
  */
-export declare function referenceOf(path: string, files: readonly PendingFileDiff[], start: number, end: number): string;
+export declare function referenceOf(path: string, workspacePath: string | undefined, start: number, end: number): string;

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

@@ -1,7 +1,7 @@
 /** The panel's injected business face and its observable snapshot. */
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
-import type { DiffApprovalOpenAction, PendingFileDiff } from '../types.ts';
+import type { DiffApprovalBlockRange, DiffApprovalOpenAction, PendingFileDiff } from '../types.ts';
 /** What the panel reads and drives: the pending list plus in-flight entries. */
 export interface PendingDiffSnapshot {
     /** Whether a list read has completed at least once. */
@@ -12,6 +12,8 @@ export interface PendingDiffSnapshot {
     error?: string;
     /** Entry ids whose keep/revert is in flight; their controls are disabled. */
     busy: ReadonlySet<string>;
+    /** The viewing session's workspace root (when it has one); enables workspace-relative references. */
+    workspacePath?: string | undefined;
 }
 /** The injected face the panel component receives from the plugin body. */
 export interface PendingPanelFace {
@@ -25,6 +27,10 @@ export interface PendingPanelFace {
     onKeep: (sessionId: SessionId, id: string) => Promise<void>;
     /** Revert one operation (restore its prior content, or remove a created file). */
     onRevert: (sessionId: SessionId, id: string) => Promise<void>;
+    /** Keep one diff block (accept its change into the tracked baseline). */
+    onBlockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
+    /** Revert one diff block (restore its old lines in the file). */
+    onBlockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
     /** Open one file with its default application or reveal it in the folder. */
     onOpen: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
 }

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

@@ -7,7 +7,7 @@
  */
 import type { SessionId } from '@deepseek-ai/dsh-client-connection/client';
 import type { HostObservable } from '@deepseek-ai/dsh-client-ui-slots';
-import type { DiffApprovalOpenAction } from '../types.ts';
+import type { DiffApprovalBlockRange, DiffApprovalOpenAction } from '../types.ts';
 import type { PendingDiffSnapshot } from './slots.ts';
 import type { DiffApprovalPort } from './port.ts';
 /** The observable the panel reads and the plugin body drives. */
@@ -18,6 +18,10 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     keep: (sessionId: SessionId, id: string) => Promise<void>;
     /** Revert one operation. */
     revert: (sessionId: SessionId, id: string) => Promise<void>;
+    /** Keep one diff block, then refresh so the entry's diff reflects the accept. */
+    blockKeep: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
+    /** Revert one diff block, then refresh so the entry's diff reflects the undo. */
+    blockRevert: (sessionId: SessionId, id: string, block: DiffApprovalBlockRange) => Promise<void>;
     /** Open one file with its default application or reveal it in the folder. */
     open: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
     /** Drop every local fact (used on connection reset). */

package/lib/types/index.d.ts

@@ -35,7 +35,7 @@
  */
 import { Context } from '@deepseek-ai/cordis';
 import type { DiffApprovalOpenAction } from './types.ts';
-export type { DiffApprovalActionOutcome, DiffApprovalActionValue, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, PendingEntry, PendingEntryKind, PendingFileDiff, } from './types.ts';
+export type { DiffApprovalActionOutcome, DiffApprovalActionValue, DiffApprovalBlockRange, DiffApprovalBlockTarget, DiffApprovalListValue, DiffApprovalOpenAction, DiffApprovalOpenValue, PendingEntry, PendingEntryKind, PendingFileDiff, } from './types.ts';
 export { PendingDiffStore } from './pending.ts';
 export { PendingPersistence, defaultStorageDir } from './persist.ts';
 export { defaultOpenPath } from './open.ts';

package/lib/types/pending.d.ts

@@ -55,6 +55,20 @@ export declare class PendingDiffStore {
      * @returns whether an entry was removed.
      */
     remove(sessionId: SessionId, id: string): boolean;
+    /**
+     * Advance one entry's tracked content after a block-level keep/revert. The
+     * entry keeps its id and path; only the given side's text and capture time
+     * move. When the caller decides the sides now match, it removes the entry
+     * instead of updating it.
+     * @param sessionId - the owning session.
+     * @param id - the entry id.
+     * @param patch - the side to advance (`oldText` for keep, `newText` for revert).
+     * @returns whether the entry changed.
+     */
+    update(sessionId: SessionId, id: string, patch: {
+        oldText?: string;
+        newText?: string;
+    }): boolean;
     /** Total entry count across all sessions. */
     get size(): number;
 }

package/lib/types/types.d.ts

@@ -51,6 +51,8 @@ export interface PendingFileDiff extends PendingEntry {
 export interface DiffApprovalListValue {
     /** Pending entries for the requested session, oldest capture first. */
     files: PendingFileDiff[];
+    /** The viewing session's workspace root (when it has one), for workspace-relative references. */
+    workspacePath?: string | undefined;
 }
 /** What the open endpoint asks the OS to do with a file. */
 export type DiffApprovalOpenAction = 'open' | 'reveal';
@@ -59,6 +61,27 @@ export interface DiffApprovalOpenValue {
     /** What the request did; `missing` means no pending entry existed. */
     outcome: 'opened' | 'missing';
 }
+/**
+ * One diff block's line ranges on the old and new sides, 1-based inclusive.
+ * A side is empty when its start exceeds its end; an empty side's start is
+ * the insertion point (the line before which content inserts) on that side.
+ */
+export interface DiffApprovalBlockRange {
+    /** First old-file line this block spans; the insertion point for pure additions. */
+    oldStart: number;
+    /** Last old-file line; `oldStart - 1` when the block has no old side. */
+    oldEnd: number;
+    /** First new-file line this block spans; the insertion point for pure deletions. */
+    newStart: number;
+    /** Last new-file line; `newStart - 1` when the block has no new side. */
+    newEnd: number;
+}
+/** Target of one block-level keep/revert: the entry plus the block range. */
+export interface DiffApprovalBlockTarget {
+    sessionId: SessionId;
+    id: string;
+    block: DiffApprovalBlockRange;
+}
 /** Outcome of one keep/revert request. */
 export type DiffApprovalActionOutcome = 'kept' | 'reverted' | 'missing';
 /** Value returned by the channel's keep and revert endpoints. */

package/package.json

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