@cmodjs/core 0.2.3 → 1.0.0

package/src/runtime/toaster.ts

@@ -0,0 +1,218 @@
+import type { ElementTable, RenderElement, RenderPropsOf, Timer } from 'claude-code'
+import type { Mod, Toast, ToastId, ToastOptions, ToastType } from '../mod.js'
+import { Box, Button, drawWith, Text } from '../ui/elements.js'
+import { coreVersion } from '../records.js'
+import { firstLine, messageOf } from '../utils/text.js'
+import type { Claude } from './claude.js'
+
+export type ShownToast = { readonly type: ToastType; readonly message: string; readonly description?: string }
+
+export type Failure = { readonly id: string; readonly message: string; readonly error?: unknown; readonly description?: string }
+
+export type Toaster = {
+  readonly toast: Toast
+  copy(text: string): Promise<void>
+  readonly shown: readonly ShownToast[]
+  draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt']): RenderElement
+}
+
+type Entry = {
+  readonly id: ToastId
+  readonly type: ToastType
+  readonly message: string
+  readonly options: ToastOptions
+  isOpen: boolean
+  timer: Timer | undefined
+}
+
+const defaultDuration = 4000
+const visibleToasts = 3
+const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] as const
+const spinnerMs = 100
+const icons: Record<Exclude<ToastType, 'loading'>, { readonly glyph: string; readonly color?: string }> = {
+  default: { glyph: ' ' },
+  success: { glyph: '✓', color: 'success' },
+  info: { glyph: 'ℹ', color: 'suggestion' },
+  warning: { glyph: '⚠', color: 'warning' },
+  error: { glyph: '✗', color: 'error' },
+}
+
+export function createToaster(claude: Claude, name: string): Toaster {
+  const entries = new Map<ToastId, Entry>()
+  let lastId = 0
+  let frame = 0
+  let spinning: Timer | undefined
+  let isHeld = false
+  let showsAll = false
+
+  const changed = () => {
+    const isLoading = [...entries.values()].some((entry) => entry.type === 'loading')
+    if (isLoading && spinning === undefined) {
+      spinning = claude.clock.every(spinnerMs, () => {
+        frame += 1
+        claude.ui.invalidate('ui.render')
+      })
+    }
+    if (!isLoading && spinning !== undefined) {
+      spinning.cancel()
+      spinning = undefined
+    }
+    if (entries.size <= visibleToasts) showsAll = false
+    claude.ui.invalidate('ui.render')
+  }
+
+  const disarm = (entry: Entry) => {
+    entry.timer?.cancel()
+    entry.timer = undefined
+  }
+
+  const arm = (entry: Entry) => {
+    const duration = entry.options.duration ?? defaultDuration
+    if (entry.timer !== undefined || entry.type === 'loading' || entry.isOpen || !Number.isFinite(duration)) return
+    entry.timer = claude.clock.after(duration, () => {
+      entry.timer = undefined
+      if (isHeld) arm(entry)
+      else dismiss(entry.id)
+    })
+  }
+
+  const dismiss = (id?: ToastId) => {
+    for (const entry of entries.values()) {
+      if (id !== undefined && entry.id !== id) continue
+      disarm(entry)
+      entries.delete(entry.id)
+    }
+    changed()
+  }
+
+  const show =
+    (type: ToastType) =>
+    (message: string, options: ToastOptions = {}): ToastId => {
+      const id = options.id ?? (lastId += 1)
+      const previous = entries.get(id)
+      if (previous !== undefined) disarm(previous)
+      const entry: Entry = { id, type, message, options, isOpen: previous?.isOpen ?? false, timer: undefined }
+      if (type === 'error' && previous?.message !== message) claude.ui.log(`${name}: ${message}${typeof options.description === 'string' ? `: ${options.description}` : ''}`, { to: 'debug' })
+      entries.set(id, entry)
+      changed()
+      return id
+    }
+
+  const toast: Toast = Object.assign(show('default'), {
+    success: show('success'),
+    info: show('info'),
+    warning: show('warning'),
+    error: show('error'),
+    loading: show('loading'),
+    dismiss,
+    promise<T>(task: Promise<T> | (() => Promise<T>), messages: Parameters<Toast['promise']>[1]) {
+      const id = show('loading')(messages.loading)
+      const settled = Promise.resolve()
+        .then(() => (typeof task === 'function' ? task() : task))
+        .then(
+          (value) => {
+            show('success')(typeof messages.success === 'function' ? messages.success(value) : messages.success, { id })
+            return value
+          },
+          (error: unknown) => {
+            show('error')(typeof messages.error === 'function' ? messages.error(error) : messages.error, { id })
+            throw error
+          },
+        )
+      settled.catch(() => undefined)
+      return { unwrap: () => settled }
+    },
+  })
+
+  const copy = async (text: string) => {
+    const copied = await claude.ui.copy({ text })
+    if (!copied.isCopied) throw new Error(copied.reason)
+  }
+
+  const press = (entry: Entry, run: () => unknown) => () =>
+    void Promise.resolve()
+      .then(run)
+      .catch((error: unknown) => showFailure({ name, claude, ui: { toast, copy } }, { id: `press:${entry.id}`, message: `${entry.message}: the press failed`, error }))
+
+  const toggle = (entry: Entry) => () => {
+    entry.isOpen = !entry.isOpen
+    disarm(entry)
+    changed()
+  }
+
+  const row = (entry: Entry): RenderElement => {
+    const { description, action } = entry.options
+    const isText = typeof description === 'string'
+    const icon = entry.type === 'loading' ? { glyph: spinner[frame % spinner.length] as string, color: 'claude' } : icons[entry.type]
+    const message = isText ? Button({ plain: true, key: `toast:${entry.id}:open`, label: entry.message, onPress: toggle(entry) }) : Text({ children: entry.message })
+    const details = !isText ? description : Text({ dimColor: true, wrap: entry.isOpen ? 'wrap' : 'truncate-end', children: entry.isOpen ? description : firstLine(description) })
+    const fixed = (child: RenderElement) => Box({ flexShrink: 0, children: child })
+    return Box({
+      gap: 2,
+      children: [
+        fixed(Text({ ...(icon.color === undefined ? {} : { color: icon.color }), children: icon.glyph })),
+        fixed(Text({ dimColor: true, children: name })),
+        Box({ flexDirection: 'column', flexGrow: 1, flexShrink: 1, children: details === undefined ? [message] : [message, details] }),
+        ...(action === undefined ? [] : [fixed(Button({ plain: true, key: `toast:${entry.id}:action`, label: action.label, onPress: press(entry, action.onClick) }))]),
+        fixed(Button({ plain: true, dimColor: true, key: `toast:${entry.id}:close`, label: '✕', onPress: () => dismiss(entry.id) })),
+      ],
+    })
+  }
+
+  return {
+    toast,
+    copy,
+    get shown() {
+      return [...entries.values()].map(({ type, message, options }) => ({ type, message, ...(typeof options.description === 'string' ? { description: options.description } : {}) }))
+    },
+    draw(drawn, table, band) {
+      isHeld = band.hasSurvey === true
+      if (isHeld || entries.size === 0) return drawn
+      const all = [...entries.values()]
+      const hidden = showsAll ? 0 : Math.max(all.length - visibleToasts, 0)
+      for (const entry of all.slice(hidden)) arm(entry)
+      const more = Button({
+        plain: true,
+        dimColor: true,
+        key: 'toasts:more',
+        label: `+${hidden} more`,
+        onPress: () => {
+          showsAll = true
+          changed()
+        },
+      })
+      return drawWith(table, () => Box({ flexDirection: 'column', children: [drawn, ...(hidden > 0 ? [more] : []), ...all.slice(hidden).map(row)] }))
+    },
+  }
+}
+
+export type FailureTarget = {
+  readonly name: string
+  readonly ui: Pick<Mod['ui'], 'toast' | 'copy'>
+  readonly claude: { readonly plugin: Claude['plugin']; readonly fs: Pick<Claude['fs'], 'read'> }
+}
+
+export function showFailure({ name, ui, claude }: FailureTarget, { id, message, error, description = describe(error) }: Failure): ToastId {
+  const stack = error instanceof Error && error.stack !== undefined ? `\n\n${error.stack}` : ''
+  const show = (label: string): ToastId => ui.toast.error(message, { id, description, duration: Infinity, action: { label, onClick: copy } })
+  const copy = async (): Promise<ToastId> => {
+    const modVersion = await claude.fs
+      .read(`${claude.plugin.root}/.claude-plugin/plugin.json`)
+      .then((text) => String((JSON.parse(text) as { version?: unknown }).version))
+      .catch((failure: unknown) => `unknown (${messageOf(failure)})`)
+    return ui.copy(`${name} ${modVersion}, @cmodjs/core ${coreVersion}\n${message}\n${description}${stack}`).then(
+      () => show('Copied'),
+      (failure: unknown) => show(`Copy failed: ${messageOf(failure)}`),
+    )
+  }
+  return show('Copy')
+}
+
+function describe(error: unknown): string {
+  const messages: string[] = []
+  for (let cause = error; cause !== undefined; cause = cause instanceof Error ? cause.cause : undefined) {
+    const text = messageOf(cause)
+    if (!messages.some((earlier) => earlier.includes(text) || text.includes(earlier))) messages.push(text)
+  }
+  return messages.join('\n')
+}

package/src/runtime/ui.ts

@@ -1,125 +1,19 @@
-import type { ElementTable, MarkdownProps, PaneOpenArgs, RenderElement, Timer } from 'claude-code'
-import type { Mod, PaneHandle, ProgressStep } from '../mod.js'
-import { ProgressBar } from '../ui/components.js'
+import type { ElementTable, MarkdownProps, PaneOpenArgs, RenderElement } from 'claude-code'
+import type { Disposable, Mod, PaneHandle } from '../mod.js'
 import type { Pane } from '../ui/define-pane.js'
 import { Box, drawWith, Text } from '../ui/elements.js'
-import type { MarkdownKind, MarkdownReader } from '../ui/markdown.js'
-import type { Slot, SlotProps } from '../ui/slots.js'
+import type { MarkdownReader } from '../ui/markdown.js'
+import { componentOf, nameOf, type Place, type PlaceProps } from '../ui/places.js'
 import { messageOf } from '../utils/text.js'
 import type { Claude } from './claude.js'
 import type { Router } from './router.js'
-
-export type ProgressLine = {
-  report(step: ProgressStep): void
-  wait(text: string): void
-  fail(reason: string, fix: string): void
-  end(): void
-}
-
-export type Progress = {
-  readonly isShown: boolean
-  start(title: string): ProgressLine
-  draw(drawn: RenderElement, table: ElementTable, columns: number | undefined): RenderElement
-}
-
-type Line = {
-  readonly title: string
-  step: ProgressStep | undefined
-  waiting: string | undefined
-  failure: { readonly reason: string; readonly fix: string } | undefined
-}
+import type { Failure, Toaster } from './toaster.js'
 
 type PaneSize = Pick<PaneOpenArgs, 'columns' | 'rows'>
 
-const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] as const
-const spinnerMs = 100
 const bullet = '⏺'
-const widestBar = 30
-const narrowestBar = 10
 const sizeKeys = ['columns', 'rows'] as const
 
-export function createProgress(claude: Claude): Progress {
-  const lines: Line[] = []
-  let frame = 0
-  let timer: Timer | undefined
-
-  const changed = () => {
-    const isSpinning = lines.some((line) => line.failure === undefined && line.waiting === undefined)
-    if (isSpinning && timer === undefined) {
-      timer = claude.clock.every(spinnerMs, () => {
-        frame += 1
-        claude.ui.invalidate('ui.render')
-      })
-    }
-    if (!isSpinning && timer !== undefined) {
-      timer.cancel()
-      timer = undefined
-    }
-    claude.ui.invalidate('ui.render')
-  }
-
-  return {
-    get isShown() {
-      return lines.length > 0
-    },
-    start(title) {
-      const line: Line = { title, step: undefined, waiting: undefined, failure: undefined }
-      lines.push(line)
-      changed()
-      return {
-        report(step) {
-          line.step = step
-          line.waiting = undefined
-          changed()
-        },
-        wait(text) {
-          line.waiting = text
-          changed()
-        },
-        fail(reason, fix) {
-          line.failure = { reason, fix }
-          changed()
-        },
-        end() {
-          const index = lines.indexOf(line)
-          if (index >= 0) lines.splice(index, 1)
-          changed()
-        },
-      }
-    },
-    draw(drawn, table, columns) {
-      return drawWith(table, () => Box({ flexDirection: 'column', children: [drawn, ...lines.map((line) => drawLine(line, frame, columns))] }))
-    },
-  }
-}
-
-function drawLine(line: Line, frame: number, columns: number | undefined): RenderElement {
-  const title = Text({ bold: true, children: line.title })
-  if (line.failure !== undefined) {
-    return Box({
-      flexDirection: 'column',
-      children: [
-        Box({ children: [Box({ minWidth: 2, children: Text({ color: 'error', children: '✗' }) }), Text({ children: [title, '  ', Text({ color: 'error', children: line.failure.reason })] })] }),
-        Box({ paddingLeft: 2, children: Text({ dimColor: true, children: line.failure.fix }) }),
-      ],
-    })
-  }
-  if (line.waiting !== undefined) {
-    return Text({ wrap: 'truncate-end', children: [Text({ color: 'warning', children: '◌' }), ' ', title, '  ', Text({ dimColor: true, children: line.waiting })] })
-  }
-  const glyph = Text({ color: 'claude', children: spinner[frame % spinner.length] })
-  if (line.step === undefined) return Text({ wrap: 'truncate-end', children: [glyph, ' ', title, Text({ dimColor: true, children: '…' })] })
-  const { done, total, label = '' } = line.step
-  const width = barWidth(columns, `${line.title}${done}/${total}${label}`.length)
-  return Text({ wrap: 'truncate-end', children: [glyph, ' ', title, '  ', ProgressBar({ done, total, width }), ...(label === '' ? [] : ['  ', label])] })
-}
-
-function barWidth(columns: number | undefined, textLength: number): number {
-  if (columns === undefined) return widestBar
-  const spacing = 2 + 2 + 2 + 2
-  return Math.max(narrowestBar, Math.min(widestBar, columns - textLength - spacing))
-}
-
 function paneSize<State extends object>(pane: Pane<State>, state: State): PaneSize {
   const size: { columns?: number; rows?: number } = {}
   for (const key of sizeKeys) {
@@ -197,18 +91,19 @@ export type UiOptions<State extends object> = {
   readonly name: string
   readonly claude: Claude
   readonly router: Router
-  readonly progress: Progress
+  readonly toaster: Toaster
+  readonly report: (failure: Failure) => void
   readonly announce: (feature: string) => void
   readonly mod: () => Mod<State>
 }
 
 export type UiArea<State extends object> = {
-  readonly ui: Mod<State>['ui']
+  readonly ui: Omit<Mod<State>['ui'], 'notice'>
   changed(): void
   restorePanes(): Promise<void>
 }
 
-export function createUi<State extends object>({ name, claude, router, progress, announce, mod }: UiOptions<State>): UiArea<State> {
+export function createUi<State extends object>({ name, claude, router, toaster, report, announce, mod }: UiOptions<State>): UiArea<State> {
   const panes = new Map<string, Pane<State>>()
   const paneLogs = new Map<string, (failure: string) => void>()
   const openPanes = new Set<string>()
@@ -222,7 +117,7 @@ export function createUi<State extends object>({ name, claude, router, progress,
   const logOnce = (what: string) => {
     let hasLogged = false
     return (failure: string) => {
-      if (!hasLogged) claude.ui.log(`${name}: the ${what} render ${failure}`)
+      if (!hasLogged) report({ id: `render:${what}`, message: `The ${what} render failed`, description: failure })
       hasLogged = true
     }
   }
@@ -250,9 +145,9 @@ export function createUi<State extends object>({ name, claude, router, progress,
     }
   }
 
-  const routeMarkdown = (kind: MarkdownKind) => {
+  const routeMarkdown = (createReader: () => MarkdownReader) => {
     if (read !== undefined) return
-    const reader = kind.createReader()
+    const reader = createReader()
     read = reader
     router.add('ui.render', async (e, next) => {
       if (e.component !== 'AssistantMessage') return next(e)
@@ -330,7 +225,7 @@ export function createUi<State extends object>({ name, claude, router, progress,
     try {
       await run()
     } catch (error) {
-      claude.ui.log(`${name}: the ${pane.title} pane's ${handler} threw: ${messageOf(error)}`)
+      report({ id: `pane:${pane.id}:${handler}`, message: `The ${pane.title} pane's ${handler} threw`, error })
     }
   }
 
@@ -358,26 +253,34 @@ export function createUi<State extends object>({ name, claude, router, progress,
         }
         return handle
       },
-      render<S extends Slot>(slot: S, Component: (props: SlotProps<S>) => RenderElement) {
-        const place: Slot = slot
-        const feature = 'markdown' in place ? `a render of markdown ${place.markdown.name}` : `a render of ${place.component}`
-        if (renders.has(feature)) throw new Error(`${name}: ${feature} is already added. Render each slot once.`)
+      render<P extends Place>(place: P, Component: (props: PlaceProps<P>) => RenderElement): Disposable {
+        const target: Place = place
+        const markdown = typeof target === 'string' ? undefined : target
+        const component = componentOf(place)
+        if (markdown === undefined && component === undefined) throw new Error(`${name}: ${String(place)} is not a place render draws, such as ToolCall or CodeBlock.`)
+        const feature = `a render of ${nameOf(place)}`
+        if (renders.has(feature)) throw new Error(`${name}: ${feature} is already added. Render each place once.`)
         renders.add(feature)
         announce(feature)
-        if ('markdown' in place) {
-          const kind = place.markdown
-          markdownRenders.set(kind.type, { Component: Component as unknown as MarkdownRender['Component'], log: logOnce(`markdown ${kind.name}`) })
-          routeMarkdown(kind)
-          return
+        if (markdown !== undefined) {
+          const markdownType = markdown.markdown
+          markdownRenders.set(markdownType, { Component: Component as unknown as MarkdownRender['Component'], log: logOnce(nameOf(place)) })
+          routeMarkdown(markdown.createReader)
+          return {
+            dispose() {
+              markdownRenders.delete(markdownType)
+              renders.delete(feature)
+              claude.ui.invalidate('ui.render')
+            },
+          }
         }
-        const { component } = place
-        const log = logOnce(component)
-        router.add('ui.render', async (e, next) => {
+        const log = logOnce(nameOf(place))
+        const drawing = router.add('ui.render', async (e, next) => {
           if (e.component !== component) return next(e)
           const table = claude.ui.resolve(e)
           const drawn = await drawComponent(
             table,
-            (Default) => Component({ ...e.props, Default } as unknown as SlotProps<S>),
+            (Default) => Component({ ...e.props, Default } as unknown as PlaceProps<P>),
             (given, isClaudesRow) => next({ ...e, props: pieceProps(e.props, given, isClaudesRow) } as typeof e),
           )
           if ('failure' in drawn) {
@@ -387,16 +290,16 @@ export function createUi<State extends object>({ name, claude, router, progress,
           if (e.component !== 'AssistantMessage') return drawn.drawing
           return drawWith(table, () => drawPieces([drawn], e.props.isFirstOfReply ? 'opensReply' : 'inReply'))
         })
-      },
-      toast: (text, options) => claude.ui.toast(text, options),
-      async progress(title, task) {
-        const line = progress.start(title)
-        try {
-          return await task((step) => line.report(step))
-        } finally {
-          line.end()
+        return {
+          dispose() {
+            drawing.dispose()
+            renders.delete(feature)
+            claude.ui.invalidate('ui.render')
+          },
         }
       },
+      toast: toaster.toast,
+      copy: toaster.copy,
       ask: (question, options) => claude.ui.ask(question, options),
       scroll: (args) => claude.ui.scroll(args),
     },

package/src/session/context/context.ts

@@ -0,0 +1,12 @@
+import type { Turn } from './turn/turn.js'
+
+export const ContextStart = 'contextStart'
+
+export const ContextEnd = 'contextEnd'
+
+export type Context = {
+  readonly number: number
+  readonly openedAt: string
+  readonly closedAt?: string
+  turns(): Promise<Turn[]>
+}

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

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

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

@@ -0,0 +1,165 @@
+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((block) => isObject(block) && block['type'] === 'tool_result' && typeof block['tool_use_id'] === 'string') as Readonly<Record<string, unknown>>[]
+  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 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
+}