@zhushanwen/pi-session-reader 0.1.0

package/src/__tests__/toolcall.test.ts

@@ -0,0 +1,256 @@
+import { describe, it, expect } from 'vitest'
+import { extractToolCalls, formatToolCallSummary } from '../core/toolcall.js'
+import type { Entry } from '../core/parser.js'
+
+/**
+ * D1 映射表（design §3.3）确定性测试：formatToolCallSummary 12 个 switch 分支
+ * + extractToolCalls 提取/coerceArgs 兜底各形态。修复 MF-2（原仅经 render.test.ts
+ * fixture 间接覆盖 bash/read/edit/write 四分支，head/todo/subagent/cw/unknown 零直接覆盖）。
+ */
+
+/** 构造带 content 的 assistant message entry。 */
+function entryWithContent(content: unknown): Entry {
+  return { type: 'message', id: 'm1', parentId: null, message: { role: 'assistant', content } }
+}
+
+describe('formatToolCallSummary — bash/read/edit/write', () => {
+  it('bash：有 command → 摘要（超 60 字截断加省略号）；无 command → 仅工具名', () => {
+    expect(formatToolCallSummary({ id: 'c1', name: 'bash', arguments: { command: 'ls -la' } })).toBe(
+      'bash: ls -la',
+    )
+    // 60 字边界：恰好 60 不截断
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'bash',
+        arguments: { command: 'y'.repeat(60) },
+      }),
+    ).toBe(`bash: ${'y'.repeat(60)}`)
+    // 61 字 → 前 60 + 省略号
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'bash',
+        arguments: { command: 'z'.repeat(61) },
+      }),
+    ).toBe(`bash: ${'z'.repeat(60)}…`)
+    expect(formatToolCallSummary({ id: 'c1', name: 'bash', arguments: {} })).toBe('bash')
+  })
+
+  it('read：有 path → basename（尾斜杠剥除）；无 path → 仅工具名', () => {
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'read', arguments: { path: '/a/b/c.ts' } }),
+    ).toBe('read: c.ts')
+    // 尾斜杠：basename 先剥 / 再取末段
+    expect(formatToolCallSummary({ id: 'c1', name: 'read', arguments: { path: '/a/b/' } })).toBe(
+      'read: b',
+    )
+    expect(formatToolCallSummary({ id: 'c1', name: 'read', arguments: {} })).toBe('read')
+  })
+
+  it('edit：path + edits 数组 → blocks 数；缺 path / 缺 edits 各自降级', () => {
+    const base = { path: '/p/f.ts' }
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'edit',
+        arguments: { ...base, edits: [{ a: 1 }, { a: 2 }, { a: 3 }] },
+      }),
+    ).toBe('edit: f.ts (3 blocks)')
+    expect(formatToolCallSummary({ id: 'c1', name: 'edit', arguments: base })).toBe('edit: f.ts')
+    // 无 path 有 edits → head 降级为工具名，保留 blocks
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'edit', arguments: { edits: [1, 2] } }),
+    ).toBe('edit (2 blocks)')
+    // edits 非数组（object）→ 无 blocks 维度
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'edit', arguments: { ...base, edits: { a: 1 } } }),
+    ).toBe('edit: f.ts')
+  })
+
+  it('write：content utf8 字节转 KB（<1KB 取 1，>1KB 四舍五入）；无 content → 仅 head', () => {
+    const base = { path: '/p/f.ts' }
+    // 100 字节 < 1KB → 下限 1KB
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'write',
+        arguments: { ...base, content: 'a'.repeat(100) },
+      }),
+    ).toBe('write: f.ts (1KB)')
+    // 2048 字节 = 2KB
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'write',
+        arguments: { ...base, content: 'a'.repeat(2048) },
+      }),
+    ).toBe('write: f.ts (2KB)')
+    // 多字节字符按 utf8 字节计（'你' = 3 字节，1024 个 = 3KB）
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'write',
+        arguments: { ...base, content: '你'.repeat(1024) },
+      }),
+    ).toBe('write: f.ts (3KB)')
+    // 无 path 有 content → head 降级为工具名
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'write', arguments: { content: 'abc' } }),
+    ).toBe('write (1KB)')
+    expect(formatToolCallSummary({ id: 'c1', name: 'write', arguments: base })).toBe('write: f.ts')
+  })
+})
+
+describe('formatToolCallSummary — head/todo/subagent', () => {
+  it('head：limit 双形态（number/string）都输出；缺 path / 缺 limit 各自降级', () => {
+    const base = { path: '/p/f.ts' }
+    expect(formatToolCallSummary({ id: 'c1', name: 'head', arguments: { ...base, limit: 5 } })).toBe(
+      'head: f.ts (5)',
+    )
+    // string limit（实测 number，防御 string）
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'head', arguments: { ...base, limit: '5' } }),
+    ).toBe('head: f.ts (5)')
+    expect(formatToolCallSummary({ id: 'c1', name: 'head', arguments: base })).toBe('head: f.ts')
+    // 无 path 有 limit → head 降级
+    expect(formatToolCallSummary({ id: 'c1', name: 'head', arguments: { limit: 5 } })).toBe(
+      'head (5)',
+    )
+  })
+
+  it('todo：id 双形态（number/string）；缺 action / 缺 id 各自降级', () => {
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'todo', arguments: { action: 'add', id: 3 } }),
+    ).toBe('todo: add(3)')
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'todo', arguments: { action: 'add', id: 'abc' } }),
+    ).toBe('todo: add(abc)')
+    expect(formatToolCallSummary({ id: 'c1', name: 'todo', arguments: { action: 'add' } })).toBe(
+      'todo: add',
+    )
+    expect(formatToolCallSummary({ id: 'c1', name: 'todo', arguments: {} })).toBe('todo')
+  })
+
+  it('subagent：task 截断 40 字；无 task → 仅工具名', () => {
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'subagent', arguments: { task: 'do work' } }),
+    ).toBe('subagent: do work')
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'subagent',
+        arguments: { task: 'x'.repeat(41) },
+      }),
+    ).toBe(`subagent: ${'x'.repeat(40)}…`)
+    expect(formatToolCallSummary({ id: 'c1', name: 'subagent', arguments: {} })).toBe('subagent')
+  })
+})
+
+describe('formatToolCallSummary — coding-workflow-* / unknown fallback', () => {
+  it('coding-workflow-gate：phase 存在（任意类型 String() 化）；缺 phase → 仅工具名', () => {
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'coding-workflow-gate',
+        arguments: { phase: 'prompt' },
+      }),
+    ).toBe('cw-gate: phase=prompt')
+    // 非 string phase（number）→ String() 化
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'coding-workflow-gate', arguments: { phase: 2 } }),
+    ).toBe('cw-gate: phase=2')
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'coding-workflow-gate', arguments: {} }),
+    ).toBe('cw-gate')
+  })
+
+  it('coding-workflow-init：slug 存在 / 缺失', () => {
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'coding-workflow-init',
+        arguments: { slug: 'abc' },
+      }),
+    ).toBe('cw-init: abc')
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'coding-workflow-init', arguments: {} }),
+    ).toBe('cw-init')
+  })
+
+  it('coding-workflow-phase-start：恒为 cw-phase-start（忽略参数）', () => {
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'coding-workflow-phase-start', arguments: {} }),
+    ).toBe('cw-phase-start')
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'coding-workflow-phase-start',
+        arguments: { phase: 'x' },
+      }),
+    ).toBe('cw-phase-start')
+  })
+
+  it('unknown fallback：空 arguments → 仅工具名；非空 → JSON 前 50 字截断；循环引用 → 仅工具名', () => {
+    expect(formatToolCallSummary({ id: 'c1', name: 'my-tool', arguments: {} })).toBe('my-tool')
+    // JSON 16 字 ≤ 50 → 不截断
+    expect(
+      formatToolCallSummary({ id: 'c1', name: 'my-tool', arguments: { long: 'value' } }),
+    ).toBe('my-tool: {"long":"value"}')
+    // JSON 68 字 > 50 → 前 50 + 省略号（'{"a":"' 6 字 + 44 x）
+    expect(
+      formatToolCallSummary({
+        id: 'c1',
+        name: 'my-tool',
+        arguments: { a: 'x'.repeat(60) },
+      }),
+    ).toBe(`my-tool: {"a":"${'x'.repeat(44)}…`)
+    // JSON.stringify 抛错（循环引用）→ 仅工具名
+    const circ: Record<string, unknown> = { a: 1 }
+    circ.self = circ
+    expect(formatToolCallSummary({ id: 'c1', name: 'my-tool', arguments: circ })).toBe('my-tool')
+  })
+})
+
+describe('extractToolCalls — 提取 + coerceArgs 兜底', () => {
+  it('无 message / content 非数组 → 空数组', () => {
+    expect(extractToolCalls({ type: 'message', id: 'm1', parentId: null })).toEqual([])
+    expect(extractToolCalls(entryWithContent('plain text'))).toEqual([])
+    expect(extractToolCalls(entryWithContent([]))).toEqual([])
+  })
+
+  it('过滤非 toolCall block / 缺 id / 缺 name 的 block', () => {
+    const content = [
+      null,
+      'str',
+      { type: 'text', text: 'hi' },
+      { type: 'toolCall', name: 'bash' }, // 缺 id
+      { type: 'toolCall', id: 42, name: 'bash' }, // id 非 string
+      { type: 'toolCall', id: 'c2' }, // 缺 name
+      { type: 'toolCall', id: 'c1', name: 'bash', arguments: { command: 'ls' } },
+    ]
+    const out = extractToolCalls(entryWithContent(content))
+    expect(out).toHaveLength(1)
+    expect(out[0]).toEqual({ id: 'c1', name: 'bash', arguments: { command: 'ls' } })
+  })
+
+  it('coerceArgs：object 原样；string JSON 解析；非法 string / number / null / array / boolean → {}', () => {
+    const blocks = (args: unknown) => [{ type: 'toolCall', id: 'c1', name: 't', arguments: args }]
+    // object 原样
+    expect(extractToolCalls(entryWithContent(blocks({ a: 1 })))[0].arguments).toEqual({ a: 1 })
+    // string JSON → 解析
+    expect(
+      extractToolCalls(entryWithContent(blocks('{"command":"ls"}')))[0].arguments,
+    ).toEqual({ command: 'ls' })
+    // 非法 JSON → {}
+    expect(extractToolCalls(entryWithContent(blocks('not-json')))[0].arguments).toEqual({})
+    // JSON 解析结果非 object（'42' → number）→ {}
+    expect(extractToolCalls(entryWithContent(blocks('42')))[0].arguments).toEqual({})
+    // number / null / array / boolean / undefined → {}
+    expect(extractToolCalls(entryWithContent(blocks(5)))[0].arguments).toEqual({})
+    expect(extractToolCalls(entryWithContent(blocks(null)))[0].arguments).toEqual({})
+    expect(extractToolCalls(entryWithContent(blocks([1, 2])))[0].arguments).toEqual({})
+    expect(extractToolCalls(entryWithContent(blocks(true)))[0].arguments).toEqual({})
+    expect(extractToolCalls(entryWithContent(blocks(undefined)))[0].arguments).toEqual({})
+  })
+})

package/src/__tests__/tree.test.ts

@@ -0,0 +1,101 @@
+import { describe, it, expect } from 'vitest'
+import { buildTreeView } from '../core/tree.js'
+import type { Entry } from '../core/parser.js'
+
+/** 构造最小 Entry（tree.ts 只消费 type/id/parentId，其余字段省略） */
+function e(id: string, parentId: string | null): Entry {
+  return { type: 'message', id, parentId }
+}
+
+describe('buildTreeView', () => {
+  it('线性链：leafPath 含全部 id，branches/orphans 空', () => {
+    const entries = [e('A', null), e('B', 'A'), e('C', 'B')]
+    const t = buildTreeView(entries)
+
+    expect(t.leafPath).toEqual(['A', 'B', 'C'])
+    expect(t.branches.size).toBe(0)
+    expect(t.orphans).toEqual([])
+  })
+
+  it('单分叉：旁支子树按 forkPoint 聚合（D+E 归 A，count=2）', () => {
+    // 主链 A→B→C，旁支 A→D→E；C 放最后 → leafId=C
+    const entries = [e('A', null), e('B', 'A'), e('D', 'A'), e('E', 'D'), e('C', 'B')]
+    const t = buildTreeView(entries)
+
+    expect(t.leafPath).toEqual(['A', 'B', 'C'])
+    expect(t.branches.size).toBe(1)
+    expect(t.branches.get('A')).toBe(2)
+    expect(t.orphans).toEqual([])
+  })
+
+  it('多级分叉：深层旁支沿祖先链归到 leafPath 上的 forkPoint', () => {
+    // 主链 A→B→C→D，旁支 B→X→Y→Z；D 放最后 → leafId=D
+    const entries = [
+      e('A', null), e('B', 'A'),
+      e('X', 'B'), e('Y', 'X'), e('Z', 'Y'),
+      e('C', 'B'), e('D', 'C'),
+    ]
+    const t = buildTreeView(entries)
+
+    expect(t.leafPath).toEqual(['A', 'B', 'C', 'D'])
+    // X/Y/Z 全部沿祖先链回到 forkPoint=B → count=3
+    expect(t.branches.get('B')).toBe(3)
+    expect(t.orphans).toEqual([])
+  })
+
+  it('多个 forkPoint：旁支挂在 leafPath 不同节点上各自计数', () => {
+    // 主链 A→B→C→D，旁支挂 A（A→X）和挂 C（C→Y）；D 放最后 → leafId=D
+    const entries = [e('A', null), e('X', 'A'), e('B', 'A'), e('C', 'B'), e('Y', 'C'), e('D', 'C')]
+    const t = buildTreeView(entries)
+
+    expect(t.leafPath).toEqual(['A', 'B', 'C', 'D'])
+    expect(t.branches.get('A')).toBe(1)
+    expect(t.branches.get('C')).toBe(1)
+    expect(t.orphans).toEqual([])
+  })
+
+  it('孤儿：parentId 指向不存在 → 进 orphans；leafPath 在断点停', () => {
+    // A 是 leafPath 根但 parentId 断（MISSING_A 不在 index）→ leafPath 在 A 处停
+    // X 非 leafPath 且 parentId 断 → 孤儿
+    // B=leafId（最后），B.parentId=A
+    const entries = [e('A', 'MISSING_A'), e('X', 'MISSING_X'), e('B', 'A')]
+    const t = buildTreeView(entries)
+
+    // 回溯 B→A→MISSING_A(不在 index) 停
+    expect(t.leafPath).toEqual(['A', 'B'])
+    // A 在 leafPath 上（断点根，有归属）→ 不重复计入 orphans
+    expect(t.orphans).toEqual(['X'])
+    expect(t.branches.size).toBe(0)
+  })
+
+  it('leafId = entries 最后一条的 id（D-2 语义）：同样节点不同顺序 → 不同 leafPath', () => {
+    const ordered = [e('A', null), e('B', 'A'), e('C', 'B'), e('D', 'C')] // leafId=D
+    const swapped = [e('A', null), e('B', 'A'), e('D', 'C'), e('C', 'B')] // leafId=C，D 变旁支
+
+    const t1 = buildTreeView(ordered)
+    const t2 = buildTreeView(swapped)
+
+    expect(t1.leafPath).toEqual(['A', 'B', 'C', 'D'])
+    expect(t2.leafPath).toEqual(['A', 'B', 'C'])
+    // swapped 里 D 挂在 C（leafPath 末端）下，成旁支
+    expect(t2.branches.get('C')).toBe(1)
+  })
+
+  it('空 entries：返回空视图', () => {
+    const t = buildTreeView([])
+    expect(t.leafPath).toEqual([])
+    expect(t.branches.size).toBe(0)
+    expect(t.orphans).toEqual([])
+  })
+
+  it('多 root 独立子树：触不到 leafPath 的 entry 不计入 branches/orphans', () => {
+    // 主链 R→A（leafId=A），另有独立 root X→Y（X.parentId=null，与主链无连接）
+    const entries = [e('R', null), e('X', null), e('Y', 'X'), e('A', 'R')]
+    const t = buildTreeView(entries)
+
+    expect(t.leafPath).toEqual(['R', 'A'])
+    // X 是独立 root（parentId=null）→ 跳过；Y 触不到 leafPath → 静默忽略
+    expect(t.branches.size).toBe(0)
+    expect(t.orphans).toEqual([])
+  })
+})

package/src/__tests__/turns.test.ts

@@ -0,0 +1,142 @@
+import { describe, it, expect } from 'vitest'
+import { segmentTurns } from '../core/turns.js'
+import type { Entry } from '../core/parser.js'
+import { parseSessionFile } from '../core/parser.js'
+import { buildTreeView } from '../core/tree.js'
+import { REAL_SESSION, HAS_REAL_SESSION } from './real-data.js'
+
+// ---- Entry 构造助手（turns.ts 只消费 type/id/parentId/message.role） ----
+
+function msg(
+  id: string,
+  parentId: string | null,
+  role: 'user' | 'assistant' | 'toolResult',
+): Entry {
+  return { type: 'message', id, parentId, message: { role, content: '' } }
+}
+
+function entry(id: string, parentId: string | null, type: string): Entry {
+  return { type, id, parentId }
+}
+
+describe('segmentTurns', () => {
+  it('1. user 开 turn，后续 assistant/toolResult 并入同一 turn', () => {
+    const entries = [msg('U', null, 'user'), msg('A', 'U', 'assistant'), msg('T', 'A', 'toolResult')]
+    const turns = segmentTurns(entries, new Set(['U', 'A', 'T']))
+
+    expect(turns).toHaveLength(1)
+    expect(turns[0].index).toBe(0)
+    expect(turns[0].isCompaction).toBe(false)
+    expect(turns[0].userEntry?.id).toBe('U')
+    expect(turns[0].entries.map((e) => e.id)).toEqual(['U', 'A', 'T'])
+  })
+
+  it('2. compaction 开新 turn（isCompaction=true，无 userEntry），后续 user 又开一个 turn', () => {
+    const entries = [
+      msg('U', null, 'user'),
+      msg('A', 'U', 'assistant'),
+      entry('C', 'A', 'compaction'),
+      msg('U2', 'C', 'user'),
+    ]
+    const turns = segmentTurns(entries, new Set(['U', 'A', 'C', 'U2']))
+
+    expect(turns).toHaveLength(3)
+    // turn 0：user + assistant
+    expect(turns[0].userEntry?.id).toBe('U')
+    expect(turns[0].isCompaction).toBe(false)
+    expect(turns[0].entries.map((e) => e.id)).toEqual(['U', 'A'])
+    // turn 1：compaction 独立成 turn
+    expect(turns[1].isCompaction).toBe(true)
+    expect(turns[1].userEntry).toBeUndefined()
+    expect(turns[1].entries.map((e) => e.id)).toEqual(['C'])
+    // turn 2：新 user
+    expect(turns[2].userEntry?.id).toBe('U2')
+    expect(turns[2].isCompaction).toBe(false)
+  })
+
+  it('3. model_change / thinking_level_change / custom 并入当前 turn', () => {
+    const entries = [
+      msg('U', null, 'user'),
+      entry('M', 'U', 'model_change'),
+      entry('T', 'M', 'thinking_level_change'),
+      entry('X', 'T', 'custom'),
+    ]
+    const turns = segmentTurns(entries, new Set(['U', 'M', 'T', 'X']))
+
+    expect(turns).toHaveLength(1)
+    expect(turns[0].userEntry?.id).toBe('U')
+    expect(turns[0].entries.map((e) => e.id)).toEqual(['U', 'M', 'T', 'X'])
+  })
+
+  it('4. branch entry（不在 leafSet）不计入', () => {
+    const entries = [
+      msg('U', null, 'user'),
+      msg('A', 'U', 'assistant'),
+      msg('B1', 'U', 'assistant'), // 旁支：不在 leafSet
+      msg('B2', 'B1', 'toolResult'), // 旁支子节点
+    ]
+    const turns = segmentTurns(entries, new Set(['U', 'A']))
+
+    expect(turns).toHaveLength(1)
+    expect(turns[0].entries.map((e) => e.id)).toEqual(['U', 'A'])
+  })
+
+  it('5. 孤儿 assistant（首个 entry 是 assistant 无前置 user）→ 并入 turn 0（preface）', () => {
+    const entries = [msg('O', null, 'assistant'), msg('U', 'O', 'user')]
+    const turns = segmentTurns(entries, new Set(['O', 'U']))
+
+    expect(turns).toHaveLength(2)
+    // turn 0：preface（孤儿 assistant），无 userEntry，非 compaction
+    expect(turns[0].isCompaction).toBe(false)
+    expect(turns[0].userEntry).toBeUndefined()
+    expect(turns[0].entries.map((e) => e.id)).toEqual(['O'])
+    // turn 1：首个 user
+    expect(turns[1].userEntry?.id).toBe('U')
+    expect(turns[1].index).toBe(1)
+  })
+
+  it('6. session header 被忽略（即使在 leafSet 中也不计 turn）', () => {
+    const entries = [
+      entry('S', null, 'session'),
+      msg('U', 'S', 'user'),
+      msg('A', 'U', 'assistant'),
+    ]
+    // S 也在 leafSet，验证规则 1 优先于规则 5
+    const turns = segmentTurns(entries, new Set(['S', 'U', 'A']))
+
+    expect(turns).toHaveLength(1)
+    expect(turns[0].entries.map((e) => e.id)).toEqual(['U', 'A'])
+  })
+
+  it('7. 空 entries → []', () => {
+    expect(segmentTurns([], new Set())).toEqual([])
+  })
+
+  it('startTime 取 turn 首条 entry 的 timestamp', () => {
+    const entries = [
+      { ...msg('U', null, 'user'), timestamp: '2026-05-28T03:17:12.844Z' },
+      msg('A', 'U', 'assistant'),
+    ]
+    const turns = segmentTurns(entries, new Set(['U', 'A']))
+    expect(turns[0].startTime).toBe('2026-05-28T03:17:12.844Z')
+  })
+
+  it.skipIf(!HAS_REAL_SESSION)('真实 019e6c96：leaf 视图分段（26 user + 5 compaction + 1 前置 = 32 turn）', async () => {
+    // 注：design P-outline / plan T1.3 基线为 26（仅数 user 的旧定义）。
+    // 本实现按冻结接口 Turn.isCompaction + design §3.5 算法 3 规则 2（compaction 独立成 turn）
+    // + 规则 4（首 user 前的 model_change/thinking_level_change 成 preface turn），
+    // 真实数据为 32 turn。26 基线早于 compaction-split 细化，详见交接说明。
+    const parsed = await parseSessionFile(REAL_SESSION)
+    const tree = buildTreeView(parsed.entries)
+    const turns = segmentTurns(parsed.entries, new Set(tree.leafPath))
+
+    expect(turns.length).toBe(32)
+    // 首个 turn 是 preface（model_change/thinking_level_change），无 userEntry
+    expect(turns[0].userEntry).toBeUndefined()
+    expect(turns[0].isCompaction).toBe(false)
+    // 其中有 5 个 compaction turn
+    expect(turns.filter((t) => t.isCompaction).length).toBe(5)
+    // 其中有 26 个 user turn
+    expect(turns.filter((t) => t.userEntry !== undefined).length).toBe(26)
+  })
+})