@g3nomaly/g3n-mods 0.1.3 → 0.1.5

package/mods/delete-guard/hooks/register.tsx

@@ -0,0 +1,585 @@
+// packages/g3n-mods/mods/delete-guard/hooks/register.tsx
+import { atom, read, update } from 'claude-code'
+import type { EngineInterface, Register } from 'claude-code'
+
+import type { Answer, BlastRadius, Deletion, DoomedFile } from '../types'
+
+const isOn = atom({ plugin: 'delete-guard', key: 'isOn' } as const, false)
+
+const PANE = 'delete-guard'
+const TITLE = 'Delete guard'
+const HOLD_TITLE = 'Delete?'
+
+/** Key in the plugin's store that remembers the switch between sessions. */
+const STORE_KEY = 'isOn'
+
+/** How long a delete waits on the card before it is refused unanswered. */
+const HOLD_MS = 5 * 60_000
+
+/** Most files one delete's walk counts before it stops. */
+const MAX_FILES = 5000
+
+/** File rows the card shows before its "Show more" button. */
+const SHOWN_FILES = 8
+
+/** Approximate pixel width of one cell of the editor's code font. */
+const CELL_PX = 7
+
+const RED = '#e06c6c'
+const ORANGE = '#e0775a'
+const TRACK = '#2b3240'
+const CHIP = '#4a2626'
+const WARN_BG = '#3a2222'
+const WARN_EDGE = '#7a3b3b'
+const UNTRACKED_BG = '#6b3a22'
+
+/** Shell syntax that starts a new command: `&&`, `||`, `;`, `|`, a newline, `$(` and a backtick. */
+const SEGMENT_BREAK = /&&|\|\||;|\||\n|\$\(|`/
+
+/** Words that run the command after them: `sudo rm`, `xargs -0 rm`, `env X=1 rm`. */
+const PREFIX = /^(?:\w+=\S*\s+|(?:sudo|command|exec|nice|nohup|time|env)\s+(?:-\S+\s+)*|xargs\s+(?:-\S+\s+)*)+/
+
+const DELETERS = new Set(['rm', 'shred', 'unlink', 'rimraf', 'srm'])
+
+/** Trash commands in order of preference, with how each one is spelled. */
+const TRASH_COMMANDS = [
+  { probe: 'trash', spell: 'trash' },
+  { probe: 'trash-put', spell: 'trash-put' },
+  { probe: 'gio', spell: 'gio trash' },
+] as const
+
+/**
+ * Splits a shell command line into its commands, each trimmed.
+ *
+ * @param command - Shell command line, e.g. `cd build && rm -rf dist`.
+ * @returns The non-empty commands in order.
+ */
+function segments(command: string): string[] {
+  return command.split(SEGMENT_BREAK).map(part => part.trim()).filter(part => part.length > 0)
+}
+
+/**
+ * Splits one command into words, dropping its prefixes and the program's directory.
+ *
+ * @param segment - One command, as `segments` returns it.
+ * @returns The program name first, then its arguments.
+ */
+function words(segment: string): string[] {
+  const [program = '', ...rest] = segment.replace(PREFIX, '').split(/\s+/)
+  return [program.split('/').pop() ?? program, ...rest]
+}
+
+/**
+ * Picks the operands of a command: every word that is not a flag, and every word after `--`.
+ *
+ * @param args - Words after the program name.
+ * @returns The operands in order.
+ */
+function operands(args: readonly string[]): string[] {
+  const end = args.indexOf('--')
+  const flagged = end === -1 ? args : args.slice(0, end)
+  const after = end === -1 ? [] : args.slice(end + 1)
+  return [...flagged.filter(arg => !arg.startsWith('-')), ...after]
+}
+
+/**
+ * @brief Finds the first permanent delete in a shell command line.
+ *
+ * Recognises `rm`, `shred`, `unlink`, `rimraf`, `find -delete`, `find -exec rm`
+ * and a forced `git clean`.
+ *
+ * @param command - Full shell command line, as the Bash tool received it.
+ * @returns The delete and what it removes, or `undefined` when nothing is deleted for good.
+ */
+export function findDeletion(command: string): Deletion | undefined {
+  for (const segment of segments(command)) {
+    const [program = '', ...args] = words(segment)
+    if (DELETERS.has(program)) {
+      return { segment, kind: 'files', paths: operands(args) }
+    }
+    if (program === 'find' && (args.includes('-delete') || /-exec(?:dir)?\s+(?:\S*\/)?rm\b/.test(segment))) {
+      return { segment, kind: 'find', paths: [] }
+    }
+    if (program === 'git' && args[0] === 'clean' && args.some(arg => /^-\w*f/.test(arg) || arg === '--force')) {
+      return { segment, kind: 'git-clean', paths: [] }
+    }
+  }
+  return undefined
+}
+
+/**
+ * Builds the command Claude should run instead of a permanent delete.
+ *
+ * @param deletion - Delete to replace, see `Deletion`.
+ * @param trash - Trash command spelled as this machine has it, e.g. `gio trash`.
+ * @returns The suggested command, with `<paths>` where no path was named.
+ */
+function insteadOf(deletion: Deletion, trash: string): string {
+  switch (deletion.kind) {
+    case 'files':
+      return deletion.paths.length > 0 ? `${trash} ${deletion.paths.join(' ')}` : `${trash} <paths>`
+    case 'find':
+      return `${deletion.segment.replace(/\s-delete\b/, '').replace(/-exec(?:dir)?\s+.*$/, '')} -exec ${trash} {} +`.replace(/\s+/g, ' ')
+    case 'git-clean':
+      return `git clean -n to list the files, then ${trash} <paths>`
+  }
+}
+
+/**
+ * Finds the first trash command on this machine's PATH.
+ *
+ * @param $ - Engine handle the hook received, see `EngineInterface`.
+ * @returns The command as it should be spelled, or `undefined` when none is installed.
+ */
+async function detectTrash($: EngineInterface): Promise<string | undefined> {
+  for (const candidate of TRASH_COMMANDS) {
+    const found = await $.process.run(['sh', '-c', `command -v ${candidate.probe}`]).catch(() => undefined)
+    if (found?.exitCode === 0) return candidate.spell
+  }
+  return undefined
+}
+
+/**
+ * Strips one pair of matching quotes around a shell word.
+ *
+ * @param word - Word as the command spelled it, e.g. `"build dir"`.
+ * @returns The word without its quotes.
+ */
+function unquote(word: string): string {
+  return /^(['"]).*\1$/.test(word) ? word.slice(1, -1) : word
+}
+
+/**
+ * Writes a path relative to the session's directory when it lies inside it.
+ *
+ * @param cwd - Session's directory, absolute.
+ * @param path - Path to shorten, absolute or relative.
+ * @returns The path without `./` and without the `cwd` prefix.
+ */
+function relativeTo(cwd: string, path: string): string {
+  const prefix = cwd.endsWith('/') ? cwd : `${cwd}/`
+  const inside = path.startsWith(prefix) ? path.slice(prefix.length) : path
+  return inside.replace(/^(\.\/)+/, '')
+}
+
+/**
+ * Turns a shell glob's last segment into a regular expression: `*`, `?` and `[...]`.
+ *
+ * @param glob - One path segment, e.g. `*.log`.
+ * @returns The matching expression, anchored at both ends.
+ */
+function globRegExp(glob: string): RegExp {
+  const body = glob.replace(/[.+^${}()|\\]/g, '\\$&').replace(/\*/g, '.*').replace(/\?/g, '.')
+  return new RegExp(`^${body}$`)
+}
+
+/**
+ * Expands one operand of a delete into the paths it names: `~` to the home directory, and a glob in its last segment.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param operand - Operand as the command spelled it.
+ * @param home - Home directory, for `~`.
+ * @returns The paths, empty when a glob matches nothing.
+ */
+async function expandOperand($: EngineInterface, operand: string, home: string): Promise<string[]> {
+  const path = unquote(operand).replace(/^~(?=\/|$)/, home)
+  if (!/[*?[]/.test(path)) return [path]
+  const cut = path.lastIndexOf('/')
+  const dir = cut === -1 ? '.' : path.slice(0, cut) || '/'
+  const pattern = globRegExp(path.slice(cut + 1))
+  const entries = await $.fs.list(dir).catch(() => [])
+  return entries
+    .filter(entry => pattern.test(entry.name) && !entry.name.startsWith('.'))
+    .map(entry => (cut === -1 ? entry.name : `${path.slice(0, cut)}/${entry.name}`))
+}
+
+/**
+ * Walks a path as a recursive delete would and adds every file under it; links count as files and are not followed.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param path - File or directory to walk.
+ * @param found - Files found so far, as path and size; added to.
+ * @returns False once `MAX_FILES` is reached, so the caller stops.
+ */
+async function walk($: EngineInterface, path: string, found: { path: string; size: number }[]): Promise<boolean> {
+  const stat = await $.fs.stat(path).catch(() => undefined)
+  if (stat === undefined) return true
+  if (stat.isLink || stat.kind !== 'dir') {
+    found.push({ path, size: stat.isLink ? 0 : stat.size })
+    return found.length < MAX_FILES
+  }
+  for (const entry of await $.fs.list(path).catch(() => [])) {
+    const child = `${path.replace(/\/$/, '')}/${entry.name}`
+    if (entry.kind === 'dir' && !entry.isLink) {
+      if (!(await walk($, child, found))) return false
+    } else {
+      found.push({ path: child, size: entry.size })
+      if (found.length >= MAX_FILES) return false
+    }
+  }
+  return true
+}
+
+/**
+ * Lists the paths a `find` delete or a forced `git clean` would remove, by running the same command without deleting.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param deletion - A delete of kind `find` or `git-clean`.
+ * @returns The paths, or `undefined` when the listing failed.
+ */
+async function listedPaths($: EngineInterface, deletion: Deletion): Promise<string[] | undefined> {
+  const argv = words(deletion.segment).map(unquote)
+  if (deletion.kind === 'git-clean') {
+    const flags = argv.slice(2)
+      .filter(arg => arg !== '--force')
+      .map(arg => (/^-[^-]/.test(arg) ? arg.replace(/f/g, '') : arg))
+      .filter(arg => arg !== '-')
+    const ran = await $.process.run(['git', 'clean', '-n', ...flags], { timeoutMs: 10_000 }).catch(() => undefined)
+    if (ran?.exitCode !== 0) return undefined
+    return ran.stdout.split('\n').map(line => line.replace(/^Would remove /, '').trim()).filter(line => line !== '')
+  }
+  const kept: string[] = []
+  for (let i = 0; i < argv.length; i++) {
+    const arg = argv[i] ?? ''
+    if (arg === '-delete') continue
+    if (arg === '-exec' || arg === '-execdir') {
+      while (i < argv.length && !/^(\\?;|\+)$/.test(argv[i] ?? '')) i++
+      continue
+    }
+    kept.push(arg)
+  }
+  const ran = await $.process.run([...kept, '-print'], { timeoutMs: 10_000 }).catch(() => undefined)
+  if (ran?.exitCode !== 0) return undefined
+  return ran.stdout.split('\n').filter(line => line !== '')
+}
+
+/**
+ * Finds the files under `paths` that git tracks, which `git checkout` can bring back.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param paths - Roots of the delete, relative to the session's directory or absolute.
+ * @returns Tracked paths relative to the session's directory; empty outside a repository.
+ */
+async function trackedFiles($: EngineInterface, paths: readonly string[]): Promise<Set<string>> {
+  const ran = await $.process.run(['git', 'ls-files', '-z', '--', ...paths], { timeoutMs: 10_000 }).catch(() => undefined)
+  if (ran?.exitCode !== 0) return new Set()
+  return new Set(ran.stdout.split('\0').filter(path => path !== ''))
+}
+
+/**
+ * @brief Measures what a delete would remove: every file, its size, and whether git can restore it.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param deletion - Delete to measure, see `findDeletion`.
+ * @param cwd - Session's directory, absolute.
+ * @param home - Home directory, for `~`.
+ * @returns The files largest first, with their total; `isKnown` false when they could not be listed.
+ */
+async function measure($: EngineInterface, deletion: Deletion, cwd: string, home: string): Promise<BlastRadius> {
+  const roots = deletion.kind === 'files'
+    ? (await Promise.all(deletion.paths.map(operand => expandOperand($, operand, home)))).flat()
+    : await listedPaths($, deletion)
+  if (roots === undefined) return { files: [], total: 0, isCut: false, isKnown: false }
+
+  const found: { path: string; size: number }[] = []
+  let isCut = false
+  for (const root of roots) {
+    if (!(await walk($, root, found))) {
+      isCut = true
+      break
+    }
+  }
+  const tracked = deletion.kind === 'git-clean' || roots.length === 0 ? new Set<string>() : await trackedFiles($, roots)
+  const files: DoomedFile[] = found
+    .map(file => {
+      const path = relativeTo(cwd, file.path)
+      return { path, size: file.size, isTracked: tracked.has(path) }
+    })
+    .sort((a, b) => b.size - a.size)
+  return { files, total: files.reduce((sum, file) => sum + file.size, 0), isCut, isKnown: true }
+}
+
+/** Formats bytes as the card shows them: `B`, whole `KB`, or `MB` and `GB` with one decimal. */
+function bytes(size: number): string {
+  if (size < 1024) return `${size} B`
+  if (size < 1024 ** 2) return `${Math.round(size / 1024)} KB`
+  if (size < 1024 ** 3) return `${(size / 1024 ** 2).toFixed(1)} MB`
+  return `${(size / 1024 ** 3).toFixed(1)} GB`
+}
+
+/** Counts files as `1 file` or `N files`, with `N+` when the walk was cut. */
+function fileCount(count: number, isCut = false): string {
+  return `${count}${isCut ? '+' : ''} file${count === 1 && !isCut ? '' : 's'}`
+}
+
+/**
+ * Says whether git can bring the files back, the warning under the card's header.
+ *
+ * @param radius - What the delete removes.
+ * @returns One sentence about how many of the files git tracks.
+ */
+function restoreNote(radius: BlastRadius): string {
+  if (!radius.isKnown) return "Couldn't list what this deletes, so its size is unknown."
+  const tracked = radius.files.filter(file => file.isTracked).length
+  if (tracked === 0) return "None of these are tracked by git, so they can't be restored."
+  if (tracked === radius.files.length) return 'All of these are tracked by git: their committed versions can be restored, uncommitted changes cannot.'
+  return `${tracked} of these are tracked by git and can be restored; the other ${radius.files.length - tracked} cannot.`
+}
+
+/** The folder a file sits in, as the card groups them: `.` for the session's directory. */
+function folderOf(path: string): string {
+  const cut = path.lastIndexOf('/')
+  return cut === -1 ? '.' : path.slice(0, cut)
+}
+
+/**
+ * Builds the SVG of a size bar: a track with a fill `share` of its width.
+ *
+ * @param width - Width of the track in pixels.
+ * @param share - Filled part, from 0 to 1.
+ * @param color - Fill color.
+ * @returns The SVG markup.
+ */
+function barSvg(width: number, share: number, color: string): string {
+  const fill = Math.max(3, share * width)
+  return `<svg xmlns="http://www.w3.org/2000/svg" width="${width}" height="8" viewBox="0 0 ${width} 8"><rect width="${width}" height="8" rx="4" fill="${TRACK}"/><rect width="${fill.toFixed(1)}" height="8" rx="4" fill="${color}"/></svg>`
+}
+
+/** A delete held for the person's answer: what it runs, what it removes, and how to settle it. */
+type Held = {
+  segment: string
+  folder: string
+  radius: BlastRadius
+  settle: (answer: Answer | 'timeout') => void
+}
+
+/** Deletes waiting on the card, oldest first; the card shows the first. */
+const held: Held[] = []
+
+/** The card lists every file instead of the first `SHOWN_FILES`. */
+let isExpanded = false
+
+/**
+ * Turns the guard on or off, for this session and every later one.
+ *
+ * @param $ - Engine handle the command or press came through.
+ * @param isGuarding - True to hold deletes on the card, false to let them run unasked.
+ */
+async function setGuard($: EngineInterface, isGuarding: boolean): Promise<void> {
+  await update($, isOn, () => isGuarding)
+  await $.store.set(STORE_KEY, isGuarding)
+}
+
+/**
+ * Shows the switch again once no delete waits: the pane's title goes back from the card's.
+ *
+ * @param $ - Engine handle the hook received.
+ */
+async function showSwitch($: EngineInterface): Promise<void> {
+  if (held.length === 0) await $.ui.open({ id: PANE, title: TITLE }).catch(() => undefined)
+  $.ui.invalidate('ui.render')
+}
+
+/**
+ * Answers the delete the card shows, then shows the next one or the switch.
+ *
+ * @param $ - Engine handle the press came through.
+ * @param answer - What the person chose.
+ */
+async function answerFirst($: EngineInterface, answer: Answer): Promise<void> {
+  const first = held.shift()
+  isExpanded = false
+  first?.settle(answer)
+  await showSwitch($)
+}
+
+/**
+ * @brief Holds a delete until the person answers its card, it waits `HOLD_MS`, or Claude's call is stopped.
+ *
+ * @param $ - Engine handle the hook received.
+ * @param card - The delete and what it removes.
+ * @param signal - Aborts the wait when Claude's call is stopped.
+ * @returns `delete`, `cancel`, or `timeout` when no one answered in time.
+ */
+async function hold($: EngineInterface, card: Omit<Held, 'settle'>, signal: AbortSignal | undefined): Promise<Answer | 'timeout'> {
+  let settle: (answer: Answer | 'timeout') => void = () => {}
+  const answered = new Promise<Answer | 'timeout'>(resolve => { settle = resolve })
+  const entry: Held = { ...card, settle }
+  held.push(entry)
+
+  /** Takes this delete off the card with `answer`, unless it was answered already. */
+  const drop = (answer: Answer | 'timeout'): void => {
+    const index = held.indexOf(entry)
+    if (index === -1) return
+    held.splice(index, 1)
+    settle(answer)
+    void showSwitch($)
+  }
+  const timer = $.clock.after(HOLD_MS, () => drop('timeout'))
+  const onAbort = (): void => drop('cancel')
+  signal?.addEventListener('abort', onAbort, { once: true })
+
+  // The switch's pane is usually open already: retitle and focus it, then redraw it as the card.
+  if (held.length === 1) await $.ui.open({ id: PANE, title: HOLD_TITLE, focus: true })
+  $.ui.invalidate('ui.render')
+
+  const answer = await answered
+  timer.cancel()
+  signal?.removeEventListener('abort', onAbort)
+  return answer
+}
+
+/**
+ * Registers this mod's `delete-guard` command, its session hook, its Bash tool hook, and its pane: the switch, or the card while a delete waits.
+ *
+ * @param on - Hook registration function the engine passes in.
+ */
+export const register: Register = on => {
+  let trash: string | undefined
+  let home = ''
+
+  on('session.start', async ($, e, next) => {
+    trash = await detectTrash($)
+    const found = await $.process.run(['printenv', 'HOME']).catch(() => undefined)
+    home = found?.stdout.trim() ?? ''
+    const remembered = await $.store.get(STORE_KEY).catch(() => undefined)
+    await update($, isOn, () => remembered === true)
+    await $.command.register({
+      name: 'delete-guard',
+      description: 'Turn the permanent-delete guard on or off; it stays that way in later sessions',
+      argumentHint: 'on | off',
+    })
+    void $.ui.open({ id: PANE, title: TITLE })
+    return next(e)
+  })
+
+  on('command.run', { command: 'delete-guard' }, async ($, e) => {
+    const wanted = e.args.trim()
+    if (wanted === 'on' || wanted === 'off') await setGuard($, wanted === 'on')
+    const isGuarding = await read($, isOn)
+    return { text: `delete-guard is ${isGuarding ? 'on: permanent deletes wait for your answer' : 'off: permanent deletes run unasked'}.` }
+  })
+
+  on('tool.call', { tool: 'Bash' }, async ($, e, next) => {
+    if (!(await read($, isOn))) return next(e)
+    const deletion = findDeletion(e.command)
+    if (deletion === undefined) return next(e)
+
+    const spelled = trash ?? 'trash'
+    const install = trash === undefined ? ' (install trash-cli: sudo apt install trash-cli)' : ''
+    const instead = `\`${insteadOf(deletion, spelled)}\`${install}`
+
+    // Nothing can draw the card, as in a -p run or VS Code without the viewer: refuse outright.
+    if ((await $.session.surfaces()).length === 0) {
+      return { deny: `delete-guard: \`${deletion.segment}\` deletes permanently. Move it to the trash instead: ${instead}.` }
+    }
+
+    const cwd = await $.session.cwd()
+    const radius = await measure($, deletion, cwd, home)
+    if (radius.isKnown && radius.files.length === 0) return next(e)
+
+    const folder = cwd.split('/').filter(Boolean).pop() ?? cwd
+    const answer = await hold($, { segment: deletion.segment, folder, radius }, next.signal)
+    if (answer === 'delete') return next(e)
+    if (answer === 'timeout') {
+      return { deny: `delete-guard: no one answered the delete card within ${HOLD_MS / 60_000} minutes, so \`${deletion.segment}\` did not run. Ask the user before trying again.` }
+    }
+    return { deny: `delete-guard: the user cancelled \`${deletion.segment}\`. Do not delete these files without asking; to remove them, move them to the trash: ${instead}.` }
+  }).catch(($, e, next) => (next.called ? next(e) : { deny: 'delete-guard: the guard failed, so the command was not run.' }))
+
+  on('ui.close', async ($, e, next) => {
+    // Closing the card by hand answers every delete it holds with Cancel.
+    if (e.id === PANE && e.origin.kind === 'person') {
+      for (const entry of held.splice(0)) entry.settle('cancel')
+      isExpanded = false
+    }
+    return next(e)
+  })
+
+  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e) => {
+    const { Box, Text, Button } = $.ui.resolve(e)
+    const card = held[0]
+    if (card === undefined) {
+      const isGuarding = await read($, isOn)
+      return (
+        <Box flexDirection="row" columnGap={2} alignItems="center">
+          <Button key="switch" label={isGuarding ? '● on' : '○ off'} variant={isGuarding ? 'primary' : 'secondary'} onPress={() => setGuard($, !isGuarding)} />
+          <Text dimColor wrap="truncate-end">{isGuarding ? 'Deletes wait here for Delete or Cancel.' : 'Deletes run without asking.'}</Text>
+        </Box>
+      )
+    }
+    const { radius } = card
+    const barCells = Math.max(8, Math.floor(e.props.bodyColumns * 0.22))
+
+    /** Draws a size bar with `share` of it filled: an SVG, or block characters in the terminal. */
+    const bar = (share: number, color: string) => {
+      if (e.surface === 'terminal') {
+        const filled = Math.max(1, Math.round(share * barCells))
+        return <Text><Text color={color}>{'▬'.repeat(filled)}</Text><Text color={TRACK}>{'▬'.repeat(barCells - filled)}</Text></Text>
+      }
+      const { Svg } = $.ui.resolve(e)
+      const width = barCells * CELL_PX
+      return <Svg source={barSvg(width, share, color)} alt={`${Math.round(share * 100)}%`} width={width} height={8} />
+    }
+
+    // Folders by size, each with its largest files under it, until SHOWN_FILES file rows are used.
+    const folders = new Map<string, DoomedFile[]>()
+    for (const file of radius.files) folders.set(folderOf(file.path), [...(folders.get(folderOf(file.path)) ?? []), file])
+    const groups = [...folders.entries()]
+      .map(([name, files]) => ({ name, files, size: files.reduce((sum, file) => sum + file.size, 0) }))
+      .sort((a, b) => b.size - a.size)
+    const largest = Math.max(1, groups[0]?.size ?? 1)
+    let budget = isExpanded ? radius.files.length : SHOWN_FILES
+    const rows = groups.flatMap(group => {
+      if (budget <= 0) return []
+      const files = group.files.slice(0, budget)
+      budget -= files.length
+      return [
+        <Box key={`dir:${group.name}`} flexDirection="row" columnGap={1} marginTop={1}>
+          <Box flexGrow={1}><Text wrap="truncate-end" bold>▭ {group.name === '.' ? './' : `${group.name}/`}</Text></Box>
+          <Box width={9} justifyContent="flex-end"><Text dimColor>{fileCount(group.files.length)}</Text></Box>
+          <Box width={8} justifyContent="flex-end"><Text bold>{bytes(group.size)}</Text></Box>
+          {bar(group.size / largest, '#d8d4c8')}
+        </Box>,
+        ...files.map(file => (
+          <Box key={`file:${file.path}`} flexDirection="row" columnGap={1} paddingLeft={2}>
+            <Box flexGrow={1}>
+              <Text wrap="truncate-end"><Text dimColor>▯ </Text><Text backgroundColor={file.isTracked ? undefined : UNTRACKED_BG}>{file.path.slice(file.path.lastIndexOf('/') + 1)}</Text></Text>
+            </Box>
+            <Box width={8} justifyContent="flex-end"><Text dimColor>{bytes(file.size)}</Text></Box>
+            {bar(file.size / largest, '#9a968c')}
+          </Box>
+        )),
+      ]
+    })
+    const hidden = isExpanded ? 0 : Math.max(0, radius.files.length - SHOWN_FILES)
+    const count = radius.isKnown ? `${fileCount(radius.files.length, radius.isCut)} · ${bytes(radius.total)}` : 'unknown files'
+    const waiting = held.length > 1 ? ` · ${held.length - 1} more waiting` : ''
+
+    return (
+      <Box flexDirection="column">
+        <Box flexDirection="row" columnGap={2} alignItems="center">
+          <Text bold color={RED} backgroundColor={CHIP}> 🗑 </Text>
+          <Box flexDirection="column" flexShrink={1}>
+            <Text wrap="truncate-end"><Text bold>{card.segment}</Text><Text dimColor> will delete </Text><Text bold color={ORANGE}>{count}</Text></Text>
+            <Text dimColor>in {card.folder}{waiting}</Text>
+          </Box>
+        </Box>
+        <Box borderStyle="round" borderColor={WARN_EDGE} backgroundColor={WARN_BG} paddingX={1} marginTop={1}>
+          <Text color={RED}>⛉ {restoreNote(radius)}</Text>
+        </Box>
+        {rows}
+        {hidden > 0 && (
+          <Box marginTop={1}>
+            <Button key="more" plain onPress={() => { isExpanded = true; $.ui.invalidate('ui.render') }}><Text dimColor>Show {hidden} more</Text></Button>
+          </Box>
+        )}
+        <Box flexDirection="row" columnGap={2} alignItems="center" marginTop={1}>
+          <Button key="delete" variant="primary" label={`Delete ${fileCount(radius.files.length, radius.isCut)}`} onPress={() => answerFirst($, 'delete')} />
+          <Button key="cancel" label="Cancel" onPress={() => answerFirst($, 'cancel')} />
+          <Text dimColor>Held by delete-guard</Text>
+        </Box>
+      </Box>
+    )
+  })
+}

package/mods/delete-guard/types/index.d.ts

@@ -7,8 +7,33 @@ export type Deletion = {
   paths: string[]
 }
 
+/** One file a delete would remove: its path relative to the session's directory, its bytes, and whether git tracks it. */
+export type DoomedFile = {
+  path: string
+  size: number
+  isTracked: boolean
+}
+
+/**
+ * What a delete would remove, as the card shows it.
+ *
+ * @property files - Every file found, largest first.
+ * @property total - Bytes of all of them.
+ * @property isCut - The walk stopped early, so there are more than `files` lists.
+ * @property isKnown - The files could be listed at all; false when the listing failed.
+ */
+export type BlastRadius = {
+  files: DoomedFile[]
+  total: number
+  isCut: boolean
+  isKnown: boolean
+}
+
+/** The person's answer on the card: run the delete, or refuse it. */
+export type Answer = 'delete' | 'cancel'
+
 declare module 'claude-code' {
   interface PluginState {
-    'delete-guard': { isOff: boolean }
+    'delete-guard': { isOn: boolean }
   }
 }

package/mods/focus-mode/.claude-plugin/plugin.json

@@ -1,7 +1,7 @@
 {
   "name": "focus-mode",
   "version": "0.1.0",
-  "description": "A timed focus block with a countdown, a progress bar and an end button.",
+  "description": "A timed focus block in which you're away: Claude asks no questions and gets no permission prompts. Countdown, progress bar and end button.",
   "author": {
     "name": "g3ntrovert"
   },