dsh-rewind-plugin 0.3.0 → 0.3.2

package/README.md

@@ -53,6 +53,8 @@ For contributors: install from a local checkout or a pinned commit — `dsh plug
 
 **Command-line entry**: type a bare `/rewind` and press Enter to open the candidate picker; selecting a target continues the same flow as the button.
 
+Both the candidate picker and the mode popover support the keyboard: ↑↓ to move, Enter to confirm, Esc to cancel/back.
+
 Rewinds can be repeated (each appends a marker to the log). A rewind cannot be undone through the plugin, but the withdrawn messages can be recovered by manually editing the session log. The file-restore action is not re-backed up.
 
 ## How it works
@@ -74,17 +76,16 @@ The plugin tracks the write-class tools — `write`, `edit`, `str_replace_editor
 
 1. **Before-capture** at `tools/execute` (the around-dispatch stage): the target file is read; the resolved path + content are held in a pending map. This stage runs only after any pre-execute approval gate let the call through — an `ask` short-circuit (dsh-edit-approval) **cannot skip** the backup, and a denied call never records. If the read fails (e.g. a permission error), the change is simply not backed up — the plugin warns in the log but **does not block the write**.
 2. **Disk commit** at `tools/post-execute`: the before-backup is written under the turn's anchor message seq (`~/.dsh/rewind-snapshots/<session>/<anchor seq>/<callId>.json`).
-3. **Restore** (`/rewind @<seq> both`): every backup anchored at or after the target applies — modified files are written back to their **earliest** captured before-state, files created after the target are deleted, symbolic / hard links are skipped (they share an inode with another name; restoring through one would clobber both). Writes go through plain `node:fs`, independent of the fs service — under sandbox / remote backends, path resolution may be restricted.
+3. **Restore** (`/rewind @<seq> both`): every backup anchored at or after the target applies once reconciled with the current disk — modified files are written back to their **earliest** captured before-state, files created after the target are deleted, files already matching the target state are left untouched (idempotent). Symbolic / hard links are skipped (they share an inode with another name; restoring through one would clobber both). Writes go through plain `node:fs`, independent of the fs service — under sandbox / remote backends, path resolution may be restricted.
 4. A tool body that **throws** skips `tools/post-execute`; a `tools/result` safety net clears the pending capture so nothing leaks in memory.
 
 Backups persist across host restarts, bounded to the newest 100 anchor groups per session.
 
 ## What it deliberately does NOT do
 
-- **Whole-tree / git-first snapshots** — only write-class tool edits are backed up. `bash`, other tools, and external edits are not tracked and cannot be restored: the same limitation as Claude Code, which defers such rollbacks to the user's git.
+- **Whole-tree / git-first snapshots** — only write-class tool edits plus external changes to already-tracked files are backed up; files never touched by a tool are not restored: the same limitation as Claude Code, which defers such rollbacks to the user's git.
 - **Subagent edits** — not tracked (same as Claude Code): a subagent runs its own session, so its backups could never be restored by a rewind of the parent session.
 - **Fork / branch rewind and `/compact`** — the harness already provides these ("branch in new chat", compact).
-- **Keyboard shortcuts** (esc+esc rewind menu) — planned as a follow-up.
 
 ## Comparison with similar projects
 
@@ -116,7 +117,7 @@ Full instructions: [docs/troubleshooting.md](docs/troubleshooting.md)
 
 ## Security
 
-This plugin only appends rewind-marker events to the session log; it never deletes or rewrites logged history. File writes happen only when you choose "conversation and code" — before-backups and restores stay under `~/.dsh/rewind-snapshots/`. It never touches your git repository, makes no network requests, and accesses no credentials.
+This plugin only appends rewind-marker events to the session log; it never deletes or rewrites logged history. Workspace files are written only when you choose "conversation and code"; backups and restores stay under `~/.dsh/rewind-snapshots/`. It never touches your git repository, makes no network requests, and accesses no credentials.
 
 > **Note:** a rewind only hides messages from view — the exported session log (`/export`) still contains them, and this plugin cannot alter exports. To remove a conversation completely, delete its session file.
 
@@ -127,7 +128,7 @@ npm install            # devDeps from the npm registry
 npm run typecheck      # tsc on both compilation surfaces (host + client)
 npm test               # vitest: rewind / snapshot / hidden / session-cwd / integration
 npm run build          # esbuild: lib/index.js (host ESM) + lib/client.js (loader closure) + .d.ts
-node scripts/verify-host.mjs   # boot the BUILT host artifact end-to-end (18 checks)
+node scripts/verify-host.mjs   # boot the BUILT host artifact end-to-end
 ```
 
 `prepare` runs the full build, so git installs and `npm pack` / `npm publish` always produce a complete `lib/` and the `LICENSE`.

package/README.zh.md

@@ -53,6 +53,8 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 **命令行入口**：输入裸 `/rewind` 回车打开候选面板，选择目标后流程与按钮一致。
 
+候选面板与模式弹层均支持键盘操作：↑↓ 移动、Enter 确认、Esc 取消/返回。
+
 回退可重复进行（每次追加一条标记到日志）。回退无法通过插件撤销，但可以手动编辑会话日志恢复。文件还原动作不再记录新备份。
 
 ## 原理
@@ -74,17 +76,16 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 1. **写前备份**（`tools/execute`，around-dispatch 阶段）：读取目标文件，把解析后的路径与内容放入 pending 表。此阶段只在任何 pre-execute 审批门放行之后运行——审批 `ask` 短路（dsh-edit-approval）**无法跳过**备份，被拒绝的调用也不会记录。若读取失败（如权限错误），该次变更直接不入备份——插件只在日志中警告，**不会阻塞写操作**。
 2. **落盘提交**（`tools/post-execute`）：备份按当前轮**锚点消息 seq** 写入 `~/.dsh/rewind-snapshots/<会话>/<锚点 seq>/<callId>.json`。
-3. **还原**（`/rewind @<seq> both`）：锚点 ≥ 目标的每条备份生效——被修改的文件写回其**最早一次**捕获的 before 内容，目标之后新建的文件被删除，符号/硬链接跳过（它们与另一名字共享 inode，透过一个还原会误伤两个）。写入走纯 `node:fs`，不经 fs 服务——sandbox / 远程 backend 下路径解析可能受限。
+3. **还原**（`/rewind @<seq> both`）：锚点 ≥ 目标的备份与磁盘**对账后生效**（改过的写回最早 before、新建的删除、一致的跳过——幂等）。符号/硬链接跳过（它们与另一名字共享 inode，透过一个还原会误伤两个）。写入走纯 `node:fs`，不经 fs 服务——sandbox / 远程 backend 下路径解析可能受限。
 4. 工具体**抛异常**会跳过 `tools/post-execute`；`tools/result` 兜底清掉 pending，避免内存泄漏。
 
 备份跨 host 重启持久化，每会话有界保留最近 100 组锚点。
 
 ## 明确不做的事
 
-- **整树 / git-first 快照**——只备份写类工具编辑。`bash`、其他工具与外部程序的修改不在备份内、无法还原：与 Claude Code 相同，官方同样不覆盖，此类回退交由用户 git 处理。
+- **整树 / git-first 快照**——只备份写类工具编辑及已追踪文件的外部改动；从未被工具碰过的文件不还原：与 Claude Code 相同，此类回退交由用户 git 处理。
 - **子代理（subagent）的编辑**——不跟踪（同 Claude Code）：子代理运行在自己的会话里，其备份无法被父会话的回退还原。
 - **fork / 分支回退与 `/compact`**——harness 已内置（「在新对话中分支」、compact）。
-- **快捷键**（esc+esc 打开回退菜单）——规划中的后续项。
 
 ## 与同类项目对比
 
@@ -116,7 +117,7 @@ dsh plugin --profile web add dsh-rewind-plugin
 
 ## 安全
 
-本插件只向会话日志追加回退标记事件，从不删除或改写已记录的历史。文件写入仅在你选择「回退对话和代码」时发生，备份与还原都限定在 `~/.dsh/rewind-snapshots/` 内。不触碰你的 git 仓库，无网络请求，不访问任何凭据。
+本插件只向会话日志追加回退标记事件，从不删除或改写已记录的历史。工作区文件仅在「回退对话和代码」时被改写，备份与还原都限定在 `~/.dsh/rewind-snapshots/` 内。不触碰你的 git 仓库，无网络请求，不访问任何凭据。
 
 > **注意：** 回退只是把消息从视图中隐藏——导出的会话日志（`/export`）仍包含撤回前的内容，本插件无法改动导出。要彻底删除对话，请删除对应的会话文件。
 
@@ -127,7 +128,7 @@ npm install            # devDeps 来自 npm registry
 npm run typecheck      # tsc 双面编译（host + client）
 npm test               # vitest：rewind / snapshot / hidden / session-cwd / 集成
 npm run build          # esbuild：lib/index.js（host ESM）+ lib/client.js（loader 闭包）+ .d.ts
-node scripts/verify-host.mjs   # 端到端验证构建产物（18 项检查）
+node scripts/verify-host.mjs   # 端到端验证构建产物
 ```
 
 `prepare` 执行完整构建，所以 git 安装与 `npm pack` / `npm publish` 总会产出完整的 `lib/` 与 `LICENSE`。

package/lib/client.js

@@ -33,9 +33,9 @@ __export(index_exports, {
 module.exports = __toCommonJS(index_exports);
 
 // src/client/hidden.ts
-function targetOfOutcome(text) {
-  if (text === void 0) return void 0;
-  const match = text.match(/seq (\d+)/);
+function targetSeqOfArgs(args) {
+  if (args === void 0 || args === null) return void 0;
+  const match = args.match(/@(\d+)/);
   return match !== null ? Number(match[1]) : void 0;
 }
 function isExecutedRewindCommand(node, seq) {
@@ -48,11 +48,14 @@ function hasFileImpact(text) {
   if (text === void 0) return true;
   const match = text.match(/impact=(\d+)/);
   if (match !== null) return Number(match[1]) > 0;
-  return text.includes("\u5C06\u5F71\u54CD");
+  return false;
 }
 function isPreviewCommand(command) {
   return (command.args ?? "").includes("preview");
 }
+function isCandidateCommand(command) {
+  return (command.args ?? "").includes("__candidates");
+}
 function hiddenSeqsOf(snap) {
   const hidden = /* @__PURE__ */ new Set();
   const spans = [];
@@ -61,7 +64,7 @@ function hiddenSeqsOf(snap) {
     if (node === void 0 || node.kind !== "command") continue;
     const command = node.data;
     if (command.name !== "rewind") continue;
-    if (isPreviewCommand(command)) {
+    if (isPreviewCommand(command) || isCandidateCommand(command)) {
       hidden.add(command.seq);
       continue;
     }
@@ -69,7 +72,7 @@ function hiddenSeqsOf(snap) {
     const marker = command.outcome.sourceEventSeq;
     if (marker === void 0) continue;
     hidden.add(command.seq);
-    const target = targetOfOutcome(command.outcome.text);
+    const target = targetSeqOfArgs(command.args);
     if (target !== void 0) {
       spans.push({ start: target, end: marker });
     }
@@ -87,6 +90,7 @@ function hiddenSeqsOf(snap) {
 
 // src/client/candidates.ts
 var PREVIEW_CHARS = 80;
+var DEFAULT_CANDIDATE_LIMIT = 50;
 function messagePreviewOf(message) {
   const text = message.content.map((block) => block.type === "text" && typeof block.text === "string" ? block.text : "").join("").replace(/\s+/g, " ").trim();
   return text.length <= PREVIEW_CHARS ? text : `${text.slice(0, PREVIEW_CHARS - 1)}\u2026`;
@@ -97,7 +101,7 @@ function formatCandidateTime(time) {
   const mm = String(d.getMinutes()).padStart(2, "0");
   return `${hh}:${mm}`;
 }
-function rewindCandidatesOf(snap, hidden, limit = 10) {
+function rewindCandidatesOf(snap, hidden, limit = DEFAULT_CANDIDATE_LIMIT) {
   const candidates = [];
   for (let i = snap.order.length - 1; i >= 0 && candidates.length < limit; i--) {
     const key = snap.order[i];
@@ -116,16 +120,30 @@ function rewindCandidatesOf(snap, hidden, limit = 10) {
 function rewindCandidatesOfChat(snap) {
   return rewindCandidatesOf(snap, hiddenSeqsOf(snap));
 }
-function rewindOptionsOf(snap, t) {
-  return rewindCandidatesOfChat(snap).map((candidate) => ({
+var CANDIDATE_LIST_HEADER = "candidates=";
+function rewindCandidatesFromHostText(text) {
+  if (!text.startsWith(CANDIDATE_LIST_HEADER)) return [];
+  const lines = text.split("\n").slice(1);
+  const candidates = [];
+  for (const line of lines) {
+    if (line === "") continue;
+    const parts = line.split("	");
+    if (parts.length !== 3) continue;
+    const seq = Number(parts[0]);
+    const time = Number(parts[1]);
+    const preview = parts[2] ?? "";
+    if (!Number.isSafeInteger(seq) || !Number.isFinite(time)) continue;
+    candidates.push({ seq, time, preview });
+  }
+  return candidates;
+}
+function rewindOptionsFromCandidates(candidates, t) {
+  return candidates.map((candidate) => ({
     id: String(candidate.seq),
     label: candidate.preview || t("popover.noText"),
     detail: formatCandidateTime(candidate.time)
   }));
 }
-function candidateBySeq(snap, seq) {
-  return rewindCandidatesOfChat(snap).find((candidate) => candidate.seq === seq);
-}
 
 // src/client/styles.ts
 var CLASS = {
@@ -304,8 +322,14 @@ function formatTarget(t, seq, time, preview) {
   const previewText = preview.length > 0 ? preview : t("popover.noText");
   return `seq ${seq} \xB7 ${hh}:${mm} \xB7 ${previewText}`;
 }
-function stripImpactToken(text) {
-  return text.replace(/\n?impact=\d+\s*$/, "");
+function parseImpactList(text) {
+  const restores = [];
+  const deletes = [];
+  for (const line of text.split("\n")) {
+    if (line.startsWith("restore:")) restores.push(line.slice("restore:".length));
+    else if (line.startsWith("delete:")) deletes.push(line.slice("delete:".length));
+  }
+  return { restores, deletes };
 }
 function findCommand(snapshot, match) {
   let found;
@@ -419,7 +443,20 @@ function renderImpactStep(root, opts, back, cached) {
       impact.textContent = t("popover.impact.failed", { message: outcome.text ?? "unknown error" });
       return;
     }
-    impact.textContent = outcome.text === void 0 ? t("popover.impact.none") : stripImpactToken(outcome.text);
+    if (outcome.text === void 0) {
+      impact.textContent = t("popover.impact.none");
+    } else {
+      const { restores, deletes } = parseImpactList(outcome.text);
+      if (restores.length === 0 && deletes.length === 0) {
+        impact.textContent = t("popover.impact.none");
+      } else {
+        const lines = [
+          ...restores.map((path) => t("popover.impact.restore", { path })),
+          ...deletes.map((path) => t("popover.impact.delete", { path }))
+        ];
+        impact.textContent = lines.join("\n");
+      }
+    }
     confirm.disabled = false;
     confirm.focus();
     confirm.addEventListener("click", () => {
@@ -738,6 +775,8 @@ var zh = {
   "popover.impact.loading": "\u6B63\u5728\u83B7\u53D6\u5F71\u54CD\u6E05\u5355\u2026",
   "popover.impact.failed": "\u65E0\u6CD5\u83B7\u53D6\u5F71\u54CD\u6E05\u5355\uFF1A{message}",
   "popover.impact.none": "\u76EE\u6807\u4E4B\u540E\u6CA1\u6709\u8DDF\u8E2A\u5230\u7684\u5199\u7C7B\u53D8\u66F4\uFF0C\u65E0\u9700\u8FD8\u539F\u6587\u4EF6\u3002",
+  "popover.impact.restore": "\u8FD8\u539F {path}",
+  "popover.impact.delete": "\u5220\u9664 {path}",
   "popover.confirm": "\u786E\u8BA4\u56DE\u9000",
   "popover.back": "\u8FD4\u56DE",
   "guard.hint": "/rewind \u624B\u52A8\u8F93\u5165\u4E0D\u63A5\u53D7\u53C2\u6570\uFF0C\u8BF7\u76F4\u63A5\u8F93\u5165 /rewind \u6253\u5F00\u56DE\u9000\u83DC\u5355"
@@ -757,6 +796,8 @@ var en = {
   "popover.impact.loading": "Fetching impact list\u2026",
   "popover.impact.failed": "Could not fetch the impact list: {message}",
   "popover.impact.none": "No tracked file changes after the target; nothing to restore.",
+  "popover.impact.restore": "Restore {path}",
+  "popover.impact.delete": "Delete {path}",
   "popover.confirm": "Confirm rewind",
   "popover.back": "Back",
   "guard.hint": "/rewind takes no typed arguments \u2014 enter /rewind to open the rewind picker."
@@ -800,6 +841,15 @@ function apply(ctx) {
       const chat = chatOf(sessionId);
       return chat !== void 0 && rewindCandidatesOfChat(chat).length > 0;
     };
+    const fetchHostCandidates = async (face) => {
+      const known = knownCommandSeqs(face, (node) => isCandidateCommand(node));
+      const result = await face.command("/rewind __candidates");
+      if (!result.ok || result.value?.matched !== true) return void 0;
+      const outcome = await waitForCommand(face, (node) => isCandidateCommand(node) && !known.has(node.seq));
+      if (outcome === null || outcome.kind !== "success" || outcome.text === void 0) return void 0;
+      return rewindCandidatesFromHostText(outcome.text);
+    };
+    const hostCandidatesCache = /* @__PURE__ */ new Map();
     const composerAnchor = () => {
       const textarea = composerTextarea();
       const card = textarea?.closest("[data-composer-card]");
@@ -814,15 +864,20 @@ function apply(ctx) {
       available: (session) => hasCandidates(session.sessionId),
       ui: {
         kind: "popupSelect",
-        options: (session) => {
-          const chat = chatOf(session.sessionId);
-          return Promise.resolve(chat === void 0 ? [] : rewindOptionsOf(chat, t));
+        options: async (session) => {
+          const face = sessionOf(session.sessionId);
+          if (face === void 0) return [];
+          const candidates = await fetchHostCandidates(face);
+          if (candidates !== void 0) hostCandidatesCache.set(session.sessionId, candidates);
+          return candidates === void 0 ? [] : rewindOptionsFromCandidates(candidates, t);
         },
         onSelect: (option, session) => {
           const face = sessionOf(session.sessionId);
-          const chat = chatOf(session.sessionId);
-          const candidate = chat !== void 0 ? candidateBySeq(chat, Number(option.id)) : void 0;
-          if (face === void 0 || candidate === void 0) return;
+          if (face === void 0) return;
+          const candidate = hostCandidatesCache.get(session.sessionId)?.find(
+            (candidate2) => candidate2.seq === Number(option.id)
+          );
+          if (candidate === void 0) return;
           openPopover({
             session: face,
             seq: candidate.seq,