@cmodjs/core 0.3.0 → 1.5.0

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

@@ -0,0 +1,203 @@
+import { isObject } from '../../../../records.js'
+import { Task } from '../../../goal/task.js'
+import { Document } from './document.js'
+import { Note } from './note.js'
+import { Notice } from './notice.js'
+import { Prompt } from './prompt.js'
+import { Reply } from './reply.js'
+import { senderOf } from './sender.js'
+import { Skill } from './skill.js'
+import { ToolCall } from './tool-call.js'
+import { ToolResult } from './tool-result.js'
+
+export const Message = 'message'
+
+export type MessageType = typeof Prompt | typeof Note | typeof Reply | typeof ToolCall | typeof ToolResult | typeof Skill | typeof Document | typeof Notice
+
+export type MessageOf<Type extends MessageType> = {
+  readonly id: string
+  readonly type: Type
+  readonly at: string
+  readonly session: string
+  readonly context: number
+  readonly turn?: string
+  readonly task?: string
+}
+
+export type Message = Prompt | Note | Reply | ToolCall | ToolResult | Skill | Document | Notice
+
+export type Placed = 'session' | 'context' | 'turn' | 'task'
+
+export type Unplaced<M extends Message = Message> = M extends Message ? Omit<M, Placed> : never
+
+export type Row = {
+  readonly id: string
+  readonly at: string
+  readonly type: 'user' | 'assistant' | 'attachment' | 'system'
+  readonly name?: string
+  readonly isMeta: boolean
+  readonly isSummary: boolean
+  readonly content: readonly unknown[]
+  readonly origin?: unknown
+  readonly cwd?: string
+  readonly path?: string
+  readonly model?: string
+}
+
+export const messageTypes: readonly MessageType[] = [Prompt, Note, Reply, ToolCall, ToolResult, Skill, Document, Notice]
+
+export const skillPrefix = 'Base directory for this skill:'
+
+const rowTypes: readonly string[] = ['user', 'assistant', 'attachment', 'system']
+
+const memoryPath = /^Contents of (.+?) \(/
+
+export function rowOfLine(row: Readonly<Record<string, unknown>>): Row | undefined {
+  const { uuid, timestamp, type } = row
+  if (typeof uuid !== 'string' || typeof timestamp !== 'string' || typeof type !== 'string' || !rowTypes.includes(type)) return undefined
+  const message = isObject(row['message']) ? row['message'] : {}
+  const attachment = isObject(row['attachment']) ? row['attachment'] : {}
+  const content = type === 'attachment' ? attachment['content'] : type === 'system' ? row['content'] : message['content']
+  const name = type === 'attachment' ? attachment['type'] : row['subtype']
+  return {
+    id: uuid,
+    at: timestamp,
+    type: type as Row['type'],
+    ...(typeof name === 'string' ? { name } : {}),
+    isMeta: row['isMeta'] === true,
+    isSummary: row['isCompactSummary'] === true,
+    content: blocksOf(content),
+    ...(row['origin'] === undefined ? {} : { origin: row['origin'] }),
+    ...(typeof row['cwd'] === 'string' ? { cwd: row['cwd'] } : {}),
+    ...(typeof attachment['path'] === 'string' ? { path: attachment['path'] } : {}),
+    ...(typeof message['model'] === 'string' ? { model: message['model'] } : {}),
+  }
+}
+
+export function rowOfAppend(append: { readonly uuid: string; readonly door: string; readonly origin: unknown; readonly message: { readonly type: Row['type']; readonly name?: string; readonly isMeta?: true; readonly content: readonly unknown[] } }, at: string, cwd: string): Row {
+  const { message, origin } = append
+  const text = textOf(message.content)
+  const path = message.type === 'attachment' ? memoryPath.exec(text)?.[1] : undefined
+  const model = isObject(origin) && origin['kind'] === 'model' && typeof origin['model'] === 'string' ? origin['model'] : undefined
+  return {
+    id: append.uuid,
+    at,
+    type: message.type,
+    ...(message.name === undefined ? {} : { name: message.name }),
+    isMeta: message.isMeta === true,
+    isSummary: append.door === 'compaction',
+    content: message.content,
+    origin,
+    cwd,
+    ...(path === undefined ? {} : { path }),
+    ...(model === undefined ? {} : { model }),
+  }
+}
+
+export function messagesOf(row: Row, isInTask: boolean): Unplaced[] {
+  const found = unplacedOf(row, isInTask)
+  return found.length === 1 ? found : found.map((message, index) => ({ ...message, id: `${row.id}:${index}` }))
+}
+
+function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
+  const base = { id: row.id, at: row.at }
+  const text = textOf(row.content).trim()
+  if (row.type === 'system') return row.name === 'turn_duration' || row.name === 'compact_boundary' || text === '' ? [] : [{ ...base, type: Notice, text }]
+  if (row.type === 'attachment') return row.name === 'nested_memory' ? [{ ...base, type: Document, path: row.path ?? '', text }] : []
+  if (row.type === 'assistant') {
+    return row.content.filter(isObject).flatMap((block): Unplaced[] => {
+      if (block['type'] === 'text' && typeof block['text'] === 'string' && block['text'].trim() !== '') return [{ ...base, type: Reply, text: block['text'].trim() }]
+      if (block['type'] !== 'tool_use' || typeof block['id'] !== 'string' || typeof block['name'] !== 'string') return []
+      return [{ ...base, type: ToolCall, callId: block['id'], name: block['name'], input: isObject(block['input']) ? block['input'] : {}, cwd: row.cwd ?? '' }]
+    })
+  }
+  if (row.isSummary) return []
+  const results = row.content.filter(isToolResultBlock)
+  if (results.length > 0) return results.map((block) => ({ ...base, type: ToolResult, callId: block['tool_use_id'] as string, text: textOf(block['content']), isError: block['is_error'] === true }))
+  if (text === '') return []
+  if (text.startsWith(skillPrefix)) return [{ ...base, type: Skill, name: basename(text.slice(skillPrefix.length).split('\n')[0]?.trim() ?? ''), text }]
+  if (text.startsWith('<task-notification')) return [{ ...base, type: Note, text: tagOf(text, 'summary') ?? text, from: { type: Task } }]
+  if (row.isMeta) return [{ ...base, type: Note, text, from: senderOf(row.origin, isInTask) }]
+  const prompt = promptText(text)
+  return prompt === undefined ? [] : [{ ...base, type: Prompt, text: prompt, from: senderOf(row.origin, isInTask) }]
+}
+
+export function withTexts(row: Row, texts: ReadonlyMap<number, string>): readonly unknown[] {
+  if (row.type === 'assistant') {
+    let index = -1
+    return row.content.map((block) => {
+      if (!isObject(block)) return block
+      const isText = block['type'] === 'text' && typeof block['text'] === 'string' && block['text'].trim() !== ''
+      const isCall = block['type'] === 'tool_use' && typeof block['id'] === 'string' && typeof block['name'] === 'string'
+      if (!isText && !isCall) return block
+      index += 1
+      const text = texts.get(index)
+      return isText && text !== undefined ? { ...block, text } : block
+    })
+  }
+  if (row.type === 'user' && row.content.some(isToolResultBlock)) {
+    let index = -1
+    return row.content.map((block) => {
+      if (!isToolResultBlock(block)) return block
+      index += 1
+      const text = texts.get(index)
+      if (text === undefined) return block
+      return { ...block, content: Array.isArray(block['content']) ? keepingMedia(block['content'], text) : text }
+    })
+  }
+  const text = texts.get(0)
+  if (text === undefined) return row.content
+  const whole = textOf(row.content)
+  if (whole.trim().startsWith('<task-notification') && tagOf(whole, 'summary') !== undefined) return keepingMedia(row.content, whole.replace(/<summary>[\s\S]*?<\/summary>/, () => `<summary>${text}</summary>`))
+  return keepingMedia(row.content, text)
+}
+
+function keepingMedia(content: readonly unknown[], text: string): unknown[] {
+  return [{ type: 'text', text }, ...content.filter((block) => !isObject(block) || block['type'] !== 'text')]
+}
+
+function isToolResultBlock(block: unknown): block is Readonly<Record<string, unknown>> {
+  return isObject(block) && block['type'] === 'tool_result' && typeof block['tool_use_id'] === 'string'
+}
+
+export function textOf(content: unknown): string {
+  if (typeof content === 'string') return content
+  if (!Array.isArray(content)) return ''
+  return content.flatMap((block) => (isObject(block) && block['type'] === 'text' && typeof block['text'] === 'string' ? [block['text']] : [])).join('\n')
+}
+
+export function tagOf(text: string, tag: string): string | undefined {
+  return new RegExp(`<${tag}>([\\s\\S]*?)</${tag}>`).exec(text)?.[1]?.trim()
+}
+
+const toolValueChars = 1024
+
+export function searchText(message: Unplaced): string {
+  if (message.type === ToolCall) return [message.name, ...stringsIn(message.input).map((value) => value.slice(0, toolValueChars))].join('\n')
+  if (message.type === ToolResult) return ''
+  if (message.type === Document) return `${message.path}\n${message.text}`
+  return message.text
+}
+
+function blocksOf(content: unknown): readonly unknown[] {
+  if (Array.isArray(content)) return content
+  return typeof content === 'string' && content !== '' ? [{ type: 'text', text: content }] : []
+}
+
+function promptText(text: string): string | undefined {
+  if (text.startsWith('<local-command-') || text.startsWith('<bash-stdout') || text.startsWith('<bash-stderr')) return undefined
+  const command = tagOf(text, 'command-name')
+  if (command === undefined) return text
+  const args = tagOf(text, 'command-args') ?? ''
+  return args === '' ? command : `${command} ${args}`
+}
+
+function basename(path: string): string {
+  return path.slice(path.lastIndexOf('/') + 1)
+}
+
+function stringsIn(value: unknown): string[] {
+  if (typeof value === 'string') return [value]
+  if (Array.isArray(value)) return value.flatMap(stringsIn)
+  return isObject(value) ? Object.values(value).flatMap(stringsIn) : []
+}

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

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

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,15 @@
+import type { RecordPart } from '../../session.js'
+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 = RecordPart & {
+  readonly prompt: Prompt
+  readonly context: number
+  readonly openedAt: string
+  readonly closedAt?: string
+  messages(): Promise<Message[]>
+}

package/src/session/conversation.ts

@@ -0,0 +1,194 @@
+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'
+import type { UsageChange, Usage } from './session.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
+  readonly agentType?: string
+}
+
+export type ContextData = Pick<Context, 'number' | 'openedAt' | 'closedAt' | 'task'>
+
+export type TurnData = Pick<Turn, 'prompt' | 'context' | 'openedAt' | 'closedAt'>
+
+export type TaskData = Pick<Task, 'id' | 'title' | 'openedBy' | 'openedAt' | 'closedAt'> & { readonly agentType: string; readonly model?: string; readonly parent?: string }
+
+export type RunningTask = TaskData & { readonly context: number; readonly contextOpenedAt?: string }
+
+export type GoalData = Pick<Goal, 'text'> & { readonly task?: string }
+
+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: RunningTask }
+  | { readonly type: typeof GoalChange; readonly goal: GoalData }
+  | { readonly type: typeof UsageChange; readonly usage: Usage }
+
+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, RunningTask>>
+  readonly taskTurns: Readonly<Record<string, TurnData>>
+}
+
+export type Conversation = {
+  add(row: Row, task?: string): SessionChange[]
+  startTask(task: TaskData): 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: {}, taskTurns: {} }
+}
+
+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 taskTurns = new Map(Object.entries(start.taskTurns))
+
+  const endTaskTurn = (task: string, at: string): SessionChange[] => {
+    const open = taskTurns.get(task)
+    if (open === undefined) return []
+    taskTurns.delete(task)
+    return open.closedAt === undefined ? [{ type: TurnEnd, turn: { ...open, closedAt: at } }] : []
+  }
+
+  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 compactTask = (task: string, at: string): SessionChange[] => {
+    const owner = tasks.get(task)
+    if (owner === undefined) return []
+    const next = { ...owner, context: owner.context + 1, contextOpenedAt: at }
+    tasks.set(task, next)
+    return [
+      { type: ContextEnd, context: { number: owner.context, openedAt: owner.contextOpenedAt ?? owner.openedAt, closedAt: at, task } },
+      { type: ContextStart, context: { number: next.context, openedAt: at, task } },
+    ]
+  }
+
+  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, only?: string): SessionChange[] => {
+    const opened = [...tasks.values()].filter((each) => each.openedBy === call && (only === undefined || each.id === only))
+    if (opened.length === 0) {
+      if (agentCalls.has(call)) endedCalls.set(call, at)
+      return []
+    }
+    if (only === undefined) agentCalls.delete(call)
+    return opened.flatMap((task) => {
+      if (task.closedAt !== undefined) return []
+      const ended = { ...task, closedAt: at }
+      tasks.set(task.id, ended)
+      return [...endTaskTurn(task.id, at), { 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 (row.type === 'system' && row.name === 'compact_boundary') return [...changes, ...(task === undefined ? [...endContext(row.at), ...startContext(row.at)] : compactTask(task, row.at))]
+      const owner = task === undefined ? undefined : tasks.get(task)
+      const placedIn = owner?.context ?? context
+      for (const unplaced of messagesOf(row, task !== undefined)) {
+        if (unplaced.type === Prompt) {
+          changes.push(...(task === undefined ? endTurn(row.at) : endTaskTurn(task, row.at)))
+          const opened: TurnData = { prompt: { ...unplaced, session: start.session, context: placedIn, turn: unplaced.id, ...(task === undefined ? {} : { task }) }, context: placedIn, openedAt: row.at, ...(owner?.closedAt === undefined ? {} : { closedAt: owner.closedAt }) }
+          if (task === undefined) turn = opened
+          else taskTurns.set(task, opened)
+          changes.push({ type: TurnStart, turn: opened })
+          if (task === undefined && goal === undefined) changes.push(...changeGoal(unplaced.text))
+        }
+        const open = task === undefined ? turn : taskTurns.get(task)
+        const placed = {
+          ...unplaced,
+          session: start.session,
+          context: placedIn,
+          ...(open === undefined ? {} : { turn: open.prompt.id }),
+          ...(task === undefined ? {} : { task }),
+        } as Message
+        changes.push({ type: Message, message: placed })
+        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, tagOf(textOf(row.content), 'task-id')))
+        }
+      }
+      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) changes.push(...endTask(data.openedBy, endedAt, data.id))
+      return changes
+    },
+    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),
+        taskTurns: Object.fromEntries(taskTurns),
+      }
+    },
+  }
+}

package/src/session/goal/goal.ts

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

package/src/session/goal/task.ts

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