@cmodjs/core 0.2.3 → 1.0.0

package/src/session/context/turn/message/notice.ts

@@ -0,0 +1,7 @@
+import type { MessageOf } from './message.js'
+
+export const Notice = 'notice'
+
+export type Notice = MessageOf<typeof Notice> & {
+  readonly text: string
+}

package/src/session/context/turn/message/prompt.ts

@@ -0,0 +1,9 @@
+import type { MessageOf } from './message.js'
+import type { Sender } from './sender.js'
+
+export const Prompt = 'prompt'
+
+export type Prompt = MessageOf<typeof Prompt> & {
+  readonly text: string
+  readonly from: Sender
+}

package/src/session/context/turn/message/reply.ts

@@ -0,0 +1,7 @@
+import type { MessageOf } from './message.js'
+
+export const Reply = 'reply'
+
+export type Reply = MessageOf<typeof Reply> & {
+  readonly text: string
+}

package/src/session/context/turn/message/sender.ts

@@ -0,0 +1,38 @@
+import { isObject } from '../../../../records.js'
+import { Task } from '../../../goal/task.js'
+
+export const Person = 'person'
+
+export const Mod = 'mod'
+
+export const Schedule = 'schedule'
+
+export const Channel = 'channel'
+
+export const Sdk = 'sdk'
+
+export type SenderType = typeof Person | typeof Mod | 'session' | typeof Task | typeof Schedule | typeof Channel | typeof Sdk
+
+export type Sender = {
+  readonly type: SenderType
+  readonly name?: string
+  readonly as?: typeof Person
+}
+
+const personOrigins: readonly string[] = ['human', 'composer', 'bridge', 'slack-ping', 'auto-continuation']
+
+const sessionOrigins: readonly string[] = ['peer', 'peer-send-message', 'coordinator', 'projects-relay', 'observer', 'observer-activity']
+
+export function senderOf(origin: unknown, isInTask: boolean): Sender {
+  const fields: Readonly<Record<string, unknown>> = isObject(origin) ? origin : {}
+  const kind = typeof fields['kind'] === 'string' ? fields['kind'] : undefined
+  if (kind === undefined) return { type: isInTask ? Task : Person }
+  if (personOrigins.includes(kind)) return { type: Person }
+  if (sessionOrigins.includes(kind)) return { type: 'session' }
+  if (kind === 'plugin' && typeof fields['name'] === 'string') return { type: Mod, name: fields['name'], ...(fields['asUser'] === true ? { as: Person } : {}) }
+  if (kind === 'scheduled-trigger') return { type: Schedule }
+  if (kind === 'channel' && typeof fields['server'] === 'string') return { type: Channel, name: fields['server'] }
+  if (kind === 'sdk') return { type: Sdk }
+  if (kind === 'task-notification') return { type: Task }
+  return { type: isInTask ? Task : Person }
+}

package/src/session/context/turn/message/skill.ts

@@ -0,0 +1,8 @@
+import type { MessageOf } from './message.js'
+
+export const Skill = 'skill'
+
+export type Skill = MessageOf<typeof Skill> & {
+  readonly name: string
+  readonly text: string
+}

package/src/session/context/turn/message/tool-call.ts

@@ -0,0 +1,10 @@
+import type { MessageOf } from './message.js'
+
+export const ToolCall = 'toolCall'
+
+export type ToolCall = MessageOf<typeof ToolCall> & {
+  readonly callId: string
+  readonly name: string
+  readonly input: Readonly<Record<string, unknown>>
+  readonly cwd: string
+}

package/src/session/context/turn/message/tool-result.ts

@@ -0,0 +1,9 @@
+import type { MessageOf } from './message.js'
+
+export const ToolResult = 'toolResult'
+
+export type ToolResult = MessageOf<typeof ToolResult> & {
+  readonly callId: string
+  readonly text: string
+  readonly isError: boolean
+}

package/src/session/context/turn/turn.ts

@@ -0,0 +1,14 @@
+import type { Message } from './message/message.js'
+import type { Prompt } from './message/prompt.js'
+
+export const TurnStart = 'turnStart'
+
+export const TurnEnd = 'turnEnd'
+
+export type Turn = {
+  readonly prompt: Prompt
+  readonly context: number
+  readonly openedAt: string
+  readonly closedAt?: string
+  messages(): Promise<Message[]>
+}

package/src/session/conversation.ts

@@ -0,0 +1,169 @@
+import { ContextEnd, ContextStart, type Context } from './context/context.js'
+import { Message, messagesOf, tagOf, textOf, type Row } from './context/turn/message/message.js'
+import { Note } from './context/turn/message/note.js'
+import { Prompt } from './context/turn/message/prompt.js'
+import { ToolCall } from './context/turn/message/tool-call.js'
+import { ToolResult } from './context/turn/message/tool-result.js'
+import { TurnEnd, TurnStart, type Turn } from './context/turn/turn.js'
+import { GoalChange, type Goal } from './goal/goal.js'
+import { Task, TaskEnd, TaskStart } from './goal/task.js'
+
+export type SessionData = {
+  readonly id: string
+  readonly title: string
+  readonly project: string
+  readonly cwd: string
+  readonly model: string
+  readonly startedAt: string
+  readonly lastAt: string
+  readonly forkedFrom?: string
+  readonly isRunning: boolean
+}
+
+export type ContextData = Omit<Context, 'turns'>
+
+export type TurnData = Omit<Turn, 'messages'>
+
+export type TaskData = Omit<Task, 'messages' | 'tasks'> & { readonly parent?: string }
+
+export type GoalData = Omit<Goal, 'update' | 'tasks'>
+
+export type SessionChange =
+  | { readonly type: typeof Message; readonly message: Message }
+  | { readonly type: typeof TurnStart | typeof TurnEnd; readonly turn: TurnData }
+  | { readonly type: typeof ContextStart | typeof ContextEnd; readonly context: ContextData }
+  | { readonly type: typeof TaskStart | typeof TaskEnd; readonly task: TaskData & { readonly context: number } }
+  | { readonly type: typeof GoalChange; readonly goal: GoalData }
+
+export type ConversationState = {
+  readonly session: string
+  readonly context: number
+  readonly contextOpenedAt: string
+  readonly turn?: TurnData
+  readonly goal?: string
+  readonly agentCalls: readonly string[]
+  readonly endedCalls: Readonly<Record<string, string>>
+  readonly tasks: Readonly<Record<string, TaskData & { readonly context: number }>>
+}
+
+export type Conversation = {
+  add(row: Row, task?: string): SessionChange[]
+  startTask(task: TaskData): SessionChange[]
+  endContext(at: string): SessionChange[]
+  startContext(at: string): SessionChange[]
+  changeGoal(text: string): SessionChange[]
+  readonly state: ConversationState
+}
+
+export const searchLimit = 50
+
+const agentTools: readonly string[] = ['Agent', 'Task']
+
+const asyncLaunch = 'Async agent launched'
+
+export function emptyConversation(session: string): ConversationState {
+  return { session, context: 0, contextOpenedAt: '', agentCalls: [], endedCalls: {}, tasks: {} }
+}
+
+export function createConversation(start: ConversationState): Conversation {
+  let { context, contextOpenedAt, turn, goal } = start
+  const agentCalls = new Set(start.agentCalls)
+  const endedCalls = new Map(Object.entries(start.endedCalls))
+  const tasks = new Map(Object.entries(start.tasks))
+
+  const startContext = (at: string): SessionChange[] => {
+    context += 1
+    contextOpenedAt = at
+    return [{ type: ContextStart, context: { number: context, openedAt: at } }]
+  }
+
+  const endContext = (at: string): SessionChange[] => (context === 0 ? [] : [{ type: ContextEnd, context: { number: context, openedAt: contextOpenedAt, closedAt: at } }])
+
+  const endTurn = (at: string): SessionChange[] => {
+    if (turn === undefined) return []
+    const ended = { ...turn, closedAt: at }
+    turn = undefined
+    return [{ type: TurnEnd, turn: ended }]
+  }
+
+  const endTask = (call: string, at: string): SessionChange[] => {
+    const task = [...tasks.values()].find((each) => each.openedBy === call)
+    if (task === undefined) {
+      if (agentCalls.has(call)) endedCalls.set(call, at)
+      return []
+    }
+    if (task.closedAt !== undefined) return []
+    const ended = { ...task, closedAt: at }
+    tasks.set(task.id, ended)
+    agentCalls.delete(call)
+    return [{ type: TaskEnd, task: ended }]
+  }
+
+  const changeGoal = (text: string): SessionChange[] => {
+    goal = text
+    return [{ type: GoalChange, goal: { text } }]
+  }
+
+  return {
+    add(row, task) {
+      const changes: SessionChange[] = []
+      if (task === undefined && context === 0) changes.push(...startContext(row.at))
+      if (task === undefined && row.type === 'system' && row.name === 'turn_duration') return [...changes, ...endTurn(row.at)]
+      if (task === undefined && row.type === 'system' && row.name === 'compact_boundary') return [...changes, ...endContext(row.at), ...startContext(row.at)]
+      const owner = task === undefined ? undefined : tasks.get(task)
+      for (const unplaced of messagesOf(row, task !== undefined)) {
+        if (task === undefined && unplaced.type === Prompt) {
+          changes.push(...endTurn(row.at))
+          const opened: TurnData = { prompt: { ...unplaced, session: start.session, context, turn: unplaced.id }, context, openedAt: row.at }
+          turn = opened
+          changes.push({ type: TurnStart, turn: opened })
+          if (goal === undefined) changes.push(...changeGoal(unplaced.text))
+        }
+        const placed = {
+          ...unplaced,
+          session: start.session,
+          context: owner?.context ?? context,
+          ...(task === undefined && turn !== undefined ? { turn: turn.prompt.id } : {}),
+          ...(task === undefined ? {} : { task }),
+        } as Message
+        changes.push({ type: Message, message: placed })
+        if (task !== undefined) continue
+        if (placed.type === ToolCall && agentTools.includes(placed.name)) agentCalls.add(placed.callId)
+        if (placed.type === ToolResult && agentCalls.has(placed.callId) && !placed.text.startsWith(asyncLaunch)) changes.push(...endTask(placed.callId, row.at))
+        if (placed.type === Note && placed.from.type === Task) {
+          const call = tagOf(textOf(row.content), 'tool-use-id')
+          if (call !== undefined && agentCalls.has(call)) changes.push(...endTask(call, row.at))
+        }
+      }
+      return changes
+    },
+    startTask(data) {
+      if (tasks.has(data.id)) return []
+      const started = { ...data, context }
+      tasks.set(data.id, started)
+      agentCalls.add(data.openedBy)
+      const changes: SessionChange[] = [{ type: TaskStart, task: started }]
+      const endedAt = endedCalls.get(data.openedBy)
+      if (endedAt !== undefined) {
+        endedCalls.delete(data.openedBy)
+        changes.push(...endTask(data.openedBy, endedAt))
+      }
+      return changes
+    },
+    endContext,
+    startContext,
+    changeGoal,
+    get state() {
+      return {
+        session: start.session,
+        context,
+        contextOpenedAt,
+        ...(turn === undefined ? {} : { turn }),
+        ...(goal === undefined ? {} : { goal }),
+        agentCalls: [...agentCalls],
+        endedCalls: Object.fromEntries(endedCalls),
+        tasks: Object.fromEntries(tasks),
+      }
+    },
+  }
+}

package/src/session/goal/goal.ts

@@ -0,0 +1,9 @@
+import type { Task } from './task.js'
+
+export const GoalChange = 'goalChange'
+
+export type Goal = {
+  readonly text: string
+  update(change: { readonly text: string }): Promise<void>
+  tasks(): Promise<Task[]>
+}

package/src/session/goal/task.ts

@@ -0,0 +1,19 @@
+import type { Message } from '../context/turn/message/message.js'
+
+export const Task = 'task'
+
+export const TaskStart = 'taskStart'
+
+export const TaskEnd = 'taskEnd'
+
+export type Task = {
+  readonly id: string
+  readonly title: string
+  readonly agentType: string
+  readonly model?: string
+  readonly openedBy: string
+  readonly openedAt: string
+  readonly closedAt?: string
+  messages(): Promise<Message[]>
+  tasks(): Promise<Task[]>
+}

package/src/session/session.ts

@@ -0,0 +1,94 @@
+import type { Disposable } from '../mod.js'
+import type { Matcher } from '../utils/matcher.js'
+import type { Context, ContextEnd, ContextStart } from './context/context.js'
+import type { Document } from './context/turn/message/document.js'
+import type { Message, MessageType } from './context/turn/message/message.js'
+import type { Note } from './context/turn/message/note.js'
+import type { Notice } from './context/turn/message/notice.js'
+import type { Prompt } from './context/turn/message/prompt.js'
+import type { Reply } from './context/turn/message/reply.js'
+import type { Person } from './context/turn/message/sender.js'
+import type { Skill } from './context/turn/message/skill.js'
+import type { ToolCall } from './context/turn/message/tool-call.js'
+import type { ToolResult } from './context/turn/message/tool-result.js'
+import type { Turn, TurnEnd, TurnStart } from './context/turn/turn.js'
+import type { Goal, GoalChange } from './goal/goal.js'
+import type { Task, TaskEnd, TaskStart } from './goal/task.js'
+
+export const Session = 'session'
+
+export type SessionEvent = typeof Message | MessageType | typeof ContextStart | typeof ContextEnd | typeof TurnStart | typeof TurnEnd | typeof TaskStart | typeof TaskEnd | typeof GoalChange
+
+export type SessionPayload = {
+  readonly message: Message
+  readonly prompt: Prompt
+  readonly note: Note
+  readonly reply: Reply
+  readonly toolCall: ToolCall
+  readonly toolResult: ToolResult
+  readonly skill: Skill
+  readonly document: Document
+  readonly notice: Notice
+  readonly contextStart: Context
+  readonly contextEnd: Context
+  readonly turnStart: Turn
+  readonly turnEnd: Turn
+  readonly taskStart: Task
+  readonly taskEnd: Task
+  readonly goalChange: Goal
+}
+
+export type Usage = {
+  readonly model: string
+  readonly context: { readonly tokens?: number; readonly window: number; readonly percent?: number }
+  readonly cost?: { readonly usd: number }
+}
+
+export type Listener<Event extends SessionEvent> = (payload: SessionPayload[Event]) => unknown
+
+export type SessionSend = {
+  readonly type: typeof Prompt | typeof Note
+  readonly text: string
+  readonly as?: typeof Person | typeof Session
+}
+
+export type TaskStartArgs = {
+  readonly prompt: string
+  readonly agentType?: string
+  readonly model?: string
+  readonly name?: string
+  readonly cwd?: string
+}
+
+export type Session = {
+  readonly id: string
+  readonly title: string
+  readonly project: string
+  readonly cwd: string
+  readonly model: string
+  readonly startedAt: string
+  readonly lastAt: string
+  readonly forkedFrom?: string
+  readonly isRunning: boolean
+  usage(): Promise<Usage>
+  on<Event extends SessionEvent>(event: Event, listener: Listener<Event>): Disposable
+  on<Event extends SessionEvent>(event: Event, matcher: Matcher<SessionPayload[Event]>, listener: Listener<Event>): Disposable
+  send(message: SessionSend): Promise<void>
+  startTask(task: TaskStartArgs): Promise<Task>
+  messages(options?: { readonly after?: string; readonly last?: number }): Promise<Message[]>
+  turns(options?: { readonly last?: number }): Promise<Turn[]>
+  contexts(): Promise<Context[]>
+  goal(): Promise<Goal>
+}
+
+export type SessionScope = {
+  readonly running?: boolean
+  readonly since?: string
+  readonly everyProject?: boolean
+}
+
+export type Sessions = {
+  readonly current: Session
+  list(options?: SessionScope): Promise<Session[]>
+  search(text: string, options?: SessionScope & { readonly limit?: number; readonly before?: Pick<Message, 'session' | 'id'> }): Promise<Message[]>
+}

package/src/testing/fake-claude.ts

@@ -1,6 +1,8 @@
-import type { Timer } from 'claude-code'
+import type { EventResult, Timer } from 'claude-code'
+import { isObject } from '../records.js'
 import type { Claude } from '../runtime/claude.js'
 import { elements } from './fake-elements.js'
+import { fakeFiles } from './fake-files.js'
 
 export type TestCall = {
   readonly call: string
@@ -12,9 +14,9 @@ export type Fakes = {
   fs: { read?: Claude['fs']['read']; write?: Claude['fs']['write']; list?: Claude['fs']['list']; exists?: Claude['fs']['exists']; stat?: Claude['fs']['stat'] }
   http: { fetch?: Claude['http']['fetch'] }
   settings: { read?: Claude['settings']['read'] }
-  config: { list?: Claude['config']['list']; set?: Claude['config']['set'] }
-  ui: { ask?: Claude['ui']['ask']; open?: Claude['ui']['open']; scroll?: Claude['ui']['scroll'] }
-  session: { messages?: Claude['session']['messages']; append?: Claude['session']['append'] }
+  config: { list?: Claude['config']['list'] }
+  ui: { ask?: Claude['ui']['ask']; open?: Claude['ui']['open']; scroll?: Claude['ui']['scroll']; copy?: Claude['ui']['copy'] }
+  session: { messages?: Claude['session']['messages']; append?: Claude['session']['append']; send?: Claude['session']['send'] }
   prompt: { submit?: Claude['prompt']['submit'] }
   model: { complete?: Claude['model']['complete'] }
   agent: { list?: Claude['agent']['list']; spawn?: Claude['agent']['spawn'] }
@@ -26,7 +28,6 @@ export type Fakes = {
 export type ShownSchedule = { readonly id: string; readonly cron: string; readonly prompt: string }
 
 export type Shown = {
-  readonly toasts: string[]
   readonly notes: string[]
   readonly prompts: string[]
   readonly logs: string[]
@@ -47,10 +48,16 @@ export type FakeClaude = {
   settle(): Promise<void>
 }
 
+export function calledAnswer(caller: string, answer: EventResult<'cmod.call'>): unknown {
+  if (isObject(answer) && typeof answer['deny'] === 'string') throw new Error(`${caller}: $.cmod.call: ${answer['deny']}`)
+  return isObject(answer) ? answer['value'] : undefined
+}
+
 export function fakeClaude(plugin: { readonly name: string; readonly root: string }): FakeClaude {
   const calls: TestCall[] = []
   const fakes: Fakes = { process: {}, fs: {}, http: {}, settings: {}, config: {}, ui: {}, session: {}, prompt: {}, model: {}, agent: {}, clock: {}, cmod: {}, tool: {} }
-  const shown: Shown = { toasts: [], notes: [], prompts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
+  const emptyDisk = fakeFiles({})
+  const shown: Shown = { notes: [], prompts: [], logs: [], debug: [], statuses: [], openPanes: new Set(), commands: [], tools: [], schedules: [] }
   const unplacedPanes = new Set<string>()
   let focusedPane: string | undefined
   const store = new Map<string, unknown>()
@@ -72,7 +79,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
 
   const appendNote: Claude['session']['append'] = async ({ message }) => {
     shown.notes.push(message.content.map((block) => (typeof block['text'] === 'string' ? block['text'] : '')).join(''))
-    return { message, uuid: `note-${shown.notes.length}` } as unknown as Awaited<ReturnType<Claude['session']['append']>>
+    return { message, uuid: `note-${shown.notes.length}` }
   }
   const submitPrompt: Claude['prompt']['submit'] = async ({ text }) => {
     shown.prompts.push(text)
@@ -98,9 +105,6 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
   const claude: Claude = {
     plugin,
     ui: {
-      toast: (text) => {
-        shown.toasts.push(text)
-      },
       status: (text) => {
         shown.statuses.push(text)
       },
@@ -134,6 +138,7 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
         ...[...unplacedPanes].map((id) => ({ id, title: id, isShown: false, isFocused: false, isPlaced: false })),
       ],
       scroll: rejected('ui.scroll', () => fakes.ui.scroll ?? (async () => ({}))),
+      copy: rejected('ui.copy', () => fakes.ui.copy ?? (async () => ({ isCopied: true as const }))),
       resolve: () => elements,
     },
     process: {
@@ -141,17 +146,16 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       spawn: faked('process.spawn', () => fakes.process.spawn),
     },
     fs: {
-      read: rejected('fs.read', () => fakes.fs.read),
-      write: rejected('fs.write', () => fakes.fs.write),
-      list: rejected('fs.list', () => fakes.fs.list),
-      exists: rejected('fs.exists', () => fakes.fs.exists ?? (async () => false)),
-      stat: rejected('fs.stat', () => fakes.fs.stat),
+      read: rejected('fs.read', () => fakes.fs.read ?? emptyDisk.read),
+      write: rejected('fs.write', () => fakes.fs.write ?? emptyDisk.write),
+      list: rejected('fs.list', () => fakes.fs.list ?? emptyDisk.list),
+      exists: rejected('fs.exists', () => fakes.fs.exists ?? emptyDisk.exists),
+      stat: rejected('fs.stat', () => fakes.fs.stat ?? emptyDisk.stat),
     },
     http: { fetch: rejected('http.fetch', () => fakes.http.fetch) },
-    settings: { read: rejected('settings.read', () => fakes.settings.read) },
+    settings: { read: rejected('settings.read', () => fakes.settings.read ?? (async () => ({}))) },
     config: {
       list: rejected('config.list', () => fakes.config.list ?? (async () => [])),
-      set: rejected('config.set', () => fakes.config.set ?? (async ({ value }) => ({ value }))) as Claude['config']['set'],
     },
     agent: {
       list: rejected('agent.list', () => fakes.agent.list),
@@ -177,10 +181,11 @@ export function fakeClaude(plugin: { readonly name: string; readonly root: strin
       root: async () => plugin.root,
       cwd: async () => plugin.root,
       model: async () => 'test-model',
-      usage: async () => ({ context: { window: 200000 }, rateLimits: {}, cost: { usd: 0 } }) as unknown as Awaited<ReturnType<Claude['session']['usage']>>,
+      usage: async () => ({ startedAt: Date.parse('2026-01-01T00:00:00.000Z'), context: { window: 200000 }, rateLimits: [], cost: { usd: 0 } }),
       surfaces: async () => ['terminal'],
       messages: rejected('session.messages', () => fakes.session.messages as ((args?: unknown) => Promise<unknown>) | undefined) as Claude['session']['messages'],
       append: rejected('session.append', () => fakes.session.append ?? appendNote),
+      send: rejected('session.send', () => fakes.session.send ?? (async () => ({ isDelivered: true as const }))),
     },
     prompt: { submit: rejected('prompt.submit', () => fakes.prompt.submit ?? submitPrompt) },
     model: { complete: rejected('model.complete', () => fakes.model.complete) },

package/src/testing/fake-elements.ts

@@ -116,8 +116,9 @@ function sideBySide(children: readonly RenderNode[], width: number, gap: number)
 
 function minWidthOf(node: RenderNode): number {
   if (typeof node === 'string') return 0
-  const minWidth = insideOf(node).props['minWidth']
-  return typeof minWidth === 'number' ? minWidth : 0
+  const { props } = insideOf(node)
+  if (props['flexShrink'] === 0) return Number.POSITIVE_INFINITY
+  return typeof props['minWidth'] === 'number' ? props['minWidth'] : 0
 }
 
 function blankRows(count: number): string[] {

package/src/testing/fake-files.ts

@@ -36,7 +36,7 @@ export function fakeFiles(files: Readonly<Record<string, string>>, links: Readon
       modified.set(realPath, writes)
     },
     list: async (path) => {
-      if (path === undefined) throw new Error('fs.list() lists the working folder, which the fake files do not know. Name the folder, such as fs.list(mod.cwd).')
+      if (path === undefined) throw new Error('fs.list() lists the working folder, which the fake files do not know. Name the folder, such as fs.list(sessions.current.cwd).')
       const folder = realPathOf(path)
       if (kindOf(folder) !== 'dir') throw new Error(`ENOENT: no such directory, list '${path}'`)
       const names = new Set(below(folder).map((file) => file.split('/')[0] as string))