fog-map

1import { atom, derive, read, update } from 'claude-code'
2import type { EngineInterface, Register } from 'claude-code'
3
4import type { FogFile, FogRepo } from '../types'
5import {
6  areaOf,
7  bar,
8  bashTouches,
9  capFiles,
10  countsOf,
11  editChange,
12  errorPaths,
13  importPattern,
14  inRepo,
15  milestoneOf,
16  rowsOf,
17  statusOf,
18  treeOf,
19  warningsOf,
20  withEdit,
21  withError,
22  withRead,
23} from './fog'
24
25const PANE = 'fog-map'
26const TITLE = '探索マップ'
27
28const repo = atom({ plugin: 'fog-map', key: 'repo' } as const, null as FogRepo | null)
29const touched = atom({ plugin: 'fog-map', key: 'touched' } as const, {} as Record<string, FogFile>)
30const focus = atom({ plugin: 'fog-map', key: 'focus' } as const, null as string | null)
31const importers = atom({ plugin: 'fog-map', key: 'importers' } as const, {} as Record<string, string[]>)
32const areas = atom({ plugin: 'fog-map', key: 'areas' } as const, [] as string[])
33const milestone = atom({ plugin: 'fog-map', key: 'milestone' } as const, 0)
34// Built from the file list once each time it changes, not on every call or every draw.
35const tracked = derive([repo], known => new Set(known?.files ?? []))
36const tree = derive([repo], known => treeOf(known?.files ?? []))
37
38const EDIT_TOOLS = new Set(['Edit', 'Write', 'NotebookEdit'])
39// Commands after which the repository's file list is read again.
40const RESHAPES = /\bgit\s+(?:checkout|switch|pull|merge|rebase|mv|rm|stash)\b|\b(?:mv|rm|cp)\s/
41
42async function git($: EngineInterface, cwd: string, argv: string[]): Promise<string | undefined> {
43  const ran = await $.process.run(['git', ...argv], { cwd, timeoutMs: 15_000 }).catch(() => undefined)
44  return ran?.exitCode === 0 ? ran.stdout : undefined
45}
46
47/** The repository the session works in and its files; null outside a git repository. */
48async function loadRepo($: EngineInterface): Promise<void> {
49  const root = (await $.session.repo())?.root
50  if (root === undefined) {
51    await update($, repo, () => null)
52    return
53  }
54  const [listed, branch] = await Promise.all([git($, root, ['ls-files', '-z']), git($, root, ['branch', '--show-current'])])
55  const files = capFiles((listed ?? '').split('\0').filter(Boolean).slice(0, 50_000))
56  const name = root.split('/').filter(Boolean).pop() ?? root
57  await update($, repo, () => ({ root, name, branch: branch?.trim() || 'detached', files }))
58}
59
60/** The repository's root, else the session's directory: paths outside it are not mapped. */
61async function placeOf($: EngineInterface): Promise<{ root: string; cwd: string; files: Set<string> }> {
62  const known = await read($, repo)
63  const cwd = await $.session.cwd()
64  return { root: known?.root ?? cwd, cwd, files: new Set(known?.files ?? []) }
65}
66
67/** Finds, once per edited file, the files importing it (JS/TS and Python, by git grep). */
68async function findImporters($: EngineInterface, path: string): Promise<void> {
69  if ((await read($, importers))[path] !== undefined) return
70  const known = await read($, repo)
71  const pattern = importPattern(path)
72  if (known === null || pattern === undefined) return
73  const out = await git($, known.root, ['grep', '-l', '-E', pattern])
74  const list = (out ?? '').split('\n').filter(line => line !== '' && line !== path).slice(0, 50)
75  await update($, importers, all => ({ ...all, [path]: list }))
76}
77
78/** Marks what a call did, then redraws the status line and announces what is worth a toast. */
79async function mark($: EngineInterface, change: (all: Record<string, FogFile>) => Record<string, FogFile>, last: string | undefined): Promise<void> {
80  const before = await read($, touched)
81  const after = await update($, touched, change)
82  if (last !== undefined) await update($, focus, () => last)
83
84  const known = await read($, repo)
85  const counts = countsOf(after, known?.files ?? [], await read($, tracked))
86  const warnings = warningsOf(after, await read($, importers))
87  $.ui.status(statusOf(counts, warnings.length, known !== null))
88
89  const notes: string[] = []
90  const reached = milestoneOf(await read($, milestone), counts.percent)
91  if (known !== null && reached !== undefined) {
92    await update($, milestone, () => reached)
93    notes.push(`🗺 探索率 ${reached}% 到達`)
94  }
95  const newlyEdited = Object.keys(after).filter(path => (after[path]?.edits ?? 0) > 0 && (before[path]?.edits ?? 0) === 0)
96  const seen = await read($, areas)
97  const fresh = [...new Set(newlyEdited.map(areaOf))].filter(area => !seen.includes(area))
98  if (fresh.length > 0) {
99    await update($, areas, list => [...list, ...fresh])
100    notes.push(`🗺 新しい区域を開拓: ${fresh.join(' ')}`)
101  }
102  if (notes.length > 0) $.ui.toast(notes.join(' · '))
103}
104
105export const register: Register = on => {
106  on('session.start', async ($, e, next) => {
107    await $.command.register({ name: 'map', description: '探索マップを開く: Claude が読んだ・編集したファイルを、未踏の場所を霧にして表示' })
108    const started = await next(e)
109    await loadRepo($).catch(() => undefined)
110    await mark($, all => all, undefined)
111    return started
112  })
113
114  on('tool.call', async ($, e, next) => {
115    const tool = String(e.tool)
116    const input = e as unknown as Record<string, unknown>
117    const isEdit = EDIT_TOOLS.has(tool)
118    if (tool !== 'Read' && tool !== 'Bash' && !isEdit) return next(e)
119
120    const place = await placeOf($)
121    const target = typeof input.file_path === 'string' ? input.file_path : typeof input.notebook_path === 'string' ? input.notebook_path : undefined
122    const path = target === undefined ? undefined : inRepo(target, place.root, place.cwd)
123    // Asked before a Write runs: whether it makes a new file, and what it writes over, so its
124    // lines count as a diff stat would rather than as the whole file added.
125    const before = tool === 'Write' && path !== undefined ? await $.fs.read(`${place.root}/${path}`).catch(() => undefined) : undefined
126    const isNew = tool === 'Write' && path !== undefined && before === undefined
127      ? (await $.fs.stat(`${place.root}/${path}`).catch(() => undefined)) === undefined
128      : false
129
130    const ran = await next(e)
131    if (ran.deny !== undefined) return ran
132    const at = await $.clock.now()
133
134    if (tool === 'Read' && path !== undefined && ran.isError !== true) {
135      await mark($, all => ({ ...all, [path]: withRead(all[path], at) }), path)
136    } else if (isEdit && path !== undefined && ran.isError !== true) {
137      const change =
138        tool === 'Edit'
139          ? editChange(String(input.old_string ?? ''), String(input.new_string ?? ''))
140          : tool === 'Write'
141            ? editChange(typeof before === 'string' ? before : '', String(input.content ?? ''))
142            : editChange('', String(input.new_source ?? ''))
143      await mark($, all => ({ ...all, [path]: withEdit(all[path], { ...change, isNew }, at) }), path)
144      if (isNew) await update($, repo, old => (old === null ? old : { ...old, files: [...old.files, path] }))
145      void findImporters($, path).catch(() => undefined)
146    } else if (tool === 'Bash') {
147      const command = String(input.command ?? '')
148      const known = (word: string, cwd: string) => {
149        const one = inRepo(word, place.root, cwd)
150        return one !== undefined && place.files.has(one) ? one : undefined
151      }
152      const { reads, edits } = bashTouches(command, place.cwd, known)
153      const failed = ran.isError === true ? errorPaths(ran.text ?? '').flatMap(word => known(word, place.cwd) ?? []) : []
154      if (reads.length + edits.length + failed.length > 0) {
155        await mark(
156          $,
157          all => {
158            const marked = { ...all }
159            for (const one of reads) marked[one] = withRead(marked[one], at)
160            for (const one of edits) marked[one] = withEdit(marked[one], { added: 0, removed: 0 }, at)
161            for (const one of failed) marked[one] = withError(marked[one], at)
162            return marked
163          },
164          [...edits, ...reads, ...failed].at(-1),
165        )
166      }
167      if (ran.isError !== true && RESHAPES.test(command)) await loadRepo($).catch(() => undefined)
168    }
169    return ran
170  }).catch(($, e, next) => next(e)) // an observer: a failure here never changes the call
171
172  on('command.run', { command: 'map' }, async $ => {
173    await $.ui.open({ id: PANE, title: TITLE })
174    const known = await read($, repo)
175    const counts = countsOf(await read($, touched), known?.files ?? [], await read($, tracked))
176    return { text: known === null ? `🗺 git リポジトリの外です（編集 ${counts.edited}）` : `🗺 探索率 ${counts.percent}% · ${counts.touched}/${counts.total}` }
177  })
178
179  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
180    const { Box, Text } = $.ui.resolve(e)
181    const known = await read($, repo)
182    const all = await read($, touched)
183    const counts = countsOf(all, known?.files ?? [], await read($, tracked))
184    const warnings = warningsOf(all, await read($, importers))
185    const width = Math.max(30, e.props.bodyColumns - 2)
186    const rows = rowsOf(known?.files ?? [], all, await read($, focus), width, await read($, tree))
187    const room = Math.max(3, (e.viewport?.rows ?? e.props.scroll.bodyRows ?? 24) - 5 - Math.min(3, warnings.length))
188    const color = { error: 'red', new: 'green', edit: 'yellow', 'focus-dir': 'cyan' } as Record<string, string>
189
190    return (
191      <Box flexDirection="column">
192        <Text bold>
193          {known === null
194            ? `🗺 リポジトリの外 · 編 ${counts.edited}`
195            : `🗺 探索率 ${counts.percent}%  ${bar(counts.percent, 20)}  読 ${counts.read} · 編 ${counts.edited} · ✗ ${counts.errors} / ${counts.total}`}
196        </Text>
197        {known !== null && <Text dimColor>{`${known.name} · ${known.branch}`}</Text>}
198        {rows.length === 0 && <Text dimColor>まだどこにも踏み込んでいません。Claude がファイルを読むと霧が晴れていきます。</Text>}
199        {rows.slice(0, room).map((row, index) => (
200          <Text key={`row-${index}`} wrap="truncate-end" color={color[row.kind]} dimColor={row.kind === 'fog'} bold={row.kind === 'dir' || row.kind === 'focus-dir'}>
201            {`${'  '.repeat(row.depth)}${row.text}`}
202          </Text>
203        ))}
204        {rows.length > room && <Text dimColor>{`…ほか ${rows.length - room} 行`}</Text>}
205        {warnings.slice(0, 3).map((note, index) => (
206          <Text key={`warn-${index}`} color="yellow" wrap="truncate-end">{`⚠ ${note}`}</Text>
207        ))}
208        {warnings.length > 3 && <Text dimColor>{`⚠ ほか ${warnings.length - 3} 件`}</Text>}
209        <Text dimColor>░ 未踏  ○ 読んだ  ● 編集  ✚ 新規  ✗ エラー  ★ 直前</Text>
210      </Box>
211    )
212  })
213}
214

1// The map, pure: where a tool call landed in the repository, what it did there, and the
2// tree drawn from it — fog where nothing was touched, marks where something was.
3
4import type { FogFile } from '../types'
5
6export const MILESTONES = [25, 50, 75, 100]
7/** Programs whose file arguments a Bash command reads. */
8const READERS = new Set(['cat', 'sed', 'head', 'tail', 'less', 'more', 'bat', 'nl', 'grep', 'rg', 'awk', 'wc', 'diff', 'cmp', 'jq'])
9
10export const blank = (at: number): FogFile => ({ reads: 0, edits: 0, added: 0, removed: 0, errors: 0, isNew: false, at })
11
12/** A path as the repository names it, or undefined when it lies outside. */
13export function inRepo(path: string, root: string, cwd: string): string | undefined {
14  const full = path.startsWith('/') ? path : `${cwd.replace(/\/+$/, '')}/${path}`
15  const parts: string[] = []
16  for (const part of full.split('/')) {
17    if (part === '' || part === '.') continue
18    if (part === '..') parts.pop()
19    else parts.push(part)
20  }
21  const clean = `/${parts.join('/')}`
22  const base = root.replace(/\/+$/, '')
23  return clean.startsWith(`${base}/`) ? clean.slice(base.length + 1) : undefined
24}
25
26export function withRead(file: FogFile | undefined, at: number): FogFile {
27  const one = file ?? blank(at)
28  return { ...one, reads: one.reads + 1, at }
29}
30
31/** An edit's mark: its lines added and removed, and the errors it answers cleared. */
32export function withEdit(file: FogFile | undefined, change: { added: number; removed: number; isNew?: boolean }, at: number): FogFile {
33  const one = file ?? blank(at)
34  return {
35    ...one,
36    edits: one.edits + 1,
37    added: one.added + change.added,
38    removed: one.removed + change.removed,
39    errors: 0,
40    isNew: one.isNew || change.isNew === true,
41    at,
42  }
43}
44
45export function withError(file: FogFile | undefined, at: number): FogFile {
46  const one = file ?? blank(at)
47  return { ...one, errors: one.errors + 1, at }
48}
49
50/**
51 * The lines a change adds and removes, as a diff stat counts them: lines of the new text
52 * not matched by an equal line of the old, and the old ones left unmatched.
53 */
54export function editChange(oldText: string, newText: string): { added: number; removed: number } {
55  const left = new Map<string, number>()
56  for (const line of oldText === '' ? [] : oldText.split('\n')) left.set(line, (left.get(line) ?? 0) + 1)
57  let added = 0
58  for (const line of newText === '' ? [] : newText.split('\n')) {
59    const count = left.get(line) ?? 0
60    if (count > 0) left.set(line, count - 1)
61    else added += 1
62  }
63  const removed = [...left.values()].reduce((sum, n) => sum + n, 0)
64  return { added, removed }
65}
66
67/** The words of a Bash command, quotes taken off; a best-effort split, not a shell. */
68const words = (part: string): string[] => part.trim().split(/\s+/).map(word => word.replace(/^['"]|['"]$/g, ''))
69
70/**
71 * What a Bash command reads and edits among the given paths: `cat a`, `sed -n 1,9p a`,
72 * `sed -i … a`. A `cd` moves where the parts after it resolve (`cd mods && cat a.ts`);
73 * one into a place it cannot follow (`cd -`, `cd $DIR`) stops it reading further parts.
74 */
75export function bashTouches(
76  command: string,
77  cwd: string,
78  isKnown: (word: string, cwd: string) => string | undefined,
79): { reads: string[]; edits: string[] } {
80  const reads = new Set<string>()
81  const edits = new Set<string>()
82  let here: string | undefined = cwd
83  for (const part of command.split(/&&|\|\||;|\||\n/)) {
84    const [program = '', ...rest] = words(part)
85    if (program === 'cd') {
86      const to = rest[0]
87      here = to === undefined || to === '-' || to.startsWith('~') || to.includes('$') || here === undefined
88        ? undefined
89        : to.startsWith('/') ? to : `${here.replace(/\/+$/, '')}/${to}`
90      continue
91    }
92    const name = program.slice(program.lastIndexOf('/') + 1)
93    if (here === undefined || !READERS.has(name)) continue
94    const isInPlace = name === 'sed' && rest.some(word => /^-[a-zA-Z]*i/.test(word) || word === '--in-place')
95    for (const word of rest) {
96      if (word.startsWith('-')) continue
97      const path = isKnown(word, here)
98      if (path !== undefined) (isInPlace ? edits : reads).add(path)
99    }
100  }
101  return { reads: [...reads], edits: [...edits] }
102}
103
104const PATH_WORD = /[\w.@~+/-]+/g
105const LINE_MARK = /:\d+|\(\d+,\d+\)/y
106const EXTENSION = /^[A-Za-z]\w*$/
107
108/**
109 * Paths a failed command's output names with a line (`a.ts:12`, `a.ts(12,5)`), as candidates.
110 * Linear: each word is read once and only its last dot is tried, the dot a path's extension
111 * must follow; a regex trying every dot of a long word took seconds on a minified line.
112 */
113export function errorPaths(output: string): string[] {
114  const found = new Set<string>()
115  let taken = 0 // where the last mark ended: a path never starts inside one (`a.ts:12.b.ts:3`)
116  for (const word of output.matchAll(PATH_WORD)) {
117    const end = word.index + word[0].length
118    LINE_MARK.lastIndex = end
119    const mark = LINE_MARK.exec(output)
120    if (mark === null) continue
121    const path = output.slice(Math.max(word.index, taken), end)
122    const dot = path.lastIndexOf('.')
123    if (dot < 1 || !EXTENSION.test(path.slice(dot + 1))) continue
124    found.add(path)
125    taken = end + mark[0].length
126  }
127  return [...found]
128}
129
130/**
131 * The `git grep -E` pattern for a file's importers, or undefined for a language it does not
132 * read. POSIX classes only: the git macOS ships matches nothing for `\s`, `\w` or `\b` there.
133 */
134export function importPattern(path: string): string | undefined {
135  const name = path.slice(path.lastIndexOf('/') + 1)
136  const dot = name.lastIndexOf('.')
137  const ext = dot > 0 ? name.slice(dot + 1) : ''
138  const stem = (dot > 0 ? name.slice(0, dot) : name).replace(/[.*+?^${}()|[\]\\]/g, '\\$&')
139  if (['ts', 'tsx', 'js', 'jsx', 'mjs', 'cjs'].includes(ext)) {
140    return String.raw`(from|import|require\()[[:space:]]*\(?['"][^'"]*[/.]${stem}(\.[a-z]+)?['"]`
141  }
142  if (ext === 'py') {
143    // `from pkg.x import y`, `from .x import y`, `import pkg.x`, `import x as y`, `import a, x`.
144    const tail = String.raw`([[:space:],]|$)`
145    return String.raw`^[[:space:]]*(from[[:space:]]+([[:alnum:]_.]*\.)?${stem}${tail}|import[[:space:]]+([[:alnum:]_.,[:space:]]*[[:space:],.])?${stem}${tail})`
146  }
147  return undefined
148}
149
150export type Counts = { read: number; edited: number; errors: number; touched: number; total: number; percent: number }
151
152/** `tracked` is `new Set(files)` from a cache, when there is one: the list is not read again. */
153export function countsOf(touched: Readonly<Record<string, FogFile>>, files: readonly string[], tracked: ReadonlySet<string> = new Set(files)): Counts {
154  const all = Object.entries(touched)
155  const inside = all.filter(([path]) => tracked.has(path) || touched[path]?.isNew === true)
156  const total = tracked.size + all.filter(([path, one]) => one.isNew && !tracked.has(path)).length
157  return {
158    read: all.filter(([, one]) => one.reads > 0 && one.edits === 0).length,
159    edited: all.filter(([, one]) => one.edits > 0).length,
160    errors: all.filter(([, one]) => one.errors > 0).length,
161    touched: inside.length,
162    total,
163    percent: total === 0 ? 0 : Math.floor((inside.length / total) * 100),
164  }
165}
166
167/** The milestone a new percentage crosses, if any. */
168export function milestoneOf(previous: number, percent: number): number | undefined {
169  return MILESTONES.filter(one => one > previous && percent >= one).at(-1)
170}
171
172/** The area a path belongs to, announced the first time it is edited: `mods/zukan/`. */
173export function areaOf(path: string): string {
174  const parts = path.split('/')
175  return parts.length >= 3 ? `${parts[0]}/${parts[1]}/` : parts.length === 2 ? `${parts[0]}/` : './'
176}
177
178/** Files that import an edited one and were never opened: what an edit may have broken unseen. */
179export function warningsOf(touched: Readonly<Record<string, FogFile>>, importers: Readonly<Record<string, string[]>>): string[] {
180  const notes: string[] = []
181  for (const [path, one] of Object.entries(touched)) {
182    if (one.edits > 0 && one.reads === 0 && !one.isNew) notes.push(`編集したのに一度も読んでいない: ${path}`)
183  }
184  const unseen = new Set<string>()
185  for (const [edited, list] of Object.entries(importers)) {
186    if ((touched[edited]?.edits ?? 0) === 0) continue
187    for (const importer of list) {
188      const one = touched[importer]
189      if (one === undefined || (one.reads === 0 && one.edits === 0)) unseen.add(importer)
190    }
191  }
192  for (const path of [...unseen].sort()) notes.push(`編集したファイルを import しているが未読: ${path}`)
193  return notes
194}
195
196export const markOf = (one: FogFile): string => (one.errors > 0 ? '✗' : one.isNew ? '✚' : one.edits > 0 ? '●' : '○')
197
198export function statusOf(counts: Counts, warnings: number, hasRepo: boolean): string {
199  const parts = [hasRepo ? `🗺 ${counts.percent}%` : '🗺', `●${counts.edited}`]
200  if (counts.errors > 0) parts.push(`✗${counts.errors}`)
201  if (warnings > 0) parts.push(`⚠${warnings}`)
202  return parts.join(' · ')
203}
204
205export function bar(percent: number, width = 24): string {
206  const full = Math.round((Math.min(100, Math.max(0, percent)) / 100) * width)
207  return `${'█'.repeat(full)}${'░'.repeat(width - full)}`
208}
209
210/** One row of the drawn tree. */
211export type Row = { depth: number; text: string; kind: 'fog' | 'read' | 'edit' | 'new' | 'error' | 'dir' | 'focus-dir' }
212
213export type Node = { name: string; dirs: Map<string, Node>; files: string[] }
214
215/** The paths as a tree of folders, each name once. */
216export function treeOf(paths: Iterable<string>): Node {
217  const root: Node = { name: '', dirs: new Map(), files: [] }
218  for (const path of new Set(paths)) {
219    const parts = path.split('/')
220    let node = root
221    for (const part of parts.slice(0, -1)) {
222      let next = node.dirs.get(part)
223      if (next === undefined) {
224        next = { name: part, dirs: new Map(), files: [] }
225        node.dirs.set(part, next)
226      }
227      node = next
228    }
229    node.files.push(parts.at(-1) ?? path)
230  }
231  return root
232}
233
234function hasPath(tree: Node, path: string): boolean {
235  const parts = path.split('/')
236  let node: Node | undefined = tree
237  for (const part of parts.slice(0, -1)) node = node?.dirs.get(part)
238  return node !== undefined && node.files.includes(parts.at(-1) ?? path)
239}
240
241/**
242 * `base` with `paths` it lacks added, as treeOf would have placed them after its own. The
243 * folders on their way are copied, so `base`, kept in a cache, is never changed.
244 */
245function withPaths(base: Node, paths: readonly string[]): Node {
246  const root: Node = { ...base, dirs: new Map(base.dirs), files: [...base.files] }
247  const copied = new Set<Node>([root])
248  for (const path of paths) {
249    const parts = path.split('/')
250    let node = root
251    for (const part of parts.slice(0, -1)) {
252      const found = node.dirs.get(part)
253      let next: Node
254      if (found === undefined) next = { name: part, dirs: new Map(), files: [] }
255      else if (copied.has(found)) next = found
256      else next = { ...found, dirs: new Map(found.dirs), files: [...found.files] }
257      copied.add(next)
258      node.dirs.set(part, next)
259      node = next
260    }
261    const name = parts.at(-1) ?? path
262    if (!node.files.includes(name)) node.files.push(name)
263  }
264  return root
265}
266
267const signed = (one: FogFile): string => (one.edits > 0 ? `+${one.added} −${one.removed}` : '')
268
269/**
270 * The tree as rows: a directory holding an edit, a new file or an error is open; one only
271 * read is closed with its marks beside it; untouched directories and files at a level are
272 * one fog row. The ★ goes on the file touched last.
273 */
274export function rowsOf(
275  files: readonly string[],
276  touched: Readonly<Record<string, FogFile>>,
277  focus: string | null,
278  width: number,
279  tree?: Node,
280): Row[] {
281  const rows: Row[] = []
282  // `tree` is treeOf(files) from a cache: only the touched paths it lacks are added, on a copy.
283  const root = tree === undefined ? treeOf([...files, ...Object.keys(touched)]) : withPaths(tree, Object.keys(touched).filter(path => !hasPath(tree, path)))
284
285  // Each folder's marks are gathered once: an open folder's are not gathered again for each level
286  // above it, and a folder holding no touched path is never read through.
287  const holding = new Set<string>()
288  for (const path of Object.keys(touched)) {
289    for (let at = path.indexOf('/'); at >= 0; at = path.indexOf('/', at + 1)) holding.add(path.slice(0, at + 1))
290  }
291  const gathered = new Map<Node, FogFile[]>()
292  const marksUnder = (node: Node, prefix: string): FogFile[] => {
293    if (prefix !== '' && !holding.has(prefix)) return []
294    const known = gathered.get(node)
295    if (known !== undefined) return known
296    const marks = [
297      ...node.files.flatMap(name => (touched[`${prefix}${name}`] ? [touched[`${prefix}${name}`] as FogFile] : [])),
298      ...[...node.dirs.values()].flatMap(dir => marksUnder(dir, `${prefix}${dir.name}/`)),
299    ]
300    gathered.set(node, marks)
301    return marks
302  }
303
304  const walk = (node: Node, prefix: string, depth: number) => {
305    const fog: string[] = []
306    for (const dir of [...node.dirs.values()].sort((a, b) => a.name.localeCompare(b.name))) {
307      const path = `${prefix}${dir.name}/`
308      const marks = marksUnder(dir, path)
309      if (marks.length === 0) {
310        fog.push(`${dir.name}/`)
311        continue
312      }
313      const isOpen = marks.some(one => one.edits > 0 || one.errors > 0 || one.isNew)
314      const hasFocus = focus !== null && focus.startsWith(path)
315      if (!isOpen) {
316        rows.push({ depth, text: `▸ ${dir.name}/  ${marks.map(markOf).join('')}`, kind: hasFocus ? 'focus-dir' : 'dir' })
317        continue
318      }
319      rows.push({ depth, text: `▾ ${dir.name}/`, kind: hasFocus ? 'focus-dir' : 'dir' })
320      walk(dir, path, depth + 1)
321    }
322    for (const name of [...node.files].sort()) {
323      const path = `${prefix}${name}`
324      const one = touched[path]
325      if (one === undefined) {
326        fog.push(name)
327        continue
328      }
329      const details = [
330        signed(one),
331        one.edits > 1 ? `編集 ${one.edits}回` : '',
332        one.isNew ? '新規' : '',
333        one.errors > 0 ? `エラー ${one.errors}` : '',
334        path === focus ? '★' : '',
335      ].filter(Boolean)
336      const kind = one.errors > 0 ? 'error' : one.isNew ? 'new' : one.edits > 0 ? 'edit' : 'read'
337      rows.push({ depth, text: `${markOf(one)} ${name}${details.length > 0 ? `  ${details.join('  ')}` : ''}`, kind })
338    }
339    if (fog.length > 0) {
340      const room = Math.max(10, width - depth * 2)
341      let line = ''
342      let shown = 0
343      for (const name of fog) {
344        const next = `${line}${line === '' ? '' : '  '}░ ${name}`
345        if (next.length > room - 6 && line !== '') break
346        line = next
347        shown += 1
348      }
349      rows.push({ depth, text: shown < fog.length ? `${line}  …${fog.length - shown}` : line, kind: 'fog' })
350    }
351  }
352
353  walk(root, '', 0)
354  return rows
355}
356
357// The repository's files are kept in one state value, which the engine holds to 4,194,304
358// characters of JSON: past this the list is cut, so the write is never refused and the
359// repository never taken for none.
360export const MAX_FILES_CHARS = 3_000_000
361
362/** The files a state value can hold, in the order git lists them. */
363export function capFiles(files: readonly string[]): string[] {
364  const kept: string[] = []
365  let size = 2
366  for (const file of files) {
367    const next = JSON.stringify(file).length + 1
368    if (size + next > MAX_FILES_CHARS) break
369    size += next
370    kept.push(file)
371  }
372  return kept
373}
374

1/** What the session did to one file of the repository. */
2export type FogFile = {
3  /** Times it was read (Read, or a reader such as cat or sed in Bash). */
4  reads: number
5  /** Times it was edited (Edit, Write, NotebookEdit, sed -i). */
6  edits: number
7  /** Lines added and removed by those edits, as the edits' own text counts them. */
8  added: number
9  removed: number
10  /** Errors a failed Bash command named it in since it was last edited. */
11  errors: number
12  /** Made by this session: it did not exist before the first write. */
13  isNew: boolean
14  /** When it was last touched. */
15  at: number
16}
17
18/** The repository the map is of. */
19export type FogRepo = {
20  root: string
21  name: string
22  branch: string
23  /** Its files, repository-relative, as `git ls-files` lists them. */
24  files: string[]
25}
26
27declare module 'claude-code' {
28  interface PluginState {
29    'fog-map': {
30      repo: FogRepo | null
31      /** Repository-relative path to what the session did to it. */
32      touched: Record<string, FogFile>
33      /** The file touched last: the map's ★. */
34      focus: string | null
35      /** Edited file to the files that import it, as git grep found them. */
36      importers: Record<string, string[]>
37      /** Areas already announced, and the highest milestone reached (percent). */
38      areas: string[]
39      milestone: number
40    }
41  }
42}
43