dsh-diff-approval 0.3.0 → 0.5.0

package/lib/index.js

@@ -236,6 +236,29 @@ var PendingPersistence = class {
 		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
 	}
 	/**
+	* Load every session's entries for one workspace, oldest capture first.
+	* The list shows a workspace's pending changes across sessions — a session
+	* that restarted carries a fresh id while its earlier entries sit under the
+	* original session ids in the same workspace file — so hydration reads the
+	* whole workspace, not one session.
+	* @param workspaceId - the owning workspace's stable id.
+	* @returns the persisted entries across all sessions; empty when none were saved.
+	*/
+	async loadWorkspace(workspaceId) {
+		const envelope = await this.readWorkspace(this.fileOf(workspaceId));
+		if (envelope === void 0) return [];
+		const entries = [];
+		for (const sessionId of Object.keys(envelope.sessions)) {
+			const rows = envelope.sessions[sessionId];
+			if (!Array.isArray(rows)) continue;
+			for (const row of rows) {
+				const entry = pendingEntryOf(row);
+				if (entry !== void 0) entries.push(entry);
+			}
+		}
+		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
+	}
+	/**
 	* Replace one session's entries durably. Saves to one file are serialized;
 	* a previous save's failure does not block the next one.
 	* @param workspaceId - the owning workspace's stable id.
@@ -348,9 +371,10 @@ function defaultOpenPath(path, action) {
 * ```
 *
 * Pending entries persist per (workspace, session) so an unhandled operation
-* survives a harness restart; the list endpoint re-reads the live file, so a
-* change or deletion made after the tracked operation is reported after
-* restart exactly as it is mid-session.
+* survives a harness restart; the list endpoint hydrates the whole workspace
+* and merges every registered session's entries, so a fresh session after a
+* restart still reports the earlier sessions' pending changes, live-verified
+* exactly as it is mid-session.
 *
 * @module dsh-diff-approval
 */
@@ -460,8 +484,11 @@ function apply(ctx, config) {
 	const store = new PendingDiffStore();
 	const persistence = new PendingPersistence(resolve(expandHomePath(storageDir ?? defaultStorageDir())));
 	const launchPath = config?.openPath ?? defaultOpenPath;
-	const loaded = /* @__PURE__ */ new Set();
-	const loading = /* @__PURE__ */ new Map();
+	/** Sessions seen per workspace, so the list can merge a workspace's sessions. */
+	const sessionsByWorkspace = /* @__PURE__ */ new Map();
+	/** Workspace ids whose persisted state has been hydrated into the store. */
+	const loadedWorkspaces = /* @__PURE__ */ new Set();
+	const loadingWorkspaces = /* @__PURE__ */ new Map();
 	/** Pre-write bases captured at the intent seams, keyed by the tool call id. */
 	const editorIntents = /* @__PURE__ */ new Map();
 	/**
@@ -602,31 +629,94 @@ function apply(ctx, config) {
 		for (const workspace of ctx.workspaceRegistry.list()) if (workspace.sessionIds.includes(sessionId)) return workspace;
 	}
 	/**
-	* Merge one session's persisted entries into the store, once per session.
-	* Concurrent callers share the in-flight load, and folds arriving while the
-	* load runs stay safe: `hydrate` never overwrites a live entry.
-	* @param sessionId - the session to hydrate.
-	* @returns resolution after the session's persisted state is merged (or skipped).
+	* Record one session in its workspace's account. Every path that touches a
+	* session registers it, so the list merges all of a workspace's sessions'
+	* entries — a fresh session after restart still sees the workspace's
+	* persisted pending changes.
+	* @param sessionId - the session to register.
+	* @returns the owning workspace, or `undefined` when none accounts it.
 	*/
-	function ensureLoaded(sessionId) {
-		const key = String(sessionId);
-		if (loaded.has(key)) return Promise.resolve();
-		const pending = loading.get(key);
+	function registerSession(sessionId) {
+		const workspace = workspaceOf(sessionId);
+		if (workspace === void 0) return void 0;
+		const key = String(workspace.id);
+		const sessions = sessionsByWorkspace.get(key);
+		if (sessions === void 0) sessionsByWorkspace.set(key, /* @__PURE__ */ new Set([String(sessionId)]));
+		else sessions.add(String(sessionId));
+		return workspace;
+	}
+	/**
+	* Merge one workspace's persisted entries into the store, once per
+	* workspace. Hydration is workspace-scoped: after a restart the current
+	* session has a fresh id while the persisted entries live under their
+	* original session ids in the same workspace file, so the whole workspace
+	* is loaded and every persisted session is accounted. Concurrent callers
+	* share the in-flight load, and folds arriving while the load runs stay
+	* safe: `hydrate` never overwrites a live entry.
+	* @param workspace - the workspace whose persisted state to merge.
+	* @returns resolution after the workspace's persisted state is merged (or skipped).
+	*/
+	function ensureWorkspaceLoaded(workspace) {
+		const key = String(workspace.id);
+		if (loadedWorkspaces.has(key)) return Promise.resolve();
+		const pending = loadingWorkspaces.get(key);
 		if (pending !== void 0) return pending;
 		const task = (async () => {
-			const workspace = workspaceOf(sessionId);
-			if (workspace !== void 0) try {
-				store.hydrate(sessionId, await persistence.load(String(workspace.id), key));
+			try {
+				const persisted = await persistence.loadWorkspace(key);
+				const bySession = /* @__PURE__ */ new Map();
+				for (const entry of persisted) {
+					const sessionKey = String(entry.sessionId);
+					const group = bySession.get(sessionKey);
+					if (group === void 0) bySession.set(sessionKey, [entry]);
+					else group.push(entry);
+				}
+				for (const [sessionKey, entries] of bySession) {
+					const sessions = sessionsByWorkspace.get(key) ?? /* @__PURE__ */ new Set();
+					sessions.add(sessionKey);
+					sessionsByWorkspace.set(key, sessions);
+					store.hydrate(SessionId(sessionKey), entries);
+				}
 			} catch (error) {
-				ctx.logger.warn(`diff-approval: loading persisted state for session ${key} failed: ${errorMessage(error)}`);
+				ctx.logger.warn(`diff-approval: loading persisted state for workspace ${key} failed: ${errorMessage(error)}`);
 			}
-			loaded.add(key);
-			loading.delete(key);
+			loadedWorkspaces.add(key);
+			loadingWorkspaces.delete(key);
 		})();
-		loading.set(key, task);
+		loadingWorkspaces.set(key, task);
 		return task;
 	}
 	/**
+	* Merge the session's workspace's persisted state into the store (a session
+	* with no workspace is the memory-only edge and has nothing to load).
+	* @param sessionId - the session to hydrate for.
+	* @returns resolution after the workspace's persisted state is merged.
+	*/
+	function ensureLoaded(sessionId) {
+		const workspace = registerSession(sessionId);
+		if (workspace === void 0) return Promise.resolve();
+		return ensureWorkspaceLoaded(workspace);
+	}
+	/**
+	* All entries visible to one session: every registered session of its
+	* workspace, merged oldest capture first. This is what makes an unhandled
+	* change survive a restart — the new session lists the workspace's whole
+	* pending set, its own live folds plus the earlier sessions' persisted
+	* entries.
+	* @param sessionId - the viewing session.
+	* @returns the merged entries; a session with no workspace lists only itself.
+	*/
+	async function workspaceEntries(sessionId) {
+		await ensureLoaded(sessionId);
+		const workspace = workspaceOf(sessionId);
+		if (workspace === void 0) return store.list(sessionId);
+		const sessions = sessionsByWorkspace.get(String(workspace.id));
+		if (sessions === void 0) return store.list(sessionId);
+		const entries = [];
+		for (const sessionKey of sessions) entries.push(...store.list(SessionId(sessionKey)));
+		return entries.sort((left, right) => left.updatedAt - right.updatedAt);
+	}
+	/**
 	* Mirror one session's entries to disk. A write fault logs a warning and
 	* leaves the in-memory view intact: the review flow must not break on a
 	* storage fault, and the next successful mutation rewrites the whole file.
@@ -668,10 +758,9 @@ function apply(ctx, config) {
 			case "list": {
 				const sessionId = sessionOf(payload);
 				if (sessionId === void 0) return rpcError("sessionId must be a non-empty string");
-				await ensureLoaded(sessionId);
 				return {
 					ok: true,
-					value: { files: await listWithState(store.list(sessionId)) }
+					value: { files: await listWithState(await workspaceEntries(sessionId)) }
 				};
 			}
 			case "keep": {

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

@@ -15,6 +15,18 @@ export interface HighlightSpan {
     text: string;
     style: CSSProperties;
 }
+/**
+ * Primary grammar ids offered in the viewer's language selector, in picker
+ * order (alphabetical). Kept explicit instead of deriving from `LANGS`: some
+ * `@shikijs/langs` modules are composite grammars whose `.name` arrays expose
+ * embedded sub-grammars (e.g. C++ → `[regexp, glsl, cpp-macro, cpp]`,
+ * TypeScript → `[typescript, jsx, tsx, graphql]`), which would otherwise leak
+ * ids like `regexp`, `glsl`, `haml` into the menu. `LANGS` still registers the
+ * full grammars (including their embedded languages) for highlighting.
+ */
+export declare const HIGHLIGHT_LANGS: string[];
+/** Conventional display name for a grammar id, falling back to the id itself. */
+export declare function languageDisplayName(id: string): string;
 /**
  * Tokenize `code` into per-line highlighted runs when `lang` names a
  * registered grammar; `undefined` means the caller renders its plain fallback.

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

@@ -24,8 +24,14 @@ export declare const zh: {
     'action.busy': string;
     'action.prevDiff': string;
     'action.nextDiff': string;
-    'action.copyRange': string;
+    'action.copyHint': string;
     'action.copied': string;
+    'action.langAuto': string;
+    'action.langAutoDetected': string;
+    'action.langSelect': string;
+    'action.expand': string;
+    'action.exitFullscreen': string;
+    'action.close': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;
@@ -62,8 +68,14 @@ export declare const en: {
     'action.busy': string;
     'action.prevDiff': string;
     'action.nextDiff': string;
-    'action.copyRange': string;
+    'action.copyHint': string;
     'action.copied': string;
+    'action.langAuto': string;
+    'action.langAutoDetected': string;
+    'action.langSelect': string;
+    'action.expand': string;
+    'action.exitFullscreen': string;
+    'action.close': string;
     'status.kept': string;
     'status.reverted': string;
     'status.missing': string;

package/lib/types/index.d.ts

@@ -26,9 +26,10 @@
  * ```
  *
  * Pending entries persist per (workspace, session) so an unhandled operation
- * survives a harness restart; the list endpoint re-reads the live file, so a
- * change or deletion made after the tracked operation is reported after
- * restart exactly as it is mid-session.
+ * survives a harness restart; the list endpoint hydrates the whole workspace
+ * and merges every registered session's entries, so a fresh session after a
+ * restart still reports the earlier sessions' pending changes, live-verified
+ * exactly as it is mid-session.
  *
  * @module dsh-diff-approval
  */

package/lib/types/persist.d.ts

@@ -37,6 +37,16 @@ export declare class PendingPersistence {
      * @returns the persisted entries; empty when none were saved.
      */
     load(workspaceId: string, sessionId: string): Promise<PendingEntry[]>;
+    /**
+     * Load every session's entries for one workspace, oldest capture first.
+     * The list shows a workspace's pending changes across sessions — a session
+     * that restarted carries a fresh id while its earlier entries sit under the
+     * original session ids in the same workspace file — so hydration reads the
+     * whole workspace, not one session.
+     * @param workspaceId - the owning workspace's stable id.
+     * @returns the persisted entries across all sessions; empty when none were saved.
+     */
+    loadWorkspace(workspaceId: string): Promise<PendingEntry[]>;
     /**
      * Replace one session's entries durably. Saves to one file are serialized;
      * a previous save's failure does not block the next one.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "dsh-diff-approval",
-  "version": "0.3.0",
+  "version": "0.5.0",
   "description": "DeepSeek Harness plugin: pending-edit review with whole-file diff and Keep/Revert",
   "packageManager": "pnpm@11.21.0",
   "author": "Wu Zhiwei",
@@ -31,7 +31,8 @@
     "lib/index.js",
     "lib/client.js",
     "lib/types/**/*.d.ts",
-    "cordis.patch.yml"
+    "cordis.patch.yml",
+    "docs/images/**"
   ],
   "dsh": {
     "bundle": {