@cmodjs/core 0.1.4 → 0.1.6

package/src/jobs/prompt.ts

@@ -1,9 +1,9 @@
-import type { Mod, Part, PartContext } from '../mod.js'
+import type { Job, JobContext, Mod } from '../mod.js'
 import { longestMs, type Deadline } from '../runtime/deadline.js'
 import { listed, messageOf } from '../utils/text.js'
 import { callEffects, type ToolCall } from '../utils/call-effects.js'
 import { matchTarget, targetOf, type Target } from './permissions/match-target.js'
-import { afterCall, modOf, modWithin, targetWords } from './part-context.js'
+import { afterCall, modOf, modWithin, targetWords } from './context.js'
 
 type PromptInput = { userPrompt?: string; call?: ToolCall }
 
@@ -16,16 +16,16 @@ type PromptOptions<State extends object> = {
 
 const deadline: Deadline = { ms: 5000, longestMs, job: 'prompt' }
 
-export function prompt<State extends object = Record<never, never>>({ name, prompt: text, when, after }: PromptOptions<State>): Part<void, State> {
+export function prompt<State extends object = Record<never, never>>({ name, prompt: text, when, after }: PromptOptions<State>): Job<void, State> {
   if (name.trim() === '') throw new Error('prompt: give the block a name. Claude reads the text under it.')
   if (when !== undefined && after !== undefined) throw new Error(`prompt "${name}": use when or after, not both. Add a second prompt for the other trigger.`)
   const targets = after === undefined ? [] : Array.isArray(after) ? after : [after]
   for (const target of targets) targetOf(target)
 
-  return (part) => {
-    part.reserveName('prompt', name, `prompt: ${part.mod.name} adds the name "${name}" two times. Give each prompt its own name.`)
+  return (job) => {
+    job.reserveName('prompt', name, `prompt: ${job.mod.name} adds the name "${name}" two times. Give each prompt its own name.`)
 
-    const log = (reason: string) => part.claude.ui.log(`prompt "${name}" added nothing: ${reason}`, { to: 'debug' })
+    const log = (reason: string) => job.claude.ui.log(`prompt "${name}" added nothing: ${reason}`, { to: 'debug' })
     const textFor = async (input: PromptInput, mod: Mod<State>) => {
       try {
         const value = typeof text === 'string' ? text : await text(input, mod)
@@ -42,20 +42,20 @@ export function prompt<State extends object = Record<never, never>>({ name, prom
     }
 
     if (when !== undefined) {
-      addAfterUserPrompts(part, when, (userPrompt) => headedText({ userPrompt }, modWithin(part, deadline)), log)
-      part.announce(`the ${name} prompt after matching user prompts`)
+      addAfterUserPrompts(job, when, (userPrompt) => headedText({ userPrompt }, modWithin(job, deadline)), log)
+      job.announce(`the ${name} prompt after matching user prompts`)
     } else if (targets.length > 0) {
-      addAfterCalls(part, targets, headedText, log)
-      part.announce(`the ${name} prompt after ${listed(targets.map(targetWords))}`)
+      addAfterCalls(job, targets, headedText, log)
+      job.announce(`the ${name} prompt after ${listed(targets.map(targetWords))}`)
     } else {
-      addOncePerConversation(part, name, () => textFor({}, modWithin(part, deadline)), log)
-      part.announce(`the ${name} prompt`)
+      addOncePerConversation(job, name, () => textFor({}, modWithin(job, deadline)), log)
+      job.announce(`the ${name} prompt`)
     }
   }
 }
 
-function addOncePerConversation(part: PartContext, name: string, textFor: () => Promise<string | undefined>, log: (reason: string) => void): void {
-  part.on('prompt.context', async (e, next) => {
+function addOncePerConversation(job: JobContext, name: string, textFor: () => Promise<string | undefined>, log: (reason: string) => void): void {
+  job.on('prompt.context', async (e, next) => {
     const below = await next(e)
     if (below.blocks.some((block) => block.name === name)) {
       log(`a block named "${name}" is already in the context`)
@@ -66,8 +66,8 @@ function addOncePerConversation(part: PartContext, name: string, textFor: () =>
   })
 }
 
-function addAfterUserPrompts(part: PartContext, when: RegExp | ((userPrompt: string) => boolean), textFor: (userPrompt: string) => Promise<string | undefined>, log: (reason: string) => void): void {
-  part.on('prompt.submit', async (e, next) => {
+function addAfterUserPrompts(job: JobContext, when: RegExp | ((userPrompt: string) => boolean), textFor: (userPrompt: string) => Promise<string | undefined>, log: (reason: string) => void): void {
+  job.on('prompt.submit', async (e, next) => {
     let value: string | undefined
     try {
       if (typeof when === 'function' ? when(e.text) : e.text.search(when) >= 0) value = await textFor(e.text)
@@ -79,19 +79,19 @@ function addAfterUserPrompts(part: PartContext, when: RegExp | ((userPrompt: str
 }
 
 function addAfterCalls<State extends object>(
-  part: PartContext<State>,
+  job: JobContext<State>,
   targets: Target[],
   textFor: (input: PromptInput, mod: Mod<State>) => Promise<string | undefined>,
   log: (reason: string) => void,
 ): void {
   afterCall(
-    part,
+    job,
     async (use, workspace) => {
       const effects = callEffects(use, workspace)
       for (const target of targets) {
         const [matched] = await matchTarget(target, use, effects, workspace)
         if (matched === undefined) continue
-        const value = await textFor({ call: matched.call }, modOf(part, matched, workspace, deadline))
+        const value = await textFor({ call: matched.call }, modOf(job, matched, workspace, deadline))
         return value === undefined ? [] : [value]
       }
       return []

package/src/jobs/slash-command.ts

@@ -1,9 +1,9 @@
 import type { CommandRunResult } from 'claude-code'
-import type { Mod, Part } from '../mod.js'
+import type { Job, Mod } from '../mod.js'
 import { parse } from '../vendor.js'
 import { longestMs, type Deadline } from '../runtime/deadline.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './part-context.js'
+import { modWithin } from './context.js'
 
 export type Reply = string | { text?: string; context?: string } | undefined
 
@@ -17,10 +17,10 @@ export function slashCommand<State extends object = Record<never, never>>(option
   readonly argumentHint?: string
   readonly immediate?: true
   readonly reply: (input: { args: string; positionals: string[] }, mod: Mod<State>) => Reply | void | Promise<Reply | void>
-}): Part<void, State> {
+}): Job<void, State> {
   const { name, description, argumentHint, immediate, reply } = options
-  return (part) => {
-    const { mod, claude, on, announce, reserveName } = part
+  return (job) => {
+    const { mod, claude, announce, reserveName } = job
     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.`)
 
@@ -35,8 +35,8 @@ export function slashCommand<State extends object = Record<never, never>>(option
     )
     announce(`/${name}`)
 
-    const replyMod = modWithin(part, deadline)
-    on('command.run', async (e, next) => {
+    const replyMod = modWithin(job, deadline)
+    job.on('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))

package/src/jobs/status-line.ts

@@ -1,7 +1,7 @@
-import type { Mod, Part } from '../mod.js'
+import type { Job, Mod } from '../mod.js'
 import type { Deadline } from '../runtime/deadline.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './part-context.js'
+import { modWithin } from './context.js'
 
 export type Usage = {
   model: string
@@ -14,14 +14,14 @@ const deadline: Deadline = { ms: 2000, job: 'statusLine' }
 export function statusLine<State extends object = Record<never, never>>(options: {
   readonly text: (usage: Usage, mod: Mod<State>) => string | undefined | Promise<string | undefined>
   readonly interval?: number
-}): Part<void, State> {
+}): Job<void, State> {
   const { text, interval = 10000 } = options
-  return (part) => {
-    const { mod, claude, on, announce, reserveName } = part
+  return (job) => {
+    const { mod, claude, announce, reserveName } = job
     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(part, deadline)
+    const textMod = modWithin(job, deadline)
     let shown: string | undefined
     let queue = Promise.resolve()
     const update = async () => {
@@ -48,7 +48,7 @@ export function statusLine<State extends object = Record<never, never>>(options:
     }
 
     announce('a status line')
-    on('session.measure', (e, next) => {
+    job.on('session.measure', (e, next) => {
       refresh()
       return next(e)
     })

package/src/jobs/tool.ts

@@ -1,10 +1,10 @@
 import type { FromSchema, JSONSchema } from 'json-schema-to-ts'
-import type { Mod, Part } from '../mod.js'
+import type { Job, Mod } from '../mod.js'
 import { Validator } from '../vendor.js'
 import { toolDeadline } from '../runtime/deadline.js'
 import { reservedKeys, toolInputOf } from '../runtime/tool-calls.js'
 import { messageOf } from '../utils/text.js'
-import { modWithin } from './part-context.js'
+import { modWithin } from './context.js'
 
 const toolName = /^[A-Za-z0-9_-]{1,64}$/
 
@@ -13,10 +13,10 @@ 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
-}): Part<{ readonly name: string }, State> {
+}): Job<{ readonly name: string }, State> {
   const { name, description, inputSchema, execute } = options
-  return (part) => {
-    const { mod, claude, on, announce, reserveName } = part
+  return (job) => {
+    const { mod, claude, announce, reserveName } = job
     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))
@@ -35,8 +35,8 @@ export function tool<const Schema extends object = { type: 'object' }, State ext
     )
     announce(`the ${name} tool`)
 
-    const executeMod = modWithin(part, toolDeadline)
-    on('tool.call', async (e, next) => {
+    const executeMod = modWithin(job, toolDeadline)
+    job.on('tool.call', async (e, next) => {
       if (e.tool !== registered) return next(e)
       const input = toolInputOf(e)
       const { valid, errors } = validator.validate(input)

package/src/mod.ts

@@ -111,7 +111,7 @@ export type Mod<State extends object = Record<never, never>> = {
   readonly state: Readonly<State>
   readonly dataFolder: string
   on<E extends ModEvent>(event: E, hook: ModHook<E>): void
-  use<Handle>(part: Part<Handle, State>): Handle
+  use<Handle>(job: Job<Handle, State>): Handle
   readonly ui: {
     pane(pane: Pane<State>): PaneHandle
     render<S extends Slot>(slot: S, Component: (props: SlotProps<S>) => RenderElement): void
@@ -157,7 +157,7 @@ export type ModDefinition<State extends StateGroups = Record<never, never>, Name
   setup(mod: Mod<State>): void | Promise<void>
 }
 
-export type PartContext<State extends object = Record<never, never>> = {
+export type JobContext<State extends object = Record<never, never>> = {
   readonly mod: Mod<State>
   readonly claude: Claude
   on<N extends RoutedEvent>(event: N, hook: RoutedHook<N>): void
@@ -166,7 +166,7 @@ export type PartContext<State extends object = Record<never, never>> = {
   readonly toolCalls: ToolCalls
 }
 
-export type Part<Handle, State extends object = Record<never, never>> = (context: PartContext<State>) => Handle
+export type Job<Handle, State extends object = Record<never, never>> = (context: JobContext<State>) => Handle
 
 export function defineMod<State extends StateGroups = Record<never, never>, Name extends string = string>(definition: ModDefinition<State, Name>): ModDefinition<State, Name> {
   if (definition.name.trim() === '') throw new Error('defineMod: the mod needs a name, such as the name in .claude-plugin/plugin.json.')

package/src/runtime/lifecycle.ts

@@ -1,5 +1,5 @@
 import type { Args, EventResult, Frozen, HookBudget, HookStream, ProcessSpawnChunk, ProcessSpawnResult } from 'claude-code'
-import type { Mod, ModDefinition, ModEvent, ModHook, PartContext } from '../mod.js'
+import type { Mod, ModDefinition, ModEvent, ModHook } from '../mod.js'
 import { dataFolder, isAtLeast, parseEvent, readRecord, readSteps, scriptsSha256, storeFolder, type ReadFile, type RunnerEvent } from '../records.js'
 import { relativePath } from '../utils/paths.js'
 import { formatExit, listed, messageOf } from '../utils/text.js'
@@ -355,7 +355,6 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
   const announce = (feature: string) => {
     added.push(feature)
   }
-  const on: PartContext<State>['on'] = (event, hook) => router.add(event, hook)
   const [session, root, startCwd] = await Promise.all([claude.session.id(), claude.session.root(), claude.session.cwd()])
   let cwd = startCwd
   let loadedCwd = startCwd
@@ -370,7 +369,7 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
       if (!hookEvents.includes(event)) hookEvents.push(event)
       router.add(`classic.${event}`, classicHook(definition.name, event, hook, claude, agents))
     },
-    use: (part) => part({ mod, claude, on, announce, reserveName, toolCalls: agents }),
+    use: (job) => job({ mod, claude, on: (event, hook) => router.add(event, hook), announce, reserveName, toolCalls: agents }),
     ui: area.ui,
     process: {
       run: (argv, init) => claude.process.run(argv, init),
@@ -414,32 +413,32 @@ async function createMod<State extends object>(definition: ModDefinition<State>,
       claude.ui.log(`${definition.name} keeps the state of ${modState.root} until the next prompt or folder move: ${messageOf(error)}`)
     }
   }
-  on('classic.SessionStart', async (e, next) => {
+  router.add('classic.SessionStart', async (e, next) => {
     await modState.switchSession(e.session_id, e.source).catch((error: unknown) => {
       claude.ui.log(`${definition.name} kept its session values from before the ${e.source}: ${messageOf(error)}`)
     })
     return next(e)
   })
-  on('classic.UserPromptSubmit', async (e, next) => {
+  router.add('classic.UserPromptSubmit', async (e, next) => {
     staleCwd = undefined
     await followSession()
     return next(e)
   })
   for (const event of ['classic.PostToolUse', 'classic.PostToolUseFailure'] as const) {
-    on(event, async (e, next) => {
+    router.add(event, async (e, next) => {
       if (shellTools.includes(e.tool_name)) await followSession()
       return next(e)
     })
   }
-  on('command.run', async (e, next) => {
+  router.add('command.run', async (e, next) => {
     const answer = await next(e)
     if (e.command === 'cd') await followSession(true)
     return answer
   })
-  on('skill.prompt', userSkillHook(claude))
+  router.add('skill.prompt', userSkillHook(claude))
   const api = Object.fromEntries(Object.entries(definition.api ?? {}).map(([method, run]) => [method, (input: never) => run(input, mod)]))
-  on('cmod.call', (e, next) => (e.to === definition.name ? answerCall(definition.name, api, e) : next(e)))
-  const agents = toolCalls({ claude, on })
+  router.add('cmod.call', (e, next) => (e.to === definition.name ? answerCall(definition.name, api, e) : next(e)))
+  const agents = toolCalls(claude, router)
   const names = new Set<string>()
   const reserveName = (kind: string, name: string, taken: string) => {
     const key = `${kind}:${name}`

package/src/runtime/tool-calls.ts

@@ -1,4 +1,5 @@
-import type { PartContext } from '../mod.js'
+import type { Claude } from './claude.js'
+import type { Router } from './router.js'
 
 export type Agent = { agentId?: string; agentType?: string }
 
@@ -17,22 +18,22 @@ type AgentFields = { readonly agent_id?: string; readonly agent_type?: string }
 
 const keptCalls = 100
 
-export function toolCalls({ claude, on }: Pick<PartContext, 'claude' | 'on'>): ToolCalls {
+export function toolCalls(claude: Claude, router: Router): ToolCalls {
   let mainAgentType: string | undefined
   const agentIds = new Map<string, string>()
   const cwds = new Map<string, string>()
   const noteAgent = (e: AgentFields) => {
     if (e.agent_id === undefined) mainAgentType = e.agent_type
   }
-  on('classic.SessionStart', (e, next) => {
+  router.add('classic.SessionStart', (e, next) => {
     noteAgent(e)
     return next(e)
   })
-  on('classic.UserPromptSubmit', (e, next) => {
+  router.add('classic.UserPromptSubmit', (e, next) => {
     noteAgent(e)
     return next(e)
   })
-  on('tool.call', async (e, next) => {
+  router.add('tool.call', async (e, next) => {
     if (e.agentId === undefined) return next(e)
     agentIds.set(e.tool_use_id, e.agentId)
     try {
@@ -41,7 +42,7 @@ export function toolCalls({ claude, on }: Pick<PartContext, 'claude' | 'on'>): T
       agentIds.delete(e.tool_use_id)
     }
   })
-  on('classic.PreToolUse', async (e, next) => {
+  router.add('classic.PreToolUse', async (e, next) => {
     cwds.set(e.tool_use_id, await claude.session.cwd())
     for (const oldest of cwds.keys()) {
       if (cwds.size <= keptCalls) break
@@ -50,7 +51,7 @@ export function toolCalls({ claude, on }: Pick<PartContext, 'claude' | 'on'>): T
     return next(e)
   })
   for (const event of ['classic.PostToolUse', 'classic.PostToolUseFailure'] as const) {
-    on(event, async (e, next) => {
+    router.add(event, async (e, next) => {
       try {
         return await next(e)
       } finally {

package/jobs/part-context.d.ts

@@ -1,14 +0,0 @@
-import type { Mod, PartContext } from '../mod.js';
-import { type Deadline } from '../runtime/deadline.js';
-import type { ToolCall, ToolUse } from '../utils/call-effects.js';
-import { type Workspace } from './permissions/find-project-scope.js';
-import { type Target } from './permissions/match-target.js';
-export declare function workspaceReader({ claude }: PartContext): () => Promise<Workspace>;
-export declare function afterCall<State extends object>(part: PartContext<State>, contextAfter: (use: ToolUse, workspace: Workspace) => Promise<readonly string[]>, failed: (error: unknown) => readonly string[]): void;
-export declare function modOf<State extends object>(context: PartContext<State>, { call, folder }: {
-    readonly call?: ToolCall;
-    readonly folder: string;
-}, workspace: Workspace, deadline: Deadline): Mod<State>;
-export declare function modWithin<State extends object>({ mod, claude }: PartContext<State>, deadline: Deadline, workTree?: () => Promise<string | undefined>): Mod<State>;
-export declare function targetWords(target: Target): string;
-//# sourceMappingURL=part-context.d.ts.map

package/jobs/part-context.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"part-context.d.ts","sourceRoot":"","sources":["../src/jobs/part-context.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,GAAG,EAAE,WAAW,EAAE,MAAM,WAAW,CAAA;AAEjD,OAAO,EAAkB,KAAK,QAAQ,EAAE,MAAM,wBAAwB,CAAA;AAItE,OAAO,KAAK,EAAE,QAAQ,EAAE,OAAO,EAAE,MAAM,0BAA0B,CAAA;AACjE,OAAO,EAAoB,KAAK,SAAS,EAAE,MAAM,qCAAqC,CAAA;AACtF,OAAO,EAAY,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAA;AAOrE,wBAAgB,eAAe,CAAC,EAAE,MAAM,EAAE,EAAE,WAAW,GAAG,MAAM,OAAO,CAAC,SAAS,CAAC,CAOjF;AAaD,wBAAgB,SAAS,CAAC,KAAK,SAAS,MAAM,EAC5C,IAAI,EAAE,WAAW,CAAC,KAAK,CAAC,EACxB,YAAY,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,KAAK,OAAO,CAAC,SAAS,MAAM,EAAE,CAAC,EAChF,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,KAAK,SAAS,MAAM,EAAE,GAC5C,IAAI,CAUN;AAMD,wBAAgB,KAAK,CAAC,KAAK,SAAS,MAAM,EAAE,OAAO,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,EAAE,IAAI,EAAE,MAAM,EAAE,EAAE;IAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,MAAM,EAAE,MAAM,CAAA;CAAE,EAAE,SAAS,EAAE,SAAS,EAAE,QAAQ,EAAE,QAAQ,GAAG,GAAG,CAAC,KAAK,CAAC,CAEtM;AAED,wBAAgB,SAAS,CAAC,KAAK,SAAS,MAAM,EAAE,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE,WAAW,CAAC,KAAK,CAAC,EAAE,QAAQ,EAAE,QAAQ,EAAE,QAAQ,GAAE,MAAM,OAAO,CAAC,MAAM,GAAG,SAAS,CAAyB,GAAG,GAAG,CAAC,KAAK,CAAC,CAwBxL;AAwBD,wBAAgB,WAAW,CAAC,MAAM,EAAE,MAAM,GAAG,MAAM,CASlD"}