changed-files

1import { atom, read, update } from 'claude-code'
2import type { Register } from 'claude-code'
3
4import { changeOf } from './diff'
5import type { FileResult } from './diff'
6import { merge } from './merge'
7
8const PANE = 'changed-files'
9const files = atom({ plugin: 'changed-files', key: 'files' } as const, [])
10const cwd = atom({ plugin: 'changed-files', key: 'cwd' } as const, '')
11
12export const register: Register = on => {
13  on('session.start', async ($, e, next) => {
14    await $.command.register({
15      name: 'changed-files',
16      description: 'Changed Files: open the sidebar of files Claude touched this session',
17      immediate: true,
18    })
19    await update($, cwd, () => e.cwd)
20
21    return next(e)
22  })
23
24  on('tool.call', async ($, e, next) => {
25    if (e.tool !== 'Edit' && e.tool !== 'Write') return next(e)
26
27    const ran = await next(e)
28    if (ran.deny !== undefined || ran.isError === true) return ran
29
30    const change = changeOf(ran.result as FileResult, await read($, cwd))
31    if (change !== null) {
32      const wasEmpty = (await read($, files)).length === 0
33      await update($, files, list => merge(list, change))
34      if (wasEmpty) void $.ui.open({ id: PANE, title: 'Changed files' })
35    }
36
37    return ran
38  })
39
40  on('session.end', async ($, e, next) => {
41    if (e.reason === 'clear') await update($, files, () => [])
42
43    return next(e)
44  })
45
46  on('command.run', { command: 'changed-files' }, async $ => {
47    await $.ui.open({ id: PANE, title: 'Changed files' })
48    const count = (await read($, files)).length
49
50    return { text: `Changed Files: ${count} file${count === 1 ? '' : 's'} touched this session.` }
51  })
52
53  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
54    const { Box, Button, Text } = $.ui.resolve(e)
55    const list = await read($, files)
56
57    if (list.length === 0) {
58      return <Text dimColor>No files touched yet this session.</Text>
59    }
60
61    const added = list.reduce((sum, one) => sum + one.added, 0)
62    const removed = list.reduce((sum, one) => sum + one.removed, 0)
63    const width = Math.max(...list.map(one => `+${one.added}`.length + `−${one.removed}`.length + 1))
64
65    return (
66      <Box flexDirection="column">
67        <Box flexDirection="row" gap={1}>
68          <Text bold>
69            {list.length} file{list.length === 1 ? '' : 's'}
70          </Text>
71          <Text color="green">+{added}</Text>
72          <Text color="red">−{removed}</Text>
73        </Box>
74        {list.map(one => (
75          <Box flexDirection="row" gap={1}>
76            <Box width={width} flexShrink={0}>
77              <Text color="green">+{one.added}</Text>
78              <Text> </Text>
79              <Text color="red">−{one.removed}</Text>
80            </Box>
81            <Text wrap="truncate-start">{one.path}</Text>
82            {one.isNew && <Text color="cyan">new</Text>}
83            {one.edits > 1 && <Text dimColor>×{one.edits}</Text>}
84          </Box>
85        ))}
86        <Box marginTop={1}>
87          <Button key="reset" label="reset" onPress={() => update($, files, () => [])} />
88        </Box>
89      </Box>
90    )
91  })
92}
93

1export type Hunk = {
2  oldStart: number
3  oldLines: number
4  newStart: number
5  newLines: number
6  lines: readonly string[]
7}
8
9/** The parts of an Edit or Write result a diff is built from. */
10export type FileResult = {
11  filePath: string
12  structuredPatch: readonly Hunk[]
13  originalFile: string | null
14  content?: string
15  type?: 'create' | 'update'
16  staged?: boolean
17}
18
19export type Change = {
20  file: string
21  kind: 'edit' | 'create' | 'overwrite'
22  diff: string
23  added: number
24  removed: number
25  isCut: boolean
26}
27
28/** Code renders at most 10000 characters; leave room for the hunk headers. */
29const MAX_SOURCE = 9000
30
31function header(hunk: Hunk): string {
32  return `@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`
33}
34
35function recount(hunk: Hunk, lines: readonly string[]): Hunk {
36  const oldLines = lines.filter(line => !line.startsWith('+')).length
37  const newLines = lines.filter(line => !line.startsWith('-')).length
38  return { ...hunk, oldLines, newLines, lines }
39}
40
41/** Joins hunks into unified-diff text, cutting whole lines (headers kept valid) past the limit. */
42export function toSource(hunks: readonly Hunk[], limit = MAX_SOURCE): { source: string; isCut: boolean } {
43  let source = ''
44  for (const hunk of hunks) {
45    const whole = `${header(hunk)}\n${hunk.lines.join('\n')}\n`
46    if (source.length + whole.length <= limit) {
47      source += whole
48      continue
49    }
50    if (source === '') {
51      const kept: string[] = []
52      let size = 40
53      for (const line of hunk.lines) {
54        if (size + line.length + 1 > limit) break
55        kept.push(line)
56        size += line.length + 1
57      }
58      const cut = recount(hunk, kept)
59      source = `${header(cut)}\n${kept.join('\n')}\n`
60    }
61    return { source, isCut: true }
62  }
63  return { source, isCut: false }
64}
65
66function creationHunk(content: string): Hunk {
67  const lines = content.split('\n')
68  if (lines.length > 0 && lines[lines.length - 1] === '') lines.pop()
69  return { oldStart: 0, oldLines: 0, newStart: 1, newLines: lines.length, lines: lines.map(line => `+${line}`) }
70}
71
72export function relative(path: string, cwd: string | undefined): string {
73  if (cwd === undefined || cwd === '') return path
74  const root = cwd.endsWith('/') ? cwd : `${cwd}/`
75  return path.startsWith(root) ? path.slice(root.length) : path
76}
77
78/** The change an Edit or Write made, or null when it wrote nothing (staged for review). */
79export function changeOf(result: FileResult, cwd?: string): Change | null {
80  if (result.staged === true) return null
81
82  const isCreate = result.type === 'create' || (result.type !== undefined && result.originalFile === null)
83  const hunks =
84    result.structuredPatch.length === 0 && isCreate && result.content !== undefined
85      ? [creationHunk(result.content)]
86      : result.structuredPatch
87  const lines = hunks.flatMap(hunk => hunk.lines)
88  const { source, isCut } = toSource(hunks)
89
90  return {
91    file: relative(result.filePath, cwd),
92    kind: result.type === undefined ? 'edit' : isCreate ? 'create' : 'overwrite',
93    diff: source,
94    added: lines.filter(line => line.startsWith('+')).length,
95    removed: lines.filter(line => line.startsWith('-')).length,
96    isCut,
97  }
98}
99

1import type { ChangedFile } from '../types'
2import type { Change } from './diff'
3
4/** Adds one change to the list, moving its file to the top. */
5export function merge(list: readonly ChangedFile[], change: Change): ChangedFile[] {
6  const before = list.find(one => one.path === change.file)
7  const next: ChangedFile = {
8    path: change.file,
9    added: (before?.added ?? 0) + change.added,
10    removed: (before?.removed ?? 0) + change.removed,
11    edits: (before?.edits ?? 0) + 1,
12    isNew: before?.isNew ?? change.kind === 'create',
13  }
14  return [next, ...list.filter(one => one.path !== change.file)]
15}
16

1export type ChangedFile = {
2  path: string
3  added: number
4  removed: number
5  edits: number
6  isNew: boolean
7}
8
9declare module 'claude-code' {
10  interface PluginState {
11    'changed-files': {
12      /** Most recently touched first. */
13      files: ChangedFile[]
14      cwd: string
15    }
16  }
17}
18