@cmodjs/core 1.6.0 → 2.0.1

package/src/jobs/status-line.ts

@@ -2,21 +2,18 @@ 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 { onStateChange } from '../runtime/state.js'
 import type { Usage } from '../session/session.js'
 import { messageOf } from '../utils/text.js'
 import { withinDeadline } from './context.js'
 
 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
-}): Job<void, State> {
-  const { text, interval = 10000 } = options
+export function statusLine<State extends object = Record<never, never>>(options: { readonly text: (usage: Usage, mod: Mod<State>) => string | undefined | Promise<string | undefined> }): Job<void, State> {
+  const { text } = options
   return (job) => {
     const { mod, announce, reserveName } = job
     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.`)
 
     let shown: string | undefined
@@ -41,7 +38,7 @@ export function statusLine<State extends object = Record<never, never>>(options:
       refresh()
       return next(e)
     })
-    claude.clock.every(interval, refresh)
+    onStateChange(mod.state, refresh)
     refresh()
   }
 }

package/src/mod.ts

@@ -1,8 +1,7 @@
 import type {
   AskOptions,
-  ClassicHookInputs,
   CmodDependencies,
-  ConfigRow,
+  ConfigRow as ClaudeConfigRow,
   FsStatOptions,
   HookStream,
   HttpInit,
@@ -11,7 +10,6 @@ import type {
   ModelCompleteRequest,
   ModelCompleteResult,
   PaneOpenArgs,
-  PermissionRequestDecision,
   ProcessRunInit,
   ProcessRunResult,
   ProcessSpawnChunk,
@@ -26,7 +24,7 @@ import type { Step } from './installer.js'
 import { checkOptions, type Option, type Options, type OptionValues } from './options.js'
 import { bound } from './runtime/bound.js'
 import { Mod as modSender } from './session/context/turn/message/sender.js'
-import type { Sessions } from './session/session.js'
+import { sessionEvents, type BeforeMethod, type CommandRun, type CommandRunAnswer, type OnMethod, type OnMethods, type Sessions } from './session/session.js'
 import type { Pane } from './ui/define-pane.js'
 import type { Place, PlaceProps } from './ui/places.js'
 import type { Disposable } from './utils/disposable.js'
@@ -67,132 +65,6 @@ export type PaneHandle = {
   readonly isFocused: boolean
 }
 
-export const SessionStart = 'SessionStart'
-export const SessionEnd = 'SessionEnd'
-export const UserPromptSubmit = 'UserPromptSubmit'
-export const InstructionsLoaded = 'InstructionsLoaded'
-export const PreToolUse = 'PreToolUse'
-export const PermissionRequest = 'PermissionRequest'
-export const PermissionDenied = 'PermissionDenied'
-export const PostToolUse = 'PostToolUse'
-export const PostToolUseFailure = 'PostToolUseFailure'
-export const PostToolBatch = 'PostToolBatch'
-export const SubagentStart = 'SubagentStart'
-export const SubagentStop = 'SubagentStop'
-export const Notification = 'Notification'
-export const PreCompact = 'PreCompact'
-export const Stop = 'Stop'
-export const StopFailure = 'StopFailure'
-export const CwdChanged = 'CwdChanged'
-export const FileChanged = 'FileChanged'
-export const UserPromptExpansion = 'UserPromptExpansion'
-export const Setup = 'Setup'
-export const ConfigChange = 'ConfigChange'
-export const DirectoryAdded = 'DirectoryAdded'
-export const PreModelSwitch = 'PreModelSwitch'
-export const PostModelSwitch = 'PostModelSwitch'
-export const PostCompact = 'PostCompact'
-export const MessageDisplay = 'MessageDisplay'
-export const TodoCreated = 'TaskCreated'
-export const TodoCompleted = 'TaskCompleted'
-export const TeammateIdle = 'TeammateIdle'
-export const Elicitation = 'Elicitation'
-export const ElicitationResult = 'ElicitationResult'
-export const WorktreeCreate = 'WorktreeCreate'
-export const WorktreeRemove = 'WorktreeRemove'
-
-export const hooks = [
-  Setup,
-  SessionStart,
-  SessionEnd,
-  UserPromptSubmit,
-  UserPromptExpansion,
-  InstructionsLoaded,
-  ConfigChange,
-  DirectoryAdded,
-  PreModelSwitch,
-  PostModelSwitch,
-  PreToolUse,
-  PermissionRequest,
-  PermissionDenied,
-  PostToolUse,
-  PostToolUseFailure,
-  PostToolBatch,
-  MessageDisplay,
-  SubagentStart,
-  SubagentStop,
-  TodoCreated,
-  TodoCompleted,
-  TeammateIdle,
-  Elicitation,
-  ElicitationResult,
-  Notification,
-  PreCompact,
-  PostCompact,
-  Stop,
-  StopFailure,
-  CwdChanged,
-  FileChanged,
-  WorktreeCreate,
-  WorktreeRemove,
-] as const
-
-export type Hook = (typeof hooks)[number]
-
-export type HookAnswer = {
-  continue?: boolean
-  stopReason?: string
-  suppressOutput?: boolean
-  systemMessage?: string
-  decision?: 'block'
-  reason?: string
-  hookSpecificOutput?: {
-    hookEventName?: Hook
-    additionalContext?: string
-    permissionDecision?: 'allow' | 'deny' | 'ask'
-    permissionDecisionReason?: string
-    updatedInput?: Record<string, unknown>
-    sessionTitle?: string
-    suppressOriginalPrompt?: boolean
-    initialUserMessage?: string
-    watchPaths?: string[]
-    reloadSkills?: boolean
-    decision?: PermissionRequestDecision
-    updatedToolOutput?: unknown
-    updatedMCPToolOutput?: unknown
-    retry?: boolean
-    displayContent?: string
-    worktreePath?: string
-  }
-}
-
-type CallFiles = { read: string[]; changed: string[] }
-
-type HookInputs = Omit<ClassicHookInputs, 'PreToolUse' | 'PostToolUse' | 'PostToolUseFailure' | 'CwdChanged'> & {
-  PreToolUse: {
-    session_id: string
-    cwd: string
-    hook_event_name: 'PreToolUse'
-    tool_name: string
-    tool_input: Record<string, unknown>
-    tool_use_id: string
-    agent_id?: string
-    agent_type?: string
-    files: CallFiles
-  }
-  PostToolUse: ClassicHookInputs['PostToolUse'] & { files: CallFiles }
-  PostToolUseFailure: ClassicHookInputs['PostToolUseFailure'] & { files: CallFiles }
-  CwdChanged: Omit<ClassicHookInputs['CwdChanged'], 'transcript_path'>
-}
-
-export type HookInput<H extends Hook> = HookInputs[H]
-
-export type HookListener<H extends Hook> = (input: HookInput<H>) => HookAnswer | void | Promise<HookAnswer | void>
-
-export type HookOptions = {
-  readonly timeoutMs?: number
-}
-
 export type Metadata = Readonly<Record<string, string>>
 
 export type FileMatch = {
@@ -215,6 +87,8 @@ export type Stat = Omit<Entry, 'name'> & {
   readonly realPath?: string
 }
 
+export type FileChange = { readonly path: string; readonly type: 'change' | 'add' | 'unlink' }
+
 export type Allowed = {
   allows(value: string): boolean
 }
@@ -237,15 +111,36 @@ export type SettingsFile = {
   update(values: Readonly<Record<string, unknown>>): Promise<void>
 }
 
-export type Setting = Pick<ConfigRow, 'key' | 'label' | 'kind' | 'value' | 'isLocked'> & {
+export type SettingsFileChange = { readonly source: 'user' | 'project' | 'local' | 'policy' | 'skills'; readonly path?: string }
+
+export type SettingsFileChangeListener = (change: SettingsFileChange) => { readonly refuse: string } | void | Promise<{ readonly refuse: string } | void>
+
+export type ConfigRow = Pick<ClaudeConfigRow, 'key' | 'label' | 'kind' | 'value' | 'isLocked'> & {
   readonly description?: string
   readonly options?: readonly string[]
   readonly plugin?: string
 }
 
+export type CommandInfo = { readonly name: string; readonly description: string; readonly source: 'builtin' | 'plugin' | 'user' | 'mcp'; readonly plugin?: string }
+
+export type CommandRunResult = { readonly text?: string; readonly note?: string }
+
 export type Imports = {
   readonly sessions: Sessions
-  readonly settings: { list(): Promise<Setting[]>; readonly user: SettingsFile; readonly project: SettingsFile; readonly local: SettingsFile }
+  readonly commands: {
+    list(): Promise<CommandInfo[]>
+    run(name: string, args?: string): Promise<CommandRunResult>
+    readonly beforeRun: BeforeMethod<CommandRun, CommandRunAnswer>
+    readonly onRun: OnMethod<CommandRun>
+  }
+  readonly config: { list(): Promise<ConfigRow[]> }
+  readonly settings: {
+    readonly user: SettingsFile
+    readonly project: SettingsFile
+    readonly local: SettingsFile
+    beforeFileChange(listener: SettingsFileChangeListener): Disposable
+    beforeFileChange(matcher: Matcher<SettingsFileChange>, listener: SettingsFileChangeListener): Disposable
+  }
   readonly model: { complete(request: ModelCompleteRequest, options?: ModelCompleteOptions): Promise<ModelCompleteResult> }
   readonly fs: {
     read(path: string): Promise<string>
@@ -254,6 +149,7 @@ export type Imports = {
     find(glob: string | readonly string[]): Promise<readonly FileMatch[]>
     list(path?: string): Promise<Entry[]>
     stat(path: string, options?: FsStatOptions): Promise<Stat>
+    onChange(matcher: { readonly path: string | readonly string[] }, listener: (change: FileChange) => unknown): Disposable
   }
   readonly metadata: {
     read(path: string): Promise<Metadata>
@@ -271,16 +167,26 @@ export const sessions: Imports['sessions'] = {
     return bound().sessions.current
   },
   list: (options) => bound().sessions.list(options),
-  search: (text, options) => bound().sessions.search(text, options),
-  on: ((...args: Parameters<Imports['sessions']['on']>) => bound().sessions.on(...args)) as Imports['sessions']['on'],
-  before: ((...args: Parameters<Imports['sessions']['before']>) => bound().sessions.before(...args)) as Imports['sessions']['before'],
+  search: (text, matcher, options) => bound().sessions.search(text, matcher, options),
+  ...(Object.fromEntries(Object.keys(sessionEvents).map((named) => [`on${named}`, (...args: unknown[]) => (bound().sessions[`on${named}` as keyof OnMethods] as (...each: unknown[]) => Disposable)(...args)])) as OnMethods),
 }
 
 export const settings: Imports['settings'] = {
-  list: () => bound().settings.list(),
   user: { read: () => bound().settings.user.read(), update: (values) => bound().settings.user.update(values) },
   project: { read: () => bound().settings.project.read(), update: (values) => bound().settings.project.update(values) },
   local: { read: () => bound().settings.local.read(), update: (values) => bound().settings.local.update(values) },
+  beforeFileChange: ((matcherOrListener: never, listener?: never) => bound().settings.beforeFileChange(matcherOrListener, listener as never)) as Imports['settings']['beforeFileChange'],
+}
+
+export const commands: Imports['commands'] = {
+  list: () => bound().commands.list(),
+  run: (name, args) => bound().commands.run(name, args),
+  beforeRun: ((...args: never[]) => (bound().commands.beforeRun as (...each: never[]) => Disposable)(...args)) as Imports['commands']['beforeRun'],
+  onRun: ((...args: never[]) => (bound().commands.onRun as (...each: never[]) => Disposable)(...args)) as Imports['commands']['onRun'],
+}
+
+export const config: Imports['config'] = {
+  list: () => bound().config.list(),
 }
 
 export const model: Imports['model'] = {
@@ -294,6 +200,7 @@ export const fs: Imports['fs'] = {
   find: (glob) => bound().fs.find(glob),
   list: (path) => bound().fs.list(path),
   stat: (path, options) => bound().fs.stat(path, options),
+  onChange: (matcher, listener) => bound().fs.onChange(matcher, listener),
 }
 
 export const metadata: Imports['metadata'] = {
@@ -317,12 +224,10 @@ export type Mod<State extends object = Record<never, never>, Declared extends Op
   readonly state: Readonly<State>
   readonly options: OptionValues<Declared>
   readonly permissions: Permissions
-  on<H extends Hook>(hook: H, listener: HookListener<H>, options?: HookOptions): Disposable
-  on<H extends Hook>(hook: H, matcher: Matcher<HookInput<H>>, listener: HookListener<H>, options?: HookOptions): Disposable
   every(ms: number, listener: () => unknown): Disposable
   after(ms: number, listener: () => unknown): Disposable
   use<Handle>(job: Job<Handle, State>): Handle
-  log(text: string): void
+  log(text: string, options?: { readonly to?: 'debug' | 'transcript' }): void
   readonly ui: {
     pane(pane: Pane<State>): PaneHandle
     render<P extends Place>(place: P, Component: (props: PlaceProps<P>) => RenderElement): Disposable
@@ -378,21 +283,21 @@ export function defineMod<State extends StateGroups = Record<never, never>, Name
 export type { Matcher } from './utils/matcher.js'
 export type { Place, PlaceProps } from './ui/places.js'
 export { AbovePrompt, AskUserQuestion, CommandOutput, PromptHint, SessionMode, Spinner, ToolGroup, ToolProgress, TurnDuration } from './ui/places.js'
-export { Session, UsageChange, type BeforeAnswer, type BeforeEvent, type BeforeListener, type Client, type Listener, type RecordPart, type Refusal, type SearchOptions, type SessionEvent, type SessionPayload, type SessionScope, type SessionSend, type Sessions, type TaskStartArgs, type ToolCallArgs, type Usage } from './session/session.js'
-export { ContextEnd, ContextStart, type Context } from './session/context/context.js'
-export { TurnEnd, TurnStart, type Turn } from './session/context/turn/turn.js'
-export { Message, type MessageType } from './session/context/turn/message/message.js'
+export { Session, type AnswerOptions, type BeforeMethods, type Surface, type Listener, type ListenerTime, type OnMethods, type ReadOptions, type RecordPart, type Refusal, type SearchOptions, type SessionScope, type SessionSend, type Sessions, type CurrentSession, type Placement, type ProjectSetup, type SessionStartAsked, type SessionStarted, type SessionEnded, type ModelChange, type CwdChange, type DirectoryAdd, type Worktree, type Notification, type Elicitation, type ElicitationResponse, type McpServer, type PermissionUpdate, type PermissionCheck, type PermissionRequest, type PermissionDenial, type BatchedCall, type ToolBatch, type Todo, type ReplyDisplay, type TaskOwner, type TaskStartArgs, type ToolCallArgs, type Usage, type CommandRun, type CommandRunAnswer } from './session/session.js'
+export type { Context } from './session/context/context.js'
+export type { Turn } from './session/context/turn/turn.js'
+export type { Message, MessageType } from './session/context/turn/message/message.js'
 export { Prompt } from './session/context/turn/message/prompt.js'
 export { Note } from './session/context/turn/message/note.js'
 export { Reply } from './session/context/turn/message/reply.js'
 export { ToolCall } from './session/context/turn/message/tool-call.js'
 export { ToolResult } from './session/context/turn/message/tool-result.js'
 export { Skill } from './session/context/turn/message/skill.js'
-export { Document } from './session/context/turn/message/document.js'
+export { InstructionFile } from './session/context/turn/message/instruction-file.js'
 export { Notice } from './session/context/turn/message/notice.js'
-export { Channel, Person, Schedule, Sdk, type Sender, type SenderType } from './session/context/turn/message/sender.js'
-export { GoalChange, type Goal } from './session/goal/goal.js'
-export { Task, TaskEnd, TaskStart } from './session/goal/task.js'
+export { Channel, Engine, Person, Schedule, Sdk, type Sender, type SenderType } from './session/context/turn/message/sender.js'
+export type { Goal } from './session/goal/goal.js'
+export { Task } from './session/goal/task.js'
 export { longestMs } from './runtime/deadline.js'
 export { notInstalled } from './runtime/dependencies.js'
 export { messageOf } from './utils/text.js'

package/src/records.ts

@@ -259,7 +259,7 @@ function readKeys(keys: unknown): Steps {
   return { keys: commands }
 }
 
-export const coreVersion = '1.6.0'
+export const coreVersion = '2.0.1'
 
 export function oldestCmodFor(steps: Steps): string {
   if (steps.permissions?.some((item) => item.startsWith('config:')) === true) return '1.6.0'

package/src/register.ts

@@ -5,10 +5,11 @@ import type { Claude } from './runtime/claude.js'
 import type { RoutedEvent } from './runtime/hooks.js'
 import { cmodPluginName } from './runtime/dependencies.js'
 import { createLifecycle, readPlugin, type Lifecycle } from './runtime/lifecycle.js'
+import { permissionRoutes, type PermissionRoutes } from './runtime/permission-check.js'
 
 let lifecycle: Lifecycle<object>
 
-let checksPermissions = false
+let permissionCheck: PermissionRoutes | undefined
 
 let registered: ModDefinition<object> | undefined
 
@@ -70,8 +71,9 @@ async function startMod($: EngineInterface, eventInput: Frozen<Args<'session.sta
       send: (args) => $.session.send(args),
     },
     prompt: { submit: (args) => $.prompt.submit(args) },
+    turn: { abort: (args) => $.turn.abort(args) },
     model: { complete: (request, options) => $.model.complete(request, options) },
-    command: { register: (command) => $.command.register(command) },
+    command: { register: (command) => $.command.register(command), list: () => $.command.list(), run: (args) => $.command.run(args) },
     tool: { register: (tool) => $.tool.register(tool), call: (input: ToolCallArgs) => $.tool.call(input) },
     agent: {
       list: () => $.agent.list(),
@@ -98,9 +100,9 @@ function routeCallToMod(_$: EngineInterface, eventInput: Frozen<Args<'cmod.call'
 }
 
 export function registerMod<State extends object, Declared extends Options>(addHook: On, definition: ModDefinition<State, string, Declared>, options: PluginOptions): void {
-  checksPermissions = false
+  permissionCheck = undefined
   registered = definition as ModDefinition<object>
-  lifecycle = createLifecycle(definition, () => checksPermissions, options)
+  lifecycle = createLifecycle(definition, () => permissionCheck, options)
   addHook('session.start', startMod)
   addHook('classic.Setup', routeToMod)
   addHook('classic.SessionStart', routeToMod)
@@ -149,10 +151,11 @@ export function registerMod<State extends object, Declared extends Options>(addH
   addHook('session.receive', routeToMod)
   addHook('agent.spawn', routeToMod)
   addHook('prompt.attachment', routeToMod)
+  addHook('turn.start', routeToMod)
 }
 
 export function registerPermissionCheck(addHook: On): void {
-  checksPermissions = true
+  permissionCheck = permissionRoutes
   addHook('tool.check', routeToMod)
   addHook('classic.PermissionRequest', routeToMod)
 }