lazzarone

1import type { EngineInterface, Register } from 'claude-code'
2
3import { describe, dueWaits, titleFor, type Wait } from './waits'
4
5// How often the waits are looked at, and how long a turn must last for its end to be worth a call.
6const CHECK_MS = 15_000
7const LONG_TURN_MS = 2 * 60 * 1000
8const TURN = 'turn'
9
10// The module's own: what Claude waits on you for, by tool call (or the finished turn).
11const waits = new Map<string, Wait>()
12
13function logFailure($: EngineInterface, what: string, error: unknown): void {
14  const reason = error instanceof Error ? error.message : String(error)
15  $.ui.log(`lazzarone: ${what} failed: ${reason}`, { to: 'debug' })
16}
17
18// Calls you, once per wait, for every wait that has lasted long enough.
19async function check($: EngineInterface, afterMs: number): Promise<void> {
20  const now = await $.clock.now()
21
22  for (const id of dueWaits(waits, now, afterMs)) {
23    const wait = waits.get(id)
24
25    if (wait !== undefined) {
26      waits.set(id, { ...wait, isCalled: true })
27      await $.ui.notify(wait.what, { title: titleFor(now - wait.since) })
28    }
29  }
30}
31
32export const register: Register = (on, options) => {
33  const minutes = typeof options.minutes === 'number' && options.minutes > 0 ? options.minutes : 3
34  const afterMs = minutes * 60_000
35
36  on('session.start', async ($, e, next) => {
37    waits.clear()
38    $.clock.every(CHECK_MS, () => {
39      check($, afterMs).catch(error => logFailure($, 'calling you', error))
40    })
41
42    return next(e)
43  })
44
45  // A call the engine puts to you (a permission, a question, a plan) starts a wait.
46  on('tool.check', async ($, e, next) => {
47    const verdict = await next(e)
48
49    if (verdict.decision === 'ask' && e.tool_use_id !== undefined) {
50      waits.set(e.tool_use_id, {
51        what: describe(e.tool, e.input),
52        since: await $.clock.now(),
53        isCalled: false
54      })
55    }
56
57    return verdict
58  })
59
60  // However the call went (run, refused, answered), its wait is over.
61  on('tool.call', async (_$, e, next) => {
62    try {
63      return await next(e)
64    } finally {
65      waits.delete(e.tool_use_id)
66    }
67  })
68
69  // A long turn that ends leaves Claude waiting for your next word.
70  on('turn.complete', async ($, e, next) => {
71    const result = await next(e)
72
73    if (!e.isAborted && e.durationMs >= LONG_TURN_MS) {
74      waits.set(TURN, {
75        what: 'ha finito: dai un’occhiata',
76        since: await $.clock.now(),
77        isCalled: false
78      })
79    }
80
81    return result
82  })
83
84  // You are back: nothing is waiting any more.
85  on('prompt.submit', async (_$, e, next) => {
86    waits.clear()
87
88    return next(e)
89  })
90}
91

1// What Claude is waiting on you for, how to say it, and which waits are due a call.
2
3export type Wait = { what: string; since: number; isCalled: boolean }
4
5// The command a Bash call wants to run, when the input carries one.
6function commandOf(input: unknown): string | undefined {
7  if (typeof input !== 'object' || input === null || !('command' in input)) {
8    return undefined
9  }
10
11  return typeof input.command === 'string' ? input.command : undefined
12}
13
14// What a tool call that needs you is waiting for, in a few words.
15export function describe(tool: string, input: unknown): string {
16  if (tool === 'AskUserQuestion') {
17    return 'ti ha fatto una domanda'
18  }
19
20  if (tool === 'ExitPlanMode') {
21    return 'ti propone un piano da approvare'
22  }
23
24  const command = commandOf(input)
25
26  if (command !== undefined) {
27    const short = command.trim().split('\n')[0] ?? ''
28
29    return `vuole il permesso per: ${short.length > 60 ? `${short.slice(0, 59)}…` : short}`
30  }
31
32  return `vuole il permesso per usare ${tool}`
33}
34
35// The waits that have lasted `afterMs` and have not had their call yet.
36export function dueWaits(waits: ReadonlyMap<string, Wait>, now: number, afterMs: number): string[] {
37  return [...waits].filter(([, w]) => !w.isCalled && now - w.since >= afterMs).map(([id]) => id)
38}
39
40// The notification's title for a wait that has lasted `ms`.
41export function titleFor(ms: number): string {
42  const minutes = Math.max(1, Math.round(ms / 60_000))
43
44  return `Claude ti aspetta da ${minutes} ${minutes === 1 ? 'minuto' : 'minuti'}`
45}
46