@epoch-agent/view 0.23.0 → 0.26.0

package/README.md

@@ -18,9 +18,23 @@
 | `applyStreamEvent(state, event)`          | 折叠一个 `AgentEvent`，返回新的 item 列表 + 变更信息 |
 | `diffLines(before, after)`                | 行级 diff                                            |
 | `collapseContext(lines)`                  | 把连续的未改动行折叠成 `@@` 摘要                     |
-| `DIFF_CONTEXT_LINES` / `DIFF_MAX_LINES`   | 折叠与截断的阈值                                     |
+| `DIFF_CONTEXT_LINES` / `DIFF_MAX_LINES`   | 折叠与截断的阈值（后者的口径见下）                   |
 | `HistoryItem*` / `ToolDisplayItem` 等类型 | item 的判别联合                                      |
 
+## 行级 diff 的两个口径（2026-10-09）
+
+| 事                      | 口径                                                                                              |
+| ----------------------- | ------------------------------------------------------------------------------------------------- |
+| `DIFF_MAX_LINES` 量什么 | **剥掉公共前后缀之后剩下的那一段**，不是整份文件。6000 行的文件改一行照画，只有中间那段真大才撞线 |
+| 截断那一档报什么        | 只有两侧整份的 `oldLines` / `newLines`，**没有** `added` / `removed`（`DiffTruncated`）           |
+
+两条都是同一条规矩：**宁可少说，不说错的。** 以前量的是整份行数，于是「600 行改
+两行」和「整份重写 600 行」落进同一档、一行都看不到；以前那两个数装的是文件行数，
+而两个宿主都把它画成 `+N −M`，于是「1000 行改 2 行」显示成 `+1000 −1000`。
+
+上限取 2000 的读数、剥前后缀的等价性、以及哪一支上有哪些字段，都在
+[diff-lines.ts](src/diff-lines.ts) 的文件头和 `DiffTruncated` 上 —— 这里不抄第二份。
+
 ## 分界线
 
 > ⚠️ **这里进了 React 就说明分界画错了。** 真到那一步，该拆成 `view-core` + 各自的

package/dist/index.d.ts

@@ -270,9 +270,22 @@ declare function applyStreamEvent(state: StreamReduceResult, event: AgentEvent,
  * 旧版 TUI 把它渲染成一行「📝 补丁预览: a.ts」，两段内容直接扔了。
  *
  * 用经典 LCS 动态规划，**但有上限**：DP 表是 O(n·m)，几千行的文件会吃掉几十 MB
- * 并且卡住渲染线程。超限就退回「N 行 → M 行」的摘要 —— 少显示细节可以接受，
+ * 并且卡住渲染线程。超限就退回「整份 N 行 → M 行」的摘要 —— 少显示细节可以接受，
  * 界面卡死不行。
  *
+ * ## 2026-10-09：先剥公共前后缀，上限只量「要逐行比的那一段」
+ *
+ * 在此之前判的是**整份文件的行数**（`a.length > 400 || b.length > 400`），于是
+ * 「600 行的 README 改两行」和「整份重写 600 行」落进同一档：一张
+ * 「内容超过逐行比对上限」的空卡。而前者才是补丁的常态，后者反倒少。
+ *
+ * 剥公共前后缀不改结果：公共前后缀一定可以出现在某个最优 LCS 里，所以先摘掉
+ * 它们、算完中间那段再拼回去，得到的就是完整解。收益是上限从此只量中间那一段 ——
+ * 几百行的文件改几行，要逐行比的只有几行。
+ *
+ * ⚠️ **这一处改的是 view，两个宿主跟着一起变**（`tui` / `web` 用的是同一份，
+ * 正是本文件存在的理由）—— 别在某一侧再改一遍。
+ *
  * ## 为什么住在 view 而不是 tui / web
  *
  * `diffLines` 原来在 `tui/src/streaming/`、`collapseContext` 原来在
@@ -287,25 +300,79 @@ declare function applyStreamEvent(state: StreamReduceResult, event: AgentEvent,
  * 固定行数并打一句「还有 N 行」；浏览器给 `max-height` + 内部滚动，一行不丢。
  * 那不是 diff 语义，搬上来反而会让本包去关心它不该知道的终端高度。
  */
-/** 超过这个行数就不做逐行 diff */
-declare const DIFF_MAX_LINES = 400;
+/**
+ * 超过这个行数就不做逐行 diff。
+ *
+ * ⚠️ **量的是「剥掉公共前后缀之后剩下的那一段」**，不是整份文件的行数（2026-10-09
+ * 改的，判据在文件头）。
+ *
+ * 400 那个值当初是按最坏情况定的：DP 表是 O(n·m)，几千行要几十 MB 并且卡住渲染
+ * 线程 —— **那句话本身没错，取值偏保守了一个数量级**。本机实测（照抄本文件的
+ * `lcsTable`，含建表和回溯）：
+ *
+ * | 行数 | 小改动（10 处） | 整份重写 | DP 表  |
+ * | ---- | --------------- | -------- | ------ |
+ * | 400  | 1.9ms           | 0.4ms    | 0.6MB  |
+ * | 600  | 1.9ms           | 1.0ms    | 1.4MB  |
+ * | 2000 | 15.3ms          | 7.8ms    | 16MB   |
+ * | 3000 | 34.2ms          | 21.7ms   | 36MB   |
+ * | 5000 | 106ms           | 51ms     | 100MB  |
+ *
+ * 取 2000：单张卡一次 `useMemo` 的预算里 15ms / 16MB 还能认。再往上（3000 起）
+ * 内存按 n² 涨，那一步该换算法而不是继续抬这个数。
+ *
+ * ⚠️ **别只看单张卡**：一屏十几张补丁卡时这个数是乘起来的。
+ *
+ * ⚠️ 和上游那个闸门对一下：core 的 `MAX_FILE_BYTES = 128KB`（注释写着约三千行）
+ * 是**服务端发不发内容**的线 —— 它比这一条宽得多。两个数**不需要相等**
+ * （发得过来不等于画得动），但知道它们差多少，才判得出「发过来却被丢掉」有多少。
+ */
+declare const DIFF_MAX_LINES = 2000;
 type DiffLineKind = 'add' | 'remove' | 'context';
 interface DiffLine {
     kind: DiffLineKind;
     text: string;
 }
-interface DiffResult {
+/** 两侧**整份**各有几行。截断那一档就靠它说「整份 N → M 行」 */
+interface DiffSides {
+    oldLines: number;
+    newLines: number;
+}
+/** 逐行比过了 */
+interface DiffAligned extends DiffSides {
+    truncated: false;
     lines: DiffLine[];
+    /** 改动**行数**。两侧的公共前后缀是 context，不算进来 */
     added: number;
     removed: number;
-    /** true = 内容太大，没有逐行比，`lines` 为空 */
-    truncated: boolean;
 }
+/**
+ * 没逐行比 —— 只剩下两侧的整份行数。
+ *
+ * ## 这一支上**刻意没有** `added` / `removed`
+ *
+ * 2026-10-09 之前有，装的是 `b.length` / `a.length`（两侧的**整份行数**），
+ * 而两个宿主都把它画成头部的 `+N −M`：于是「1000 行的文件改 2 行」显示成
+ * `+1000 −1000`。整份重写时它碰巧对，那只是巧合 —— 一个算错的数字比没有数字
+ * 糟得多，所以它在这一支上**在结构上就不存在**，不是「算了但不画」
+ * （同 `thread/patch.tsx` 的 `PatchShape` 那条判据）。
+ *
+ * 要看这一份到底改了什么，得让 `lines` 那一支回来 —— 也就是把要逐行比的那一段
+ * 压到 {@link DIFF_MAX_LINES} 以内。
+ */
+interface DiffTruncated extends DiffSides {
+    truncated: true;
+}
+type DiffResult = DiffAligned | DiffTruncated;
 /**
  * 比较两段文本，产出带 add / remove / context 标记的行序列。
  *
  * 内容缺失（undefined）时按空串处理：新建文件只有 newContent，删除只有
  * oldContent，两种都该显示成纯增 / 纯删而不是空 diff。
+ *
+ * 先剥公共前后缀再对中间那段跑 LCS，见文件头与 {@link DIFF_MAX_LINES}。
+ * 返回的 `lines` **永远是整份文件的**（前后缀作为 context 拼在前面和后面）——
+ * 剥只是省掉一次没必要的大表，不是「只给中间那一截」。
  */
 declare function diffLines(oldContent?: string, newContent?: string): DiffResult;
 /** 变更行前后各保留几行上下文 */

package/dist/index.js

@@ -122,7 +122,7 @@ function applyStreamEvent(state, event, meta) {
   }
 }
 // src/diff-lines.ts
-var DIFF_MAX_LINES = 400;
+var DIFF_MAX_LINES = 2e3;
 function splitLines(text) {
   if (text === "") return [];
   const lines = text.split("\n");
@@ -146,33 +146,49 @@ function lcsTable(a, b) {
 function diffLines(oldContent = "", newContent = "") {
   const a = splitLines(oldContent);
   const b = splitLines(newContent);
-  if (a.length > DIFF_MAX_LINES || b.length > DIFF_MAX_LINES) {
-    return { lines: [], added: b.length, removed: a.length, truncated: true };
+  const sides = { oldLines: a.length, newLines: b.length };
+  const { prefix, suffix } = trimCommon(a, b);
+  const aMid = a.slice(prefix, a.length - suffix);
+  const bMid = b.slice(prefix, b.length - suffix);
+  if (aMid.length > DIFF_MAX_LINES || bMid.length > DIFF_MAX_LINES) {
+    return { ...sides, truncated: true };
   }
-  const table = lcsTable(a, b);
+  const table = lcsTable(aMid, bMid);
   const lines = [];
   let added = 0;
   let removed = 0;
+  for (let k = 0; k < prefix; k++) lines.push({ kind: "context", text: a[k] });
   let i = 0;
   let j = 0;
-  while (i < a.length && j < b.length) {
-    if (a[i] === b[j]) {
-      lines.push({ kind: "context", text: a[i] });
+  while (i < aMid.length && j < bMid.length) {
+    if (aMid[i] === bMid[j]) {
+      lines.push({ kind: "context", text: aMid[i] });
       i++;
       j++;
     } else if (table[i + 1][j] >= table[i][j + 1]) {
-      lines.push({ kind: "remove", text: a[i] });
+      lines.push({ kind: "remove", text: aMid[i] });
       removed++;
       i++;
     } else {
-      lines.push({ kind: "add", text: b[j] });
+      lines.push({ kind: "add", text: bMid[j] });
       added++;
       j++;
     }
   }
-  for (; i < a.length; i++, removed++) lines.push({ kind: "remove", text: a[i] });
-  for (; j < b.length; j++, added++) lines.push({ kind: "add", text: b[j] });
-  return { lines, added, removed, truncated: false };
+  for (; i < aMid.length; i++, removed++) lines.push({ kind: "remove", text: aMid[i] });
+  for (; j < bMid.length; j++, added++) lines.push({ kind: "add", text: bMid[j] });
+  for (let k = suffix; k > 0; k--) lines.push({ kind: "context", text: a[a.length - k] });
+  return { ...sides, lines, added, removed, truncated: false };
+}
+function trimCommon(a, b) {
+  const max = Math.min(a.length, b.length);
+  let prefix = 0;
+  while (prefix < max && a[prefix] === b[prefix]) prefix += 1;
+  let suffix = 0;
+  while (suffix < max - prefix && a[a.length - 1 - suffix] === b[b.length - 1 - suffix]) {
+    suffix += 1;
+  }
+  return { prefix, suffix };
 }
 var DIFF_CONTEXT_LINES = 1;
 function collapseContext(lines, context = DIFF_CONTEXT_LINES) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@epoch-agent/view",
-  "version": "0.23.0",
+  "version": "0.26.0",
   "private": false,
   "description": "epoch-agent 展示层纯逻辑：AgentEvent → 可渲染 item，tui 与 web 共用",
   "repository": {
@@ -22,7 +22,7 @@
     "dist"
   ],
   "dependencies": {
-    "@epoch-agent/protocol": "0.23.0"
+    "@epoch-agent/protocol": "0.26.0"
   },
   "devDependencies": {
     "tsup": "^8.3.6",