attic-widget

1import { atom, read, update } from 'claude-code'
2import type { Elements, EngineInterface, PluginState, Register, RenderElement, RenderSurface, ToolDescribeInput, ToolDescribeResult } from 'claude-code'
3import type { WidgetsPlace } from 'widgets'
4
5import { fit, folder, plural } from './lib'
6
7type Tags = Pick<Elements[RenderSurface], 'Box' | 'Text'>
8type Book = PluginState['attic-widget']['book']
9type Plan = PluginState['attic-widget']['plan']
10type Run = PluginState['attic-widget']['run']
11type Tool = Book['tools'][string]
12type List = 'keep' | 'stow'
13type Row = { key: string; text: string; isDim: boolean; isSentence: boolean }
14
15const PANE = 'widgets'
16const CARD_COLUMNS = 40
17const CARD_FRAME = 4
18const WIDE_COLUMNS = 30
19const WINDOW = 5
20const AIRING_EVERY = 10
21const FORWARD_CALLS = 3
22const SHOW_ROWS = 20
23const SEARCH = 'ToolSearch'
24const FLOOR = [SEARCH, 'Bash', 'Read', 'Edit', 'Write', 'Grep', 'Glob']
25const USAGE = 'Usage: /attic-widget [on|off|show|keep <tool>|stow <tool>|clear]'
26const VERBS = ['', 'on', 'off', 'show', 'keep', 'stow', 'clear']
27const EMPTY = `Counting the tools Claude calls in this project. After ${WINDOW} sessions the unused ones wait behind ${SEARCH}.`
28const AIRING = 'Airing: every tool is where the engine puts it this session, so a stowed tool can earn its way back.'
29const BLIND = `No ${SEARCH} in this session, so nothing is moved. Still counting.`
30const FETCHED = 'Claude fetched '
31const REST: Book = { key: '', sessions: 0, base: -1, keep: [], stow: [], tools: {} }
32const UNPLANNED: Plan = { isReady: false, n: 1, mode: 'dry', moves: {} }
33const IDLE: Run = { isCounted: false, isDirty: false, isMeasured: false, onDemand: -1, fetched: [] }
34const site = { plugin: 'widgets', key: 'site' } as const
35const widths = { plugin: 'widgets', key: 'widths' } as const
36const restored = { plugin: 'attic-widget', key: 'isOn' } as const
37const isOn = atom({ plugin: 'attic-widget', key: 'isOn' } as const, false)
38const book = atom({ plugin: 'attic-widget', key: 'book' } as const, REST)
39const plan = atom({ plugin: 'attic-widget', key: 'plan' } as const, UNPLANNED)
40const run = atom({ plugin: 'attic-widget', key: 'run' } as const, IDLE)
41
42const cut = (text: string, room: number): string => {
43  const letters = [...text]
44
45  return letters.length <= room ? text : `${letters.slice(0, Math.max(0, room - 1)).join('')}…`
46}
47
48const wrapped = (text: string, room: number): string[] =>
49  text.split(' ').reduce<string[]>((lines, word) => {
50    const last = lines.at(-1)
51
52    return last !== undefined && last.length + 1 + word.length <= room ? [...lines.slice(0, -1), `${last} ${word}`] : [...lines, cut(word, room)]
53  }, [])
54
55const kilo = (tokens: number): string => {
56  if (tokens < 1000) return String(tokens)
57
58  const tenths = Math.round(tokens / 100)
59
60  return tenths < 1000 ? `${(tenths / 10).toFixed(1)}k` : `${Math.round(tokens / 1000)}k`
61}
62
63const calls = (tool: Tool, n: number): number => tool.used.filter(at => at >= n - WINDOW && at < n).length
64
65const planned = (held: Book, n: number, hasSearch: boolean): Plan => {
66  const mode = !hasSearch ? 'blind' : n <= WINDOW ? 'dry' : n % AIRING_EVERY === 0 ? 'airing' : 'live'
67  const moves: Plan['moves'] = {}
68  if (!hasSearch) return { isReady: true, n, mode, moves }
69
70  for (const name of held.stow) if (!FLOOR.includes(name)) moves[name] = 'away'
71  for (const name of held.keep) if (held.tools[name]?.isDeferred === true) moves[name] = 'forward'
72  if (mode !== 'live') return { isReady: true, n, mode, moves }
73
74  for (const [name, tool] of Object.entries(held.tools)) {
75    if (held.keep.includes(name) || held.stow.includes(name)) continue
76
77    const used = calls(tool, n)
78    const isKnown = tool.since <= n - WINDOW && tool.seen >= n - WINDOW
79    if (tool.isEngine && !tool.isDeferred && !FLOOR.includes(name) && isKnown && used === 0) moves[name] = 'away'
80    else if (tool.isDeferred && used >= FORWARD_CALLS) moves[name] = 'forward'
81  }
82
83  return { isReady: true, n, mode, moves }
84}
85
86const noted = (held: Book, e: ToolDescribeInput, n: number): Book => {
87  const known = held.tools[e.tool]
88  const isEngine = e.provider.plugin === 'engine'
89  const isDeferred = e.isDeferred === true
90  if (known !== undefined && known.isEngine === isEngine && known.isDeferred === isDeferred && known.seen === n) return held
91
92  return { ...held, tools: { ...held.tools, [e.tool]: { isEngine, isDeferred, since: known?.since ?? n, seen: n, used: known?.used ?? [] } } }
93}
94
95const tallied = (held: Book, tool: string, n: number): Book => {
96  const known = held.tools[tool] ?? { isEngine: false, isDeferred: false, since: n, seen: 0, used: [] }
97  if (held.sessions === n && known.used.includes(n)) return held
98
99  return { ...held, sessions: n, tools: { ...held.tools, [tool]: known.used.includes(n) ? known : { ...known, used: [...known.used, n] } } }
100}
101
102const listed = (held: Book, list: List, tool: string): Book => {
103  const keep = held.keep.filter(name => name !== tool)
104  const stow = held.stow.filter(name => name !== tool)
105  if (held[list].includes(tool)) return { ...held, keep, stow }
106
107  return { ...held, keep: list === 'keep' ? [...keep, tool] : keep, stow: list === 'stow' ? [...stow, tool] : stow }
108}
109
110const merged = (saved: Book, early: Book, n: number): Book =>
111  early.key !== ''
112    ? saved
113    : {
114        ...saved,
115        tools: {
116          ...saved.tools,
117          ...Object.fromEntries(
118            Object.entries(early.tools).map(([name, tool]) => [name, { ...tool, since: saved.tools[name]?.since ?? n, seen: n, used: saved.tools[name]?.used ?? [] }]),
119          ),
120        },
121      }
122
123const trimmed = (held: Book, n: number): Omit<Book, 'key'> => ({
124  sessions: held.sessions,
125  base: held.base,
126  keep: held.keep,
127  stow: held.stow,
128  tools: Object.fromEntries(
129    Object.entries(held.tools)
130      .filter(([name, tool]) => tool.seen >= n - WINDOW || held.keep.includes(name) || held.stow.includes(name))
131      .map(([name, tool]) => [name, { ...tool, used: tool.used.filter(at => at >= n - WINDOW) }]),
132  ),
133})
134
135const present = (held: Book, n: number): string[] => Object.keys(held.tools).filter(name => held.tools[name]?.seen === n)
136
137const idle = (held: Book, n: number): string[] =>
138  present(held, n)
139    .filter(name => {
140      const tool = held.tools[name]
141
142      return tool?.isEngine === true && !tool.isDeferred && tool.used.length === 0 && !FLOOR.includes(name)
143    })
144    .sort()
145
146const unused = (held: Book, n: number): string[] => idle(held, n).filter(name => !held.keep.includes(name) && !held.stow.includes(name))
147
148const isListed = (held: Book, name: string): boolean => {
149  const tool = held.tools[name]
150
151  return tool !== undefined && tool.seen > 0 && !tool.isDeferred
152}
153
154const titled = (key: string): string => key.split('/').at(-1) || key || '/'
155
156const going = (held: Book, made: Plan, move: Plan['moves'][string]): string[] => {
157  const here = present(held, made.n)
158
159  return Object.keys(made.moves)
160    .filter(name => made.moves[name] === move && (here.length === 0 || here.includes(name)))
161    .sort()
162}
163
164const figures = (held: Book, moved: number, onDemand: number): [wide: string, narrow: string][] => {
165  if (onDemand < 0) return []
166  if (held.base < 0 || moved === 0) return [[`On demand now: ${kilo(onDemand)} tokens`, `${kilo(onDemand)} on demand`]]
167
168  const less = onDemand - held.base
169  const size = kilo(Math.abs(less))
170  const head: [string, string] = [`On demand ${kilo(held.base)} -> ${kilo(onDemand)} tokens`, `${kilo(held.base)} -> ${kilo(onDemand)}`]
171  if (Math.abs(less) > onDemand) return [head]
172  if (less === 0) return [head, ['No change in a request', '+0/request']]
173
174  return [head, less > 0 ? [`${size} less in every request`, `-${size}/request`] : [`${size} more in every request`, `+${size}/request`]]
175}
176
177const noteOf = (held: Book, made: Plan, isWide: boolean): string => {
178  if (made.mode === 'blind') return 'no search'
179  if (made.mode === 'airing') return 'airing'
180  if (made.mode === 'dry') return isWide ? `watching ${made.n}/${WINDOW}` : `${made.n}/${WINDOW}`
181
182  const away = going(held, made, 'away').length
183  const forward = going(held, made, 'forward').length
184
185  return away === 0 && forward > 0 ? `${forward} forward` : `${away} away`
186}
187
188const drawn = (held: Book, made: Plan, ran: Run, inner: number, isWide: boolean): Row[] => {
189  const pick = (wide: string, narrow: string): string => (isWide && wide.length <= inner ? wide : narrow)
190  const said = (key: string, text: string): Row => ({ key, text, isDim: true, isSentence: true })
191  const row = (key: string, wide: string, narrow: string, isDim = false): Row => ({ key, text: pick(wide, narrow), isDim, isSentence: false })
192  const away = going(held, made, 'away').length
193  const forward = going(held, made, 'forward').length
194  const known = present(held, made.n).length
195  const never = idle(held, made.n).length
196  const latest = ran.fetched.at(-1)
197  const more = ran.fetched.length - 1
198  const counts = row(
199    'counts',
200    away === 0 ? `Nothing in the attic, ${forward} forward.` : `${plural(away, 'tool')} in the attic${forward > 0 ? `, ${forward} forward` : ''}.`,
201    `${away} away, ${forward} fwd`,
202  )
203  const rows: Row[] = []
204
205  if (latest !== undefined && isWide) {
206    const name = `${cut(latest, inner - FETCHED.length)}${more > 0 ? ` and ${more} more` : ''}`
207    rows.push({ ...said('fetch', `${FETCHED}${name} from the attic. ${held.stow.includes(latest) ? 'Stowed by you, so it stays.' : 'Listed again next session.'}`), isDim: false })
208  }
209  if (latest !== undefined && !isWide) {
210    const tail = more > 0 ? ` +${more}` : ''
211    rows.push({ key: 'fetch', text: `fetched ${cut(latest, inner - 'fetched '.length - tail.length)}${tail}`, isDim: false, isSentence: false })
212    if (held.stow.includes(latest)) rows.push({ key: 'stays', text: 'stays stowed', isDim: false, isSentence: false })
213  }
214
215  if (made.mode === 'blind') rows.push(said('said', BLIND))
216  if (made.mode === 'airing') rows.push(said('said', AIRING))
217  if (made.mode === 'dry' && away + forward === 0) rows.push(known === 0 ? said('said', EMPTY) : row('still', 'Nothing moved yet.', 'nothing moved'))
218  if (made.mode === 'live' && away + forward === 0) rows.push(row('still', 'Nothing to move this session.', 'nothing moved'))
219  if (away + forward > 0) rows.push(counts)
220  if (made.mode === 'dry' && known > 0) {
221    rows.push(row('unused', never === 0 ? 'Every tool has been called here.' : `${plural(never, 'tool')} never called here so far.`, `${never} never called`))
222  }
223  figures(held, away + forward, ran.onDemand).forEach(([wide, narrow], at) => rows.push(row(at === 0 ? 'figure' : 'change', wide, narrow, true)))
224
225  return rows
226}
227
228const reported = (held: Book, made: Plan, ran: Run): string => {
229  const name = titled(held.key)
230  const away = going(held, made, 'away')
231  const forward = going(held, made, 'forward')
232  const figure = figures(held, away.length + forward.length, ran.onDemand)
233    .map(([wide]) => wide)
234    .join(', ')
235  const rows = [
236    ...away.map(tool => `away ${tool}: ${held.stow.includes(tool) ? 'stowed by you' : `no call in the last ${WINDOW} sessions`}`),
237    ...forward.map(tool => {
238      const known = held.tools[tool]
239
240      return `forward ${tool}: ${held.keep.includes(tool) || known === undefined ? 'kept by you' : `called in ${calls(known, made.n)} of the last ${WINDOW} sessions`}`
241    }),
242    ...held.keep
243      .filter(tool => made.moves[tool] === undefined && isListed(held, tool))
244      .sort()
245      .map(tool => `kept ${tool}: kept by you`),
246    ...(made.mode === 'dry' ? unused(held, made.n).map(tool => `would go ${tool}: never called here`) : []),
247  ]
248
249  return [
250    made.mode === 'dry'
251      ? `Attic, session ${made.n} of ${WINDOW} in ${name}: watching, nothing moved.`
252      : `Attic, session ${made.n} in ${name}: ${away.length} away, ${forward.length} forward.`,
253    ...(made.mode === 'airing' ? [AIRING] : []),
254    ...(made.mode === 'blind' ? [BLIND] : []),
255    ...rows.slice(0, SHOW_ROWS),
256    ...(rows.length > SHOW_ROWS ? [`and ${rows.length - SHOW_ROWS} more`] : []),
257    ...(figure === '' ? [] : [figure]),
258  ].join('\n')
259}
260
261const show = async (
262  $: EngineInterface,
263  { Box, Text }: Tags,
264  beneath: RenderElement,
265  place: WidgetsPlace,
266  columns: number,
267): Promise<RenderElement> => {
268  if (!(await read($, isOn))) return beneath
269  if ((await $.state.get(site)).value !== place) return beneath
270
271  const width = fit((await $.state.get(widths)).value?.['attic-widget'] ?? CARD_COLUMNS, columns)
272  const inner = width - CARD_FRAME
273  const isWide = width >= WIDE_COLUMNS
274  const made = await read($, plan)
275  const held = await read($, book)
276
277  return $.widgets.card({
278    beneath,
279    width,
280    title: 'Attic',
281    note: noteOf(held, made, isWide),
282    body: (
283      <Box flexDirection="column">
284        {drawn(held, made, await read($, run), inner, isWide).flatMap(({ key, text, isDim, isSentence }) =>
285          (isSentence ? wrapped(text, inner) : [cut(text, inner)]).map((line, at) => (
286            <Box key={`${key}:${at}`}>
287              <Text dimColor={isDim} wrap="truncate-end">
288                {line}
289              </Text>
290            </Box>
291          )),
292        )}
293      </Box>
294    ),
295  })
296}
297
298const named = async ($: EngineInterface): Promise<string[]> => {
299  try {
300    return (await $.tool.list()).map(tool => tool.name)
301  } catch {
302    return []
303  }
304}
305
306const opened = async ($: EngineInterface): Promise<void> => {
307  const key = folder((await $.session.repo())?.root ?? (await $.session.root()))
308  const stored = await $.store.get(`book:${key}`)
309  const saved: Book = { ...REST, ...(typeof stored === 'object' && stored !== null ? (stored as Partial<Book>) : {}), key }
310  const names = await named($)
311  const n = saved.sessions + 1
312  const early = await read($, book)
313  const made = planned(merged(saved, early, n), n, names.includes(SEARCH))
314
315  await update($, plan, () => made)
316  await update($, book, seen => merged(saved, seen ?? REST, n))
317  await update($, run, () => ({ ...IDLE, isDirty: early.key === '' && Object.keys(early.tools).length > 0 }))
318  if (Object.keys(made.moves).length > 0) $.ui.invalidate('tool.describe')
319}
320
321const written = async ($: EngineInterface): Promise<void> => {
322  const held = await read($, book)
323
324  await $.store.set(`book:${held.key}`, trimmed(held, (await read($, plan)).n))
325  await update($, run, ran => ({ ...(ran ?? IDLE), isDirty: false }))
326}
327
328const kept = async ($: EngineInterface): Promise<void> => {
329  const { isCounted, isDirty } = await read($, run)
330  if (isCounted && isDirty) await written($)
331}
332
333const closed = async ($: EngineInterface): Promise<void> => {
334  const { moves } = await read($, plan)
335
336  await kept($)
337  await update($, book, () => REST)
338  await update($, plan, () => UNPLANNED)
339  await update($, run, () => IDLE)
340  if (Object.keys(moves).length > 0) $.ui.invalidate('tool.describe')
341}
342
343const woken = async ($: EngineInterface): Promise<boolean> => {
344  try {
345    if ((await $.state.get(restored)).version > 0) return false
346    const isStored = (await $.store.get('isOn')) === true
347
348    return await update($, isOn, () => isStored)
349  } catch {
350    return false
351  }
352}
353
354const placed = async ($: EngineInterface, e: ToolDescribeInput, answer: ToolDescribeResult): Promise<ToolDescribeResult> => {
355  const { isReady, n, mode, moves } = await read($, plan)
356  const seen = isReady ? n : 0
357  const held = await read($, book)
358  if (noted(held, e, seen) !== held) {
359    await update($, book, held => noted(held ?? REST, e, seen))
360    if (isReady) await update($, run, ran => ({ ...(ran ?? IDLE), isDirty: true }))
361  }
362
363  const isKept = e.isDeferred === true && mode !== 'blind' && moves[e.tool] === undefined && held.keep.includes(e.tool)
364  if (isKept) {
365    await update($, plan, made => ({ ...(made ?? UNPLANNED), moves: { ...(made ?? UNPLANNED).moves, [e.tool]: 'forward' } }))
366    await update($, run, ran => ({ ...(ran ?? IDLE), isMeasured: false, onDemand: -1 }))
367  }
368
369  const move = isKept ? 'forward' : moves[e.tool]
370
371  return move === undefined ? answer : { ...answer, isDeferred: move === 'away' }
372}
373
374const counted = async ($: EngineInterface, tool: string): Promise<void> => {
375  const { isReady, n, moves } = await read($, plan)
376  if (!isReady) return
377
378  const held = await read($, book)
379  const isFetched = moves[tool] === 'away' && !(await read($, run)).fetched.includes(tool)
380  if (tallied(held, tool, n) === held && !isFetched) return
381
382  await update($, book, seen => tallied(seen ?? REST, tool, n))
383  await update($, run, ran => {
384    const { fetched, ...rest } = ran ?? IDLE
385
386    return { ...rest, isCounted: true, isDirty: true, fetched: isFetched && !fetched.includes(tool) ? [...fetched, tool] : fetched }
387  })
388}
389
390const measured = async ($: EngineInterface): Promise<void> => {
391  const { isReady, moves } = await read($, plan)
392  if (!isReady || (await read($, run)).isMeasured) return
393
394  const rows = ((await $.session.usage({ breakdown: 'summary' })).context.breakdown?.categories ?? []).filter(row => row.kind === 'deferred')
395  const onDemand = rows.length === 0 ? -1 : rows.reduce((sum, row) => sum + row.tokens, 0)
396  const isBase = onDemand >= 0 && Object.keys(moves).length === 0 && (await read($, book)).base !== onDemand
397  if (isBase) await update($, book, held => ({ ...(held ?? REST), base: onDemand }))
398  await update($, run, ran => ({ ...(ran ?? IDLE), isMeasured: true, onDemand, isDirty: (ran ?? IDLE).isDirty || isBase }))
399}
400
401const shelved = async ($: EngineInterface, list: List, typed: string): Promise<string> => {
402  const before = await read($, plan)
403  const held = await read($, book)
404  const floor = FLOOR.find(name => name.toLowerCase() === typed.toLowerCase())
405  if (list === 'stow' && floor !== undefined) return `${floor} is never put away.`
406
407  const known = [...(await named($)), ...Object.keys(held.tools), ...held.keep, ...held.stow]
408  const tool = known.find(name => name === typed) ?? known.find(name => name.toLowerCase() === typed.toLowerCase())
409  if (tool === undefined) return `No tool named ${typed} in this session.`
410
411  const { [tool]: was, ...others } = before.moves
412  const move = planned(await update($, book, seen => listed(seen ?? REST, list, tool)), before.n, before.mode !== 'blind').moves[tool]
413  const made: Plan = { ...before, moves: move === undefined ? others : { ...others, [tool]: move } }
414  await written($)
415  await update($, plan, () => made)
416  const isUnseen = list === 'keep' && !held.keep.includes(tool) && before.mode !== 'blind' && held.tools[tool]?.seen !== before.n
417  if (move !== was) await update($, run, ran => ({ ...(ran ?? IDLE), isMeasured: false, onDemand: -1 }))
418  if (move !== was || isUnseen) $.ui.invalidate('tool.describe')
419
420  if (held[list].includes(tool)) return `${tool} is back to evidence.`
421  if (list === 'keep') return `${tool} stays listed.`
422
423  return made.mode === 'blind' ? `${tool} is on the stow list. ${BLIND}` : `${tool} is in the attic from the next request. One prompt-cache miss.`
424}
425
426const cleared = async ($: EngineInterface): Promise<string> => {
427  const { key, tools } = await read($, book)
428  const { mode, moves } = await read($, plan)
429
430  await $.store.delete(`book:${key}`)
431  await update($, book, () => ({ ...REST, key }))
432  await update($, plan, () => planned(REST, 1, mode !== 'blind'))
433  await update($, run, () => IDLE)
434  if (Object.keys(moves).length > 0) $.ui.invalidate('tool.describe')
435
436  return `Attic cleared: ${plural(Object.keys(tools).length, 'tool')} forgotten for ${titled(key)}.`
437}
438
439export const register: Register = on => {
440  on('session.start', async ($, e, next) => {
441    await $.command.register({
442      name: 'attic-widget',
443      description: 'Toggle the Attic card, list where each tool waits, keep or stow one, or clear the count',
444      argumentHint: '[on|off|show|keep <tool>|stow <tool>|clear]',
445    })
446    if ((await $.store.get('isOn')) === true) await update($, isOn, () => true)
447    else await update($, isOn, shown => shown ?? false)
448    if (await read($, isOn)) await opened($)
449
450    return next(e)
451  })
452
453  on('command.run', { command: 'attic-widget' }, async ($, e) => {
454    const [verb = '', ...rest] = e.args.trim().split(/\s+/)
455    const arg = verb.toLowerCase()
456    const [typed = ''] = rest
457    if (!VERBS.includes(arg) || rest.length !== (arg === 'keep' || arg === 'stow' ? 1 : 0)) return { text: USAGE }
458
459    if (arg === 'show' || arg === 'keep' || arg === 'stow' || arg === 'clear') {
460      if (!(await read($, isOn))) return { text: 'Attic is off.' }
461      if (arg === 'show') return { text: reported(await read($, book), await read($, plan), await read($, run)) }
462
463      return { text: arg === 'clear' ? await cleared($) : await shelved($, arg, typed) }
464    }
465
466    const wasOn = await read($, isOn)
467    const isShown = await update($, isOn, shown => (arg === '' ? !(shown ?? false) : arg === 'on'))
468    await $.store.set('isOn', isShown)
469    if (isShown && !wasOn) await opened($)
470    if (!isShown && wasOn) await closed($)
471
472    return { text: isShown ? 'Attic on; /widgets places it.' : 'Attic off.' }
473  })
474
475  on('tool.describe', async ($, e, next) => {
476    if (!(await read($, isOn)) && !(await woken($))) return next(e)
477
478    const answer = await next(e)
479    try {
480      return await placed($, e, answer)
481    } catch {
482      return answer
483    }
484  })
485
486  on('tool.call', async ($, e, next) => {
487    if (!(await read($, isOn))) return next(e)
488
489    try {
490      await counted($, e.tool)
491    } catch {
492      // A call that cannot be counted still runs: the tally is evidence, never a gate.
493    }
494
495    return next(e)
496  })
497
498  on('turn.complete', async ($, e, next) => {
499    if (e.agentId !== undefined || !(await read($, isOn))) return next(e)
500
501    try {
502      await measured($).catch(() => undefined)
503      await kept($)
504    } catch {
505      // A book that cannot be saved is kept in this session and written at the next turn.
506    }
507
508    return next(e)
509  })
510
511  on('ui.render', { component: 'Pane', requestId: PANE }, async ($, e, next) =>
512    show($, $.ui.resolve(e), await next(e), 'side', e.props.bodyColumns),
513  )
514
515  on('ui.render', { component: 'AbovePrompt' }, async ($, e, next) =>
516    e.props.hasSurvey ? next(e) : show($, $.ui.resolve(e), await next(e), 'above', e.props.bodyColumns),
517  )
518
519  on('ui.render', { component: 'PromptHint' }, async ($, e, next) =>
520    show($, $.ui.resolve(e), await next(e), 'below', e.viewport?.columns ?? 80),
521  )
522}
523

1const MIN_CARD = 20
2const BARS = '▁▂▃▄▅▆▇█'
3
4export const fit = (wanted: number, columns: number): number => Math.min(wanted, Math.max(MIN_CARD, columns))
5
6export const plural = (count: number, word: string): string => `${count} ${word}${count === 1 ? '' : 's'}`
7
8export const span = (ms: number): string => {
9  const seconds = Math.max(0, Math.round(ms / 1000))
10  if (seconds < 60) return `${seconds}s`
11  const minutes = Math.floor(seconds / 60)
12  if (minutes < 60) return `${minutes}m ${String(seconds % 60).padStart(2, '0')}s`
13  const hours = Math.floor(minutes / 60)
14  if (hours < 24) return `${hours}h ${String(minutes % 60).padStart(2, '0')}m`
15
16  return `${Math.floor(hours / 24)}d ${hours % 24}h`
17}
18
19export const spark = (values: readonly number[], width: number): string => {
20  const shown = width > 0 ? values.slice(-width) : []
21  const top = Math.max(...shown, 0)
22
23  return shown
24    .map(value => (top <= 0 ? BARS[0] : BARS[Math.min(BARS.length - 1, Math.round((Math.max(0, value) / top) * (BARS.length - 1)))]))
25    .join('')
26}
27
28export const hash = (text: string): number => {
29  let held = 2166136261
30  for (const letter of text) held = Math.imul(held ^ (letter.codePointAt(0) ?? 0), 16777619)
31
32  return held >>> 0
33}
34
35export const shade = (color: number, factor: number): number =>
36  (Math.round((color >> 16) * factor) << 16) |
37  (Math.round(((color >> 8) & 255) * factor) << 8) |
38  Math.round((color & 255) * factor)
39
40export const folder = (path: string): string => {
41  const flat = path.replaceAll('\\', '/').replace(/\/+$/, '')
42
43  return /^[a-z]:/i.test(flat) ? flat.toLowerCase() : flat
44}
45

1declare module 'claude-code' {
2  interface PluginState {
3    'attic-widget': {
4      isOn: boolean
5      book: {
6        key: string
7        sessions: number
8        base: number
9        keep: string[]
10        stow: string[]
11        tools: Record<string, { isEngine: boolean; isDeferred: boolean; since: number; seen: number; used: number[] }>
12      }
13      plan: {
14        isReady: boolean
15        n: number
16        mode: 'dry' | 'airing' | 'blind' | 'live'
17        moves: Record<string, 'away' | 'forward'>
18      }
19      run: {
20        isCounted: boolean
21        isDirty: boolean
22        isMeasured: boolean
23        onDemand: number
24        fetched: string[]
25      }
26    }
27  }
28}
29