@cmodjs/core 0.2.3 → 1.0.0

package/src/jobs/schedule.ts

@@ -1,37 +1,37 @@
 import type { Job } from '../mod.js'
 import { onStateChange } from '../runtime/state.js'
-import { messageOf } from '../utils/text.js'
+import { engineOf } from '../runtime/engine.js'
 
-export type Schedule = { readonly cron: string; readonly prompt: string }
+export type ScheduledPrompt = { readonly cron: string; readonly prompt: string }
 
 const scheduleCounts = new WeakMap<object, number>()
 
-export function schedule<State extends object = Record<never, never>>(entry: Schedule | ((state: State) => Schedule | undefined)): Job<void, State> {
+export function schedule<State extends object = Record<never, never>>(entry: ScheduledPrompt | ((state: State) => ScheduledPrompt | undefined)): Job<void, State> {
   if (typeof entry !== 'function') checked(entry)
 
   return (job) => {
     const { mod } = job
-    const { claude } = mod
+    const { claude, report: reportFailure } = engineOf(mod)
     const order = scheduleCounts.get(mod) ?? 0
     scheduleCounts.set(mod, order + 1)
     const storeKey = `cmod:schedule:${order}`
-    const log = (reason: string) => claude.ui.log(`${mod.name}: the schedule ${reason}`)
+    const report = (message: string, error: unknown) => reportFailure({ id: storeKey, message: `The schedule ${message}`, error })
     let current: { readonly id: string; readonly wanted: string } | undefined
     let isQueued = false
 
     const remove = async (id: string) => {
-      await claude.tool.call({ tool: 'CronDelete', id }).catch(() => undefined)
+      await claude.tool.call({ tool: 'CronDelete', id }).catch((error: unknown) => report(`could not delete its last cron ${id}`, error))
       await claude.store.delete(storeKey)
     }
 
     const update = async () => {
       isQueued = false
-      let next: Schedule | undefined
+      let next: ScheduledPrompt | undefined
       try {
-        next = typeof entry === 'function' ? entry(mod.state as State) : entry
+        next = typeof entry === 'function' ? entry(mod.state) : entry
         if (next !== undefined) checked(next)
       } catch (error) {
-        log(`kept its last cron: ${messageOf(error)}`)
+        report('kept its last cron', error)
         return
       }
       const wanted = next === undefined ? undefined : JSON.stringify([next.cron, next.prompt])
@@ -40,8 +40,8 @@ export function schedule<State extends object = Record<never, never>>(entry: Sch
       current = undefined
       if (next === undefined) return
       const answer = await claude.tool.call({ tool: 'CronCreate', cron: next.cron, prompt: next.prompt, recurring: true })
-      if (answer.deny !== undefined) return log(`was refused: ${answer.deny}`)
-      if (answer.isError === true) return log(`failed: ${answer.text ?? 'CronCreate answered an error'}`)
+      if (answer.deny !== undefined) return report('was refused', answer.deny)
+      if (answer.isError === true) return report('failed', answer.text ?? 'CronCreate answered an error')
       current = { id: answer.result.id, wanted: wanted as string }
       await claude.store.set(storeKey, current.id)
     }
@@ -50,17 +50,17 @@ export function schedule<State extends object = Record<never, never>>(entry: Sch
       .get(storeKey)
       .then((left) => (typeof left === 'string' ? remove(left) : undefined))
       .then(update)
-      .catch((error: unknown) => log(`failed: ${messageOf(error)}`))
+      .catch((error: unknown) => report('failed', error))
     onStateChange(mod.state, () => {
       if (isQueued) return
       isQueued = true
-      updates = updates.then(update).catch((error: unknown) => log(`failed: ${messageOf(error)}`))
+      updates = updates.then(update).catch((error: unknown) => report('failed', error))
     })
     job.announce(typeof entry === 'function' ? 'a schedule from its state' : `a schedule at ${entry.cron}`)
   }
 }
 
-function checked(entry: Schedule): void {
+function checked(entry: ScheduledPrompt): void {
   if (entry.cron.trim() === '') throw new Error('schedule: give it a cron, such as "*/10 * * * *" for every 10 minutes.')
   if (entry.prompt.trim() === '') throw new Error('schedule: give it the prompt Claude gets at each fire.')
 }

package/src/jobs/slash-command.ts

@@ -1,13 +1,14 @@
 import type { CommandRunResult } from 'claude-code'
-import type { Job, Mod } from '../mod.js'
+import type { Disposable, Job, Mod } from '../mod.js'
 import { parse } from '../vendor.js'
-import { longestMs, type Deadline } from '../runtime/deadline.js'
+import type { Deadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './context.js'
+import { withinDeadline } from './context.js'
 
-export type Reply = string | { text?: string; context?: string } | undefined
+export type CommandReply = string | { text?: string; context?: string } | undefined
 
-const deadline: Deadline = { ms: 30000, longestMs, job: 'slashCommand' }
+const deadline: Deadline = { ms: 30000, job: 'slashCommand' }
 
 const commandName = /^[A-Za-z0-9_-]{1,64}$/
 
@@ -16,14 +17,14 @@ export function slashCommand<State extends object = Record<never, never>>(option
   readonly description: string
   readonly argumentHint?: string
   readonly immediate?: true
-  readonly reply: (input: { args: string; positionals: string[] }, mod: Mod<State>) => Reply | void | Promise<Reply | void>
-}): Job<void, State> {
+  readonly reply: (input: { args: string; positionals: string[] }, mod: Mod<State>) => CommandReply | void | Promise<CommandReply | void>
+}): Job<Disposable, State> {
   const { name, description, argumentHint, immediate, reply } = options
   return (job) => {
     const { mod, announce, reserveName } = job
-    const { claude } = mod
+    const { claude, router, report } = engineOf(mod)
     if (!commandName.test(name)) throw new Error(`${mod.name}: "${name}" is not a slash command name. Use 1 to 64 letters, digits, "_", or "-", without the slash.`)
-    reserveName('slashCommand', name, `${mod.name}: the slash command /${name} is already added. Give each slashCommand its own name.`)
+    const reserved = reserveName('slashCommand', name, `${mod.name}: the slash command /${name} is already added. Give each slashCommand its own name.`)
 
     let registered: string | undefined
     claude.command.register({ name, description, ...(argumentHint === undefined ? {} : { argumentHint }), ...(immediate === undefined ? {} : { immediate }) }).then(
@@ -31,24 +32,29 @@ export function slashCommand<State extends object = Record<never, never>>(option
         registered = command
       },
       (error: unknown) => {
-        claude.ui.log(`${mod.name}: /${name} is not added: ${oneLine(error)}`)
+        report({ id: `command:${name}`, message: `/${name} is not added`, error })
       },
     )
     announce(`/${name}`)
 
-    const replyMod = modWithin(job, deadline)
-    claude.on('command.run', async (e, next) => {
+    const answering = router.add('command.run', async (e, next) => {
       if (e.command !== registered) return next(e)
       try {
-        return answerOf(await reply({ args: e.args, positionals: splitWords(e.args) }, replyMod))
+        return answerOf(await withinDeadline(mod, deadline, `/${name}`, () => reply({ args: e.args, positionals: splitWords(e.args) }, mod)))
       } catch (error) {
         return { text: `/${name} failed: ${oneLine(error)}` }
       }
     })
+    return {
+      dispose() {
+        answering.dispose()
+        reserved.dispose()
+      },
+    }
   }
 }
 
-function answerOf(reply: Reply | void): CommandRunResult {
+function answerOf(reply: CommandReply | void): CommandRunResult {
   if (reply === undefined) return {}
   if (typeof reply === 'string') return { text: reply }
   return { ...(reply.text === undefined ? {} : { text: reply.text }), ...(reply.context === undefined ? {} : { context: [reply.context] }) }

package/src/jobs/status-line.ts

@@ -1,13 +1,10 @@
 import type { Job, Mod } from '../mod.js'
 import type { Deadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
+import { usageOf } from '../runtime/sessions.js'
+import type { Usage } from '../session/session.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './context.js'
-
-export type Usage = {
-  model: string
-  context: { tokens?: number; window: number; percent?: number }
-  cost?: { usd: number }
-}
+import { withinDeadline } from './context.js'
 
 const deadline: Deadline = { ms: 2000, job: 'statusLine' }
 
@@ -18,30 +15,21 @@ export function statusLine<State extends object = Record<never, never>>(options:
   const { text, interval = 10000 } = options
   return (job) => {
     const { mod, announce, reserveName } = job
-    const { claude } = mod
+    const { claude, router } = engineOf(mod)
     if (!(interval >= 1)) throw new Error(`${mod.name}: the status line interval is ${interval}. Give it in milliseconds, 1 or more.`)
     reserveName('statusLine', '', `${mod.name}: a status line is already added. A mod has one status line: join the texts in one statusLine.`)
 
-    const textMod = modWithin(job, deadline)
     let shown: string | undefined
     let queue = Promise.resolve()
     const update = async () => {
       try {
-        const [model, usage] = await Promise.all([claude.session.model(), claude.session.usage()])
-        const { tokens, window, percent } = usage.context
-        const next = await text(
-          {
-            model,
-            context: { window, ...(tokens === undefined ? {} : { tokens }), ...(percent === undefined ? {} : { percent }) },
-            ...(usage.cost === undefined ? {} : { cost: { usd: usage.cost.usd } }),
-          },
-          textMod,
-        )
+        const usage = await usageOf(claude)
+        const next = await withinDeadline(mod, deadline, 'the status line', () => text(usage, mod))
         if (next === shown) return
         shown = next
         claude.ui.status(next)
       } catch (error) {
-        claude.ui.log(`${mod.name}: the status line kept its last text: ${messageOf(error)}`, { to: 'debug' })
+        mod.log(`the status line kept its last text: ${messageOf(error)}`)
       }
     }
     const refresh = () => {
@@ -49,7 +37,7 @@ export function statusLine<State extends object = Record<never, never>>(options:
     }
 
     announce('a status line')
-    claude.on('session.measure', (e, next) => {
+    router.add('session.measure', (e, next) => {
       refresh()
       return next(e)
     })

package/src/jobs/tool.ts

@@ -1,10 +1,11 @@
 import type { FromSchema, JSONSchema } from 'json-schema-to-ts'
-import type { Job, Mod } from '../mod.js'
+import type { Disposable, Job, Mod } from '../mod.js'
 import { Validator } from '../vendor.js'
 import { toolDeadline } from '../runtime/deadline.js'
+import { engineOf } from '../runtime/engine.js'
 import { reservedKeys, toolInputOf } from '../runtime/tool-calls.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './context.js'
+import { withinDeadline } from './context.js'
 
 const toolName = /^[A-Za-z0-9_-]{1,64}$/
 
@@ -13,42 +14,47 @@ export function tool<const Schema extends object = { type: 'object' }, State ext
   readonly description: string
   readonly inputSchema?: Schema
   readonly execute: (input: Schema extends JSONSchema ? FromSchema<Schema> : never, mod: Mod<State>) => unknown
-}): Job<{ readonly name: string }, State> {
+}): Job<Disposable & { readonly name: string }, State> {
   const { name, description, inputSchema, execute } = options
   return (job) => {
     const { mod, announce, reserveName } = job
-    const { claude } = mod
+    const { claude, router, report } = engineOf(mod)
     if (!toolName.test(name)) throw new Error(`${mod.name}: "${name}" is not a tool name. Use 1 to 64 letters, digits, "_", or "-".`)
     const properties = (inputSchema as { properties?: object } | undefined)?.properties ?? {}
     const reserved = reservedKeys.filter((key) => Object.hasOwn(properties, key))
     if (reserved.length > 0) throw new Error(`${mod.name}: the ${name} tool's inputSchema has the property ${reserved.join(', ')}, which Claude Code keeps for itself. Rename it.`)
-    reserveName('tool', name, `${mod.name}: the tool ${name} is already added. Give each tool its own name.`)
+    const named = reserveName('tool', name, `${mod.name}: the tool ${name} is already added. Give each tool its own name.`)
 
-    const validator = new Validator((inputSchema ?? { type: 'object' }) as ConstructorParameters<typeof Validator>[0], '2020-12', false)
+    const validator = new Validator(inputSchema ?? { type: 'object' }, '2020-12', false)
     let registered: string | undefined
     claude.tool.register({ name, description, ...(inputSchema === undefined ? {} : { inputSchema: inputSchema as Record<string, unknown> }) }).then(
       (answer) => {
         registered = answer.tool
       },
       (error: unknown) => {
-        claude.ui.log(`${mod.name}: the ${name} tool is not added: ${messageOf(error)}`)
+        report({ id: `tool:${name}`, message: `The ${name} tool is not added`, error })
       },
     )
     announce(`the ${name} tool`)
 
-    const executeMod = modWithin(job, toolDeadline)
-    claude.on('tool.call', async (e, next) => {
+    const answering = router.add('tool.call', async (e, next) => {
       if (e.tool !== registered) return next(e)
       const input = toolInputOf(e)
       const { valid, errors } = validator.validate(input)
       if (!valid) return { deny: `The ${name} tool input is not valid:\n${errors.map((error) => `- ${error.instanceLocation}: ${error.error}`).join('\n')}` }
       try {
-        return { result: resultOf(await execute(input as Parameters<typeof execute>[0], executeMod)) }
+        return { result: resultOf(await withinDeadline(mod, toolDeadline, `the ${name} tool`, () => execute(input as Parameters<typeof execute>[0], mod))) }
       } catch (error) {
         return { deny: `The ${name} tool failed: ${messageOf(error)}` }
       }
     })
-    return { name: `mcp__${claude.plugin.name}__${name}` }
+    return {
+      name: `mcp__${claude.plugin.name}__${name}`,
+      dispose() {
+        answering.dispose()
+        named.dispose()
+      },
+    }
   }
 }