dsh-diff-approval 0.13.1 → 0.14.0

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

@@ -44,8 +44,12 @@ export declare function referenceOf(path: string, workspacePath: string | undefi
 /**
  * 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).
+ * numbers, and a line whose content changed in place (a delete replaced by an
+ * add at the same logical position) maps to that position's new line — its text
+ * changed, but the line is not gone. Only a line that is genuinely removed
+ * (a delete with no replacement) is omitted. The surviving lines' min/max span
+ * is returned; when every line in the range is gone, 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).
@@ -59,8 +63,9 @@ export declare function remapReferenceRange(oldContent: string, newContent: stri
 /**
  * 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)`.
+ * whose lines all survived (unchanged context or an in-place edit) becomes the
+ * new range; one whose lines were all genuinely 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.

package/lib/types/pending.d.ts

@@ -1,10 +1,11 @@
 /**
- * In-memory pending-diff store: one entry per (session, path), holding the
- * file's full set of unhandled changes as one cumulative span. Every later
- * operation to a tracked path folds into its entry — `oldText` stays the
- * earliest basis, `newText` takes the latest content — even when the chain
- * breaks (an outside writer changed the file between operations): the list
- * still shows one element per file. Pure state and transitions; the plugin
+ * In-memory pending-diff store: one entry per file path, globally, holding the
+ * file's full set of unhandled changes as one cumulative span (earliest basis →
+ * latest content) across every session and workspace that touched it. Every
+ * later operation to a tracked path folds into its entry — `oldText` stays the
+ * earliest basis, `newText` takes the latest content, and the touching sessions
+ * accumulate in `sessionIds` — even when the chain breaks (an outside writer
+ * changed the file between operations). Pure state and transitions; the plugin
  * body owns the `tools/result` observation, the RPC surface, and the
  * filesystem I/O.
  * @module dsh-diff-approval/src/pending
@@ -12,75 +13,74 @@
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 import type { PendingEntry } from './types.ts';
 /**
- * The pending-diff store. Keep/Revert decides one whole file at a time.
+ * The pending-diff store: one entry per file path across all sessions. Keep /
+ * Revert decides one whole file at a time.
  */
 export declare class PendingDiffStore {
     private readonly entries;
-    private readonly pathIndex;
-    /** Merge one operation into the store, keyed by (session, path). */
-    private merge;
     /**
-     * Fold one captured operation into its file's entry. A no-op (equal before
+     * Merge one captured operation into its file's entry. A no-op (equal before
      * and after) folds nothing.
      * @param entry - the captured operation (id assigned by the caller).
      * @returns whether the stored entry changed.
      */
     fold(entry: PendingEntry): boolean;
+    /** Fold a captured entry into the path's single global entry. */
+    private merge;
     /**
-     * Merge persisted entries into the store, one per path after folding. An
-     * already-keyed live entry wins over a persisted one: the live entry is
-     * newer by construction (it was captured after the persisted state was
-     * written), so the path's whole persisted run is skipped.
-     * @param sessionId - the session the entries belong to.
-     * @param entries - persisted entries, oldest capture first, to fold in.
+     * Combine a stored entry and a new capture. `oldText` comes from the earlier
+     * capture (the file's original basis), `newText` from the later (latest
+     * content), and the session set is the union — so the entry always spans the
+     * whole pending change regardless of which session contributed which part.
      */
-    hydrate(sessionId: SessionId, entries: readonly PendingEntry[]): void;
+    private mergeEntry;
     /**
-     * Copy the session's entries, oldest capture first.
-     * @param sessionId - the session whose entries to list.
+     * Copy every entry touching a session (the session's view), oldest capture
+     * first. The file list is session-scoped: an entry appears for each session
+     * that touched it, so a session only sees files it worked on.
+     * @param sessionId - the viewing session.
      * @returns detached entries in capture order.
      */
     list(sessionId: SessionId): PendingEntry[];
+    /** Every entry (all paths, all sessions), oldest capture first. */
+    all(): PendingEntry[];
     /**
-     * Read one entry without removing it.
-     * @param sessionId - the owning session.
-     * @param id - the entry id.
-     * @returns the entry, or `undefined` when the pair has none.
+     * Read one path's entry without removing it.
+     * @param path - the file path (the global entry key).
+     * @returns the entry, or `undefined` when none is tracked.
      */
-    get(sessionId: SessionId, id: string): PendingEntry | undefined;
+    get(path: string): PendingEntry | undefined;
     /**
-     * Remove one entry.
-     * @param sessionId - the owning session.
-     * @param id - the entry id.
+     * Remove one path's entry.
+     * @param path - the file path.
      * @returns whether an entry was removed.
      */
-    remove(sessionId: SessionId, id: string): boolean;
+    remove(path: 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.
+     * entry keeps its path; only the given side's text and capture time move.
+     * @param path - the file path.
      * @param patch - the side to advance (`oldText` for keep, `newText` for revert).
      * @returns whether the entry changed.
      */
-    update(sessionId: SessionId, id: string, patch: {
+    update(path: string, patch: {
         oldText?: string;
         newText?: string;
     }): boolean;
     /**
      * Restore one entry exactly as given (an undo/redo replays a snapshot). The
-     * entry is inserted or replaced by id, and the path index points at it so a
-     * later capture folds into the restored entry. The store keeps one entry per
-     * path: restoring an entry for a path that a DIFFERENT entry currently owns
-     * drops that occupant first, so an undo can never leave two list items for
-     * the same file (e.g. an imported entry and a replayed keep of the same path).
-     * @param sessionId - the owning session.
+     * entry is inserted or replaced by path.
      * @param entry - the entry state to restore.
      * @returns whether the store changed.
      */
-    restore(sessionId: SessionId, entry: PendingEntry): boolean;
-    /** Total entry count across all sessions. */
+    restore(entry: PendingEntry): boolean;
+    /**
+     * Merge persisted entries into the store, one per path after folding. A live
+     * entry wins over a persisted one only when its time is newer (folders are
+     * applied in capture order, so a later persisted capture is strictly newer).
+     * @param entries - persisted entries, oldest capture first, to fold in.
+     */
+    hydrate(entries: readonly PendingEntry[]): void;
+    /** Total entry count (one per tracked file path). */
     get size(): number;
 }

package/lib/types/persist.d.ts

@@ -1,59 +1,52 @@
 /**
- * Durable pending-entry persistence under the harness home. One JSON file per
- * workspace holds every session's entries, at
- * `<storageDir>/<workspaceId>.json`; the default root is
- * `<dshHome>/diff-approval/workspaces` and the plugin's `storageDir` config
- * relocates it. `save` rewrites the whole workspace file so sibling sessions
- * survive; a session with no entries leaves the file, and a workspace with no
- * sessions loses its file. Writes are serialized per file, staged as a
- * sibling temp file, and atomically renamed, so a crash leaves either the old
- * or the new file. Missing files read as empty; corrupt content and unknown
- * versions throw so the caller can fail loud instead of silently dropping
- * persisted data.
+ * Durable pending-entry persistence under the harness home: one global JSON
+ * file holding one entry per file path (across all sessions and workspaces), at
+ * `<storageDir>/pending.json`; the default root is `<dshHome>/diff-approval/workspaces`
+ * and the plugin's `storageDir` config relocates it. Saves rewrite the whole
+ * file (the entry set is small), staged as a sibling temp file and atomically
+ * renamed, so a crash leaves either the old or the new file. A missing file
+ * reads as empty; corrupt content and unknown versions throw.
+ *
+ * Legacy layout: the pre-global schema stored one JSON file per workspace
+ * (`<storageDir>/<workspaceId>.json`, `{ version: 2, sessions: { [sessionId]:
+ * PendingEntry[] } }`). On first load without a global file, `loadAll` scans for
+ * those files, flattens every session's entries, and reports them so the caller
+ * can fold them into the global store once; `save` then writes the global file
+ * and deletes the legacy files.
  * @module dsh-diff-approval/src/persist
  */
 import type { PendingEntry } from './types.ts';
 /** Default persistence root: this plugin's own directory under the harness home. */
 export declare function defaultStorageDir(): string;
 /**
- * File-backed pending entries keyed by (workspace, session).
+ * File-backed pending entries, one global file keyed by path.
  */
 export declare class PendingPersistence {
     private readonly root;
     private readonly tails;
+    private readonly globalFile;
     /**
-     * @param root - directory holding one JSON file per workspace.
+     * @param root - directory holding the global `pending.json` (and, pre-migration,
+     * one JSON file per workspace).
      */
     constructor(root: string);
-    private fileOf;
-    /** Read one workspace file; a missing file reads as empty. */
-    private readWorkspace;
-    /** Stage the envelope as a sibling temp file and atomically rename it into place. */
-    private writeWorkspace;
     /**
-     * Load one session's entries from its workspace file, oldest capture first.
-     * @param workspaceId - the owning workspace's stable id.
-     * @param sessionId - the session whose entries to load.
-     * @returns the persisted entries; empty when none were saved.
+     * Load every persisted entry. Returns the global file's entries, or — when the
+     * global file is absent — flattens the legacy per-workspace files so the
+     * caller can fold them once and then save (which clears the legacy files).
+     * @returns the entries plus whether they came from the legacy layout (awaiting
+     * a save to finalize the migration).
      */
-    load(workspaceId: string, sessionId: string): Promise<PendingEntry[]>;
+    loadAll(): Promise<{
+        entries: PendingEntry[];
+        migratedLegacy: boolean;
+    }>;
     /**
-     * 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.
-     * @param workspaceId - the owning workspace's stable id.
-     * @param sessionId - the session whose entries to replace.
-     * @param entries - the session's complete entry list, possibly empty.
+     * Replace the persisted entry set durably. Saves to the one file are
+     * serialized; a previous save's failure does not block the next one. On a
+     * legacy migration this also removes the per-workspace files.
+     * @param entries - the complete entry list, possibly empty.
      * @returns resolution after the file is durable.
      */
-    save(workspaceId: string, sessionId: string, entries: readonly PendingEntry[]): Promise<void>;
+    save(entries: readonly PendingEntry[]): Promise<void>;
 }

package/lib/types/types.d.ts

@@ -5,26 +5,29 @@
  */
 import type { SessionId } from '@deepseek-ai/dsh-session/types';
 /**
- * One file's pending entry in one session: the complete set of unhandled
- * changes folded into a single cumulative span. `oldText` is the earliest
- * captured basis and `newText` the latest captured content, so Keep/Revert
- * decides the whole file at once.
+ * One file's pending entry, global and unique per `path`: the complete set of
+ * unhandled changes folded into a single cumulative span across every session
+ * and workspace that touched the file. `oldText` is the earliest captured basis
+ * and `newText` the latest captured content, so Keep/Revert decides the whole
+ * file at once.
  */
 export interface PendingEntry {
-    /** Stable per-entry id (generated at capture; persisted with the entry). */
+    /** Stable per-entry id, equal to the path (the global key). */
     id: string;
-    /** The session whose agent ran the operation. */
-    sessionId: SessionId;
     /** Backend-resolved display path (the tool's output `path`). */
     path: string;
     /** What the operation did: an in-place change or a file creation. */
     kind: PendingEntryKind;
-    /** File content before the operation (empty for a creation). */
+    /** File content before the first captured operation (empty for a creation). */
     oldText: string;
-    /** File content after the operation. */
+    /** File content after the latest captured operation. */
     newText: string;
-    /** Epoch milliseconds of the capture. */
+    /** Epoch milliseconds of the latest capture. */
     updatedAt: number;
+    /** The most recent session whose agent touched the file (back-compat). */
+    sessionId: SessionId;
+    /** Every session that touched the file (drives the per-session list filter). */
+    sessionIds: SessionId[];
 }
 /** What one captured operation did to the file. */
 export type PendingEntryKind = 'edit' | 'create';

package/package.json

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