replay

1import { atom, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { Step } from '../types'
5import { createdHunk, toPatch } from './patch'
6import type { Hunk } from './patch'
7
8const pending = atom({ plugin: 'replay', key: 'pending' } as const, [])
9const steps = atom({ plugin: 'replay', key: 'steps' } as const, [])
10const at = atom({ plugin: 'replay', key: 'at' } as const, 0)
11// The band offering the replay, from a turn with edits to the next prompt.
12const hint = atom({ plugin: 'replay', key: 'hint' } as const, false)
13// The replay itself, drawn in the band above the prompt: a pane would dock
14// beside a fullscreen transcript, and its placement is not the mod's to pick.
15const isOpen = atom({ plugin: 'replay', key: 'isOpen' } as const, false)
16
17const openReplay = async ($: EngineInterface) => {
18  if ((await read($, steps)).length === 0) return false
19  await update($, at, () => 0)
20  await update($, hint, () => false)
21  await update($, isOpen, () => true)
22  return true
23}
24
25const go = async ($: EngineInterface, d: number) => {
26  const last = (await read($, steps)).length - 1
27  await update($, at, n => Math.max(0, Math.min(last, n + d)))
28}
29const close = ($: EngineInterface) => update($, isOpen, () => false)
30
31export const register: Register = on => {
32  on('session.start', async ($, e, next) => {
33    const r = await next(e)
34    await $.command.register({ name: 'replay', description: "Step through the last turn's file edits" })
35    return r
36  })
37
38  on('command.run', { command: 'replay' }, async $ => ({
39    text: (await openReplay($)) ? 'Replay des éditions du dernier tour.' : 'Aucune édition au dernier tour.',
40  }))
41
42  // Observes only: the edit runs as it would, its own patch is recorded.
43  on('tool.call', async ($, e, next) => {
44    const r = await next(e)
45    if ((e.tool !== 'Edit' && e.tool !== 'Write') || r.deny !== undefined || r.isError) return r
46    const result = r.result as { filePath: string; structuredPatch?: Hunk[]; type?: string; content?: string }
47    const hunks = result.structuredPatch?.length
48      ? result.structuredPatch
49      : result.type === 'create' && result.content !== undefined
50        ? [createdHunk(result.content)]
51        : []
52    if (hunks.length) {
53      const step: Step = { tool: e.tool, path: result.filePath, ...toPatch(hunks) }
54      await update($, pending, list => [...list, step])
55    }
56    return r
57  })
58
59  // turn.start is the main loop's alone; a subagent's edits join its turn.
60  on('turn.start', async ($, e, next) => {
61    await update($, pending, () => [])
62    return next(e)
63  })
64
65  on('turn.complete', async ($, e, next) => {
66    const r = await next(e)
67    const recorded = await read($, pending)
68    // Every main turn replaces the replay, an empty one included: /replay
69    // is the last turn's, never an older one's.
70    if (!e.agentId) {
71      await update($, steps, () => recorded)
72      if (recorded.length) await update($, hint, () => true)
73    }
74    return r
75  })
76
77  // A letter typed at the prompt never presses a band Button, so the keys are
78  // caught here, in an empty prompt only: `r` opens the replay from the hint,
79  // then `n`, `p` and `q` step and close it. None of them reach the box.
80  on('prompt.edit', async ($, e, next) => {
81    const key = e.text === '' ? e.inputText.toLowerCase() : ''
82    const consumed = { text: e.text, cursor: e.cursor }
83    if (await read($, isOpen)) {
84      if (key === 'n') return (await go($, 1), consumed)
85      if (key === 'p') return (await go($, -1), consumed)
86      if (key === 'q') return (await close($), consumed)
87    } else if (key === 'r' && (await read($, hint)) && (await openReplay($))) return consumed
88    return next(e)
89  })
90
91  // Any prompt sent takes the hint and the replay down.
92  on('prompt.submit', async ($, e, next) => {
93    await update($, hint, () => false)
94    await close($)
95    return next(e)
96  })
97
98  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) => {
99    const list = await read($, steps)
100    if (e.props.hasSurvey || list.length === 0) return next(e)
101    const { Box, Text, Button, Code } = $.ui.resolve(e)
102
103    if (await read($, isOpen)) {
104      const i = Math.min(await read($, at), list.length - 1)
105      const step = list[i]!
106      return (
107        <Box flexDirection="column" borderStyle="round" borderColor="magenta">
108          <Text>
109            {list.map((_, n) => (
110              <Text color={n === i ? 'magenta' : undefined} dimColor={n !== i}>
111                {' '}
112                {n + 1}
113              </Text>
114            ))}
115            {'  '}
116            {step.tool} <Text dimColor>{step.path}</Text>
117          </Text>
118          {step.patch ? (
119            <Code format="diff" source={step.patch} path={step.path} />
120          ) : (
121            <Text dimColor>diff trop long pour s'afficher</Text>
122          )}
123          {step.omitted > 0 && <Text dimColor>… {step.omitted} bloc(s) non affichés</Text>}
124          <Box>
125            <Button key="prev" label="préc." hotkey="p" plain onPress={() => void go($, -1)} />
126            <Text> </Text>
127            <Button key="next" label="suiv." hotkey="n" plain onPress={() => void go($, 1)} />
128            <Text> </Text>
129            <Button key="close" label="fermer" hotkey="q" plain onPress={() => void close($)} />
130          </Box>
131        </Box>
132      )
133    }
134
135    if (!(await read($, hint))) return next(e)
136    return (
137      <Box>
138        <Text color="magenta">↺ {list.length} édition(s) au dernier tour · </Text>
139        <Button key="replay" label="rejouer" hotkey="r" plain onPress={() => void openReplay($)} />
140        <Text dimColor> (ou /replay)</Text>
141      </Box>
142    )
143  })
144}
145

1export type Hunk = { oldStart: number; oldLines: number; newStart: number; newLines: number; lines: string[] }
2
3// `Code format="diff"` takes at most 10000 characters and refuses a hunk cut
4// in the middle, so whole hunks are kept while they fit; the rest is counted.
5const LIMIT = 10_000
6// Tab and newline are the only control characters Code accepts.
7const CONTROL = /[\x00-\x08\x0b-\x1f\x7f]/g
8
9export const toPatch = (hunks: readonly Hunk[]) => {
10  let patch = ''
11  let omitted = 0
12  for (const h of hunks) {
13    const text = `@@ -${h.oldStart},${h.oldLines} +${h.newStart},${h.newLines} @@\n${h.lines.join('\n')}`.replace(CONTROL, "")
14    const next = patch ? `${patch}\n${text}` : text
15    if (next.length > LIMIT) omitted++
16    else patch = next
17  }
18  return { patch, omitted }
19}
20
21// A Write that created a file may come back with no hunks: the whole content is added.
22export const createdHunk = (content: string): Hunk => {
23  const lines = content.replace(/\n$/, '').split('\n')
24  return { oldStart: 0, oldLines: 0, newStart: 1, newLines: lines.length, lines: lines.map(l => `+${l}`) }
25}
26

1// One file edit of a turn: the tool, the file, its unified-diff hunks.
2export type Step = { tool: string; path: string; patch: string; omitted: number }
3
4declare module 'claude-code' {
5  interface PluginState {
6    replay: { pending: Step[]; steps: Step[]; at: number; hint: boolean; isOpen: boolean }
7  }
8}
9