dsh-diff-approval 0.8.0 → 0.10.0

package/lib/index.js

@@ -864,9 +864,16 @@ function apply(ctx, config) {
 		await ensureLoaded(sessionId);
 		if (store.fold(entry)) await persistSession(sessionId);
 	}
+	/** The stable `FsError.code`, when the thrown value carries one. */
+	function fsErrorCodeOf(error) {
+		if (typeof error !== "object" || error === null) return void 0;
+		const code = error.code;
+		return typeof code === "string" ? code : void 0;
+	}
 	/**
-	* Read one path's live state: present content, an unresolvable (missing)
-	* path, or a resolved-but-unreadable file.
+	* Read one path's live state. The only existence test is `stat`: it returns
+	* `undefined` for an absent target (gone), so a deleted file never falls into
+	* the unreadable bucket. A file that exists but cannot be read is `unavailable`.
 	* @param path - backend display path to probe through `ctx.fs`.
 	* @returns the live state.
 	*/
@@ -874,22 +881,23 @@ function apply(ctx, config) {
 		let target;
 		try {
 			target = await ctx.fs.resolve(path, {});
-		} catch {
-			return {
-				present: false,
-				kind: "missing"
-			};
+		} catch (error) {
+			return fsErrorCodeOf(error) === "FS_NOT_FOUND" ? { kind: "deleted" } : { kind: "unavailable" };
+		}
+		let info;
+		try {
+			info = await ctx.fs.stat(target, void 0);
+		} catch (error) {
+			return fsErrorCodeOf(error) === "FS_NOT_FOUND" ? { kind: "deleted" } : { kind: "unavailable" };
 		}
+		if (info === void 0) return { kind: "deleted" };
 		try {
 			return {
-				present: true,
+				kind: "present",
 				content: await ctx.fs.readText(target, void 0)
 			};
-		} catch {
-			return {
-				present: false,
-				kind: "unreadable"
-			};
+		} catch (error) {
+			return fsErrorCodeOf(error) === "FS_NOT_FOUND" ? { kind: "deleted" } : { kind: "unavailable" };
 		}
 	}
 	/**
@@ -898,7 +906,32 @@ function apply(ctx, config) {
 	* @param entries - the store's entries for one session.
 	* @returns entries with `missing` and `diverged` set from the live file.
 	*/
-	async function listWithState(entries) {
+	/** Drop every undo/redo pair that belongs to a removed entry, so the LIFO
+	* queue stays traversable without ever trying to restore an unreadable file. */
+	function purgeForEntry(sessionId, entryId, path) {
+		const key = String(sessionId);
+		for (const stacks of [undoStacks, redoStacks]) {
+			const stack = stacks.get(key);
+			if (stack === void 0) continue;
+			stacks.set(key, stack.filter((pair) => {
+				const touches = (state) => state.id === entryId || state.path === path;
+				const batch = pair.before.batch ?? pair.after.batch;
+				if (batch !== void 0) return !batch.some((item) => item.id === entryId || item.path === path);
+				return !touches(pair.before) && !touches(pair.after);
+			}));
+		}
+	}
+	/**
+	* Settle each listed entry against its live file. Existence is decided by the
+	* live state alone: a deleted file leaves the list as an undoable checkpoint
+	* (Ctrl+Z recreates it and restores the entry), an unavailable one leaves the
+	* list and has its undo/redo records dropped, and externally changed content
+	* is adopted as the new baseline with its own checkpoint.
+	* @param sessionId - the session being listed.
+	* @param entries - the store's entries for one session.
+	* @returns the listed entries plus whether an external change cleared redo.
+	*/
+	async function listWithState(sessionId, entries) {
 		const byPath = /* @__PURE__ */ new Map();
 		for (const entry of entries) {
 			const group = byPath.get(entry.path);
@@ -906,21 +939,62 @@ function apply(ctx, config) {
 			else group.push(entry);
 		}
 		const listed = [];
+		let redoCleared = false;
 		for (const group of byPath.values()) {
 			const newest = group[group.length - 1];
 			if (newest === void 0) continue;
 			const live = await liveStateOf(newest.path);
+			if (live.kind === "deleted") {
+				store.remove(sessionId, newest.id);
+				pushUndo(sessionId, {
+					id: newest.id,
+					path: newest.path,
+					entry: newest,
+					fileText: newest.newText
+				}, {
+					id: newest.id,
+					path: newest.path,
+					entry: void 0,
+					fileText: void 0
+				});
+				await persistSession(sessionId);
+				continue;
+			}
+			if (live.kind === "unavailable") {
+				store.remove(sessionId, newest.id);
+				purgeForEntry(sessionId, newest.id, newest.path);
+				await persistSession(sessionId);
+				continue;
+			}
+			const content = live.content;
 			let adopted = newest.newText;
-			if (live.present && typeof live.content === "string" && live.content !== newest.newText) {
-				adopted = live.content;
-				if (store.update(newest.sessionId, newest.id, { newText: live.content })) await persistSession(newest.sessionId);
+			const hasContent = typeof content === "string";
+			if (hasContent && content !== newest.newText) {
+				adopted = content;
+				const beforeText = newest.newText;
+				const redoWasPresent = redoStacks.has(String(sessionId));
+				store.update(sessionId, newest.id, { newText: content });
+				pushUndo(sessionId, {
+					id: newest.id,
+					path: newest.path,
+					entry: newest,
+					fileText: beforeText
+				}, {
+					id: newest.id,
+					path: newest.path,
+					entry: {
+						...newest,
+						newText: content,
+						updatedAt: Date.now()
+					},
+					fileText: content
+				});
+				await persistSession(sessionId);
+				if (redoWasPresent) redoCleared = true;
 			}
-			const state = live.present ? {
+			const state = {
 				missing: false,
-				diverged: live.content !== adopted
-			} : {
-				missing: live.kind === "missing",
-				diverged: live.kind === "unreadable"
+				diverged: hasContent ? content !== adopted : true
 			};
 			for (const entry of group) listed.push(entry.id === newest.id ? {
 				...entry,
@@ -931,7 +1005,10 @@ function apply(ctx, config) {
 				...state
 			});
 		}
-		return listed;
+		return {
+			files: listed,
+			redoCleared
+		};
 	}
 	/**
 	* The workspace whose session account holds `sessionId`. Web sessions are
@@ -1146,11 +1223,13 @@ function apply(ctx, config) {
 			case "list": {
 				const sessionId = sessionOf(payload);
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
+				const { files, redoCleared } = await listWithState(sessionId, await workspaceEntries(sessionId));
 				return {
 					ok: true,
 					value: {
-						files: await listWithState(await workspaceEntries(sessionId)),
-						workspacePath: workspaceOf(sessionId)?.path
+						files,
+						workspacePath: workspaceOf(sessionId)?.path,
+						redoCleared: redoCleared || void 0
 					}
 				};
 			}

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

@@ -1,6 +1,7 @@
 /** Sidebar-foot pending-edit review action and the split review panel it opens. */
 import type { InjectFace, PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots';
 import type { PendingPanelFace } from './slots.ts';
+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'>;
 /**
@@ -14,4 +15,4 @@ export type PendingPanelProps = PropsRuntime<'sidebar.footer.action'> & InjectFa
  */
 export declare function openSettingsSection(sectionLabel: string): void;
 /** 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, t, }: PendingPanelProps): import("react").JSX.Element;
+export declare function PendingPanel({ wide, useSessions, usePending, onRefresh, onKeep, onRevert, onBlockKeep, onBlockRevert, onOpen, onPasteReference, onUndo, onRedo, onImportVcs, onAckRedoCleared, t, }: PendingPanelProps): import("react").JSX.Element;

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

@@ -3,9 +3,10 @@ import type { PropsLocale, PropsRuntime } from '@deepseek-ai/dsh-client-ui-slots
 /** Full component props assembled by the Settings slot renderer. */
 export type DiffApprovalSettingsTabProps = PropsRuntime<'settings.section'> & PropsLocale<'diff-approval'>;
 /**
- * The plugin's preferences: auto-paste a copied reference into the input, and
- * whether importing workspace VCS changes includes untracked files. Each row
- * mirrors the harness's Agent-preset row (title + description on the left, a
- * pill picker on the right) with the two boolean states 打开 / 关闭.
+ * The plugin's preferences: auto-paste a copied reference into the input,
+ * whether importing workspace VCS changes includes untracked files, and the
+ * diff's tab width. Each row mirrors the harness's Agent-preset row (title +
+ * description on the left, a pill picker on the right); the tab-width row
+ * offers 2 / 4 / 8 spaces.
  */
 export declare function DiffApprovalSettingsTab({ t }: DiffApprovalSettingsTabProps): import("react").JSX.Element;

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

@@ -15,11 +15,15 @@ export declare const zh: {
     'panel.searchPlaceholder': string;
     'panel.missing': string;
     'panel.missingHint': string;
+    'panel.externalChanged': string;
+    'panel.dismiss': string;
     'panel.createHint': string;
     'panel.pasteOnCopy': string;
     'panel.pasteOnCopyDesc': string;
     'panel.importUntracked': string;
     'panel.importUntrackedDesc': string;
+    'panel.tabWidth': string;
+    'panel.tabWidthDesc': string;
     'settings.tabLabel': string;
     'row.create': string;
     'row.failed': string;
@@ -34,11 +38,14 @@ export declare const zh: {
     'action.busy': string;
     'action.prevDiff': string;
     'action.nextDiff': string;
+    'action.showFileList': string;
+    'action.hideFileList': string;
     'action.copyHint': string;
     'action.copied': string;
     'action.langAuto': string;
     'action.langAutoDetected': string;
     'action.langSelect': string;
+    'action.wrap': string;
     'action.toggleOn': string;
     'action.toggleOff': string;
     'action.importVcs': string;
@@ -79,11 +86,15 @@ export declare const en: {
     'panel.searchPlaceholder': string;
     'panel.missing': string;
     'panel.missingHint': string;
+    'panel.externalChanged': string;
+    'panel.dismiss': string;
     'panel.createHint': string;
     'panel.pasteOnCopy': string;
     'panel.pasteOnCopyDesc': string;
     'panel.importUntracked': string;
     'panel.importUntrackedDesc': string;
+    'panel.tabWidth': string;
+    'panel.tabWidthDesc': string;
     'settings.tabLabel': string;
     'row.create': string;
     'row.failed': string;
@@ -98,11 +109,14 @@ export declare const en: {
     'action.busy': string;
     'action.prevDiff': string;
     'action.nextDiff': string;
+    'action.showFileList': string;
+    'action.hideFileList': string;
     'action.copyHint': string;
     'action.copied': string;
     'action.langAuto': string;
     'action.langAutoDetected': string;
     'action.langSelect': string;
+    'action.wrap': string;
     'action.toggleOn': string;
     'action.toggleOff': string;
     'action.importVcs': string;

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

@@ -17,3 +17,22 @@ export declare function setPasteOnCopyEnabled(value: boolean): void;
 export declare function includeUntrackedEnabled(): boolean;
 /** Persist the import-untracked preference. */
 export declare function setIncludeUntrackedEnabled(value: boolean): void;
+/**
+ * Whether lines wrap (auto-wrap) in the diff for one highlight language.
+ * Defaults to off; only an explicit `'1'` enables it. Stored per language, so
+ * a language's preference never leaks into another's.
+ * @param lang - the highlight language (or `''` for the auto/default bucket).
+ * @returns whether lines wrap.
+ */
+export declare function wrapEnabled(lang: string): boolean;
+/** Persist the per-language auto-wrap preference. */
+export declare function setWrapEnabled(lang: string, value: boolean): void;
+/**
+ * The diff's tab width in spaces. Defaults to 4; the settings UI offers 2/4/8,
+ * but any positive integer is accepted. This drives both the rendered
+ * `tab-size` and the wrapped-line tab measurement, so they always agree.
+ * @returns the number of spaces one tab advances.
+ */
+export declare function tabWidth(): number;
+/** Persist the diff's tab width (in spaces). */
+export declare function setTabWidth(value: number): void;

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

@@ -16,6 +16,10 @@ export interface PendingDiffSnapshot {
     failed?: ReadonlyMap<string, string> | undefined;
     /** The viewing session's workspace root (when it has one); enables workspace-relative references. */
     workspacePath?: string | undefined;
+    /** Latched when an external change created a fresh undo checkpoint that
+     * superseded the redo history; the panel surfaces it once (deferred if the
+     * panel is closed) via a bottom-right notice. */
+    redoCleared?: boolean;
 }
 /** The injected face the panel component receives from the plugin body. */
 export interface PendingPanelFace {
@@ -43,4 +47,6 @@ export interface PendingPanelFace {
     onRedo: (sessionId: SessionId) => Promise<string | undefined>;
     /** Import the workspace's local VCS changes as pending entries (detection included). */
     onImportVcs: (sessionId: SessionId, includeUntracked: boolean) => Promise<VcsImportValue>;
+    /** Acknowledge the redo-cleared notice so it is only surfaced once. */
+    onAckRedoCleared: () => void;
 }

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

@@ -32,6 +32,8 @@ export interface PendingDiffStore extends HostObservable<PendingDiffSnapshot> {
     open: (sessionId: SessionId, id: string, action: DiffApprovalOpenAction) => Promise<void>;
     /** Drop every local fact (used on connection reset). */
     reset: () => void;
+    /** Acknowledge a redo-cleared notice so the panel surfaces it only once. */
+    clearRedoCleared: () => void;
 }
 /**
  * Create the store over the review-channel port.

package/lib/types/types.d.ts

@@ -53,6 +53,10 @@ export interface DiffApprovalListValue {
     files: PendingFileDiff[];
     /** The viewing session's workspace root (when it has one), for workspace-relative references. */
     workspacePath?: string | undefined;
+    /** Set when a detected external change created a fresh undo checkpoint while
+     * redo history was pending, so the panel can surface that the redo stack was
+     * superseded. */
+    redoCleared?: boolean | undefined;
 }
 /** What the open endpoint asks the OS to do with a file. */
 export type DiffApprovalOpenAction = 'open' | 'reveal';

package/package.json

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