@cmodjs/core 1.0.0 → 1.5.1

package/src/runtime/toaster.ts

@@ -1,30 +1,47 @@
 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 type { Toast, ToastId, ToastOptions, ToastType } from '../mod.js'
+import { Box, Button, drawWith, Link, Text } from '../ui/elements.js'
+import { coreVersion, isObject } 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 Failure = { readonly id: string; readonly message: string; readonly error?: unknown; readonly description?: string; readonly retry?: () => unknown }
 
 export type Toaster = {
   readonly toast: Toast
   copy(text: string): Promise<void>
+  fail(failure: Failure): ToastId
   readonly shown: readonly ShownToast[]
-  draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt']): RenderElement
+  draw(drawn: RenderElement, table: ElementTable, band: RenderPropsOf['AbovePrompt'], bandId: string): RenderElement
 }
 
+type Action = { readonly label: string; readonly onClick: () => unknown }
+
+type Contact = { readonly kind: 'github'; readonly repository: string } | { readonly kind: 'email'; readonly address: string }
+
+type Reporting = { readonly contact: Contact | undefined; readonly details: string; readonly status?: string }
+
 type Entry = {
   readonly id: ToastId
   readonly type: ToastType
   readonly message: string
   readonly options: ToastOptions
+  readonly actions: readonly Action[]
+  readonly hides?: string
   isOpen: boolean
+  reporting?: Reporting | undefined
+  trying?: string | RenderElement | undefined
   timer: Timer | undefined
 }
 
+const githubRepository = /^https:\/\/github\.com\/([^/]+\/[^/#?]+?)(?:\.git)?(?:\/issues)?\/?$/
+
+const linkLimit = 2048
+
+const hiddenKey = 'cmod:hidden-failures'
+
 const defaultDuration = 4000
 const visibleToasts = 3
 const spinner = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'] as const
@@ -37,16 +54,25 @@ const icons: Record<Exclude<ToastType, 'loading'>, { readonly glyph: string; rea
   error: { glyph: '✗', color: 'error' },
 }
 
-export function createToaster(claude: Claude, name: string): Toaster {
+export function createToaster(claude: Claude, name: string, version: () => string | undefined): Toaster {
   const entries = new Map<ToastId, Entry>()
+  const hidden = new Map<string, string>()
+  void claude.store.get(hiddenKey).then(
+    (saved) => {
+      if (typeof saved !== 'object' || saved === null) return
+      for (const [id, hides] of Object.entries(saved)) if (typeof hides === 'string' && !hidden.has(id)) hidden.set(id, hides)
+    },
+    (error: unknown) => claude.ui.log(`${name}: could not read the failures you hid: ${messageOf(error)}`, { to: 'debug' }),
+  )
   let lastId = 0
   let frame = 0
   let spinning: Timer | undefined
   let isHeld = false
   let showsAll = false
+  let bandId: string | undefined
 
   const changed = () => {
-    const isLoading = [...entries.values()].some((entry) => entry.type === 'loading')
+    const isLoading = [...entries.values()].some((entry) => entry.type === 'loading' || entry.trying !== undefined)
     if (isLoading && spinning === undefined) {
       spinning = claude.clock.every(spinnerMs, () => {
         frame += 1
@@ -85,18 +111,34 @@ export function createToaster(claude: Claude, name: string): Toaster {
     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)
+  const put = (type: ToastType, message: string, options: ToastOptions, actions: readonly Action[], hides?: string): ToastId => {
+    const id = options.id ?? (lastId += 1)
+    const previous = entries.get(id)
+    if (previous?.trying !== undefined && type === 'loading') {
+      previous.trying = options.description ?? message
       changed()
       return id
     }
+    if (previous !== undefined) disarm(previous)
+    const reporting = hides !== undefined && previous?.hides === hides ? previous.reporting : undefined
+    const entry: Entry = { id, type, message, options, actions, ...(hides === undefined ? {} : { hides }), isOpen: previous?.isOpen ?? false, reporting, 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 show =
+    (type: ToastType) =>
+    (message: string, options: ToastOptions = {}): ToastId =>
+      put(type, message, options, options.action === undefined ? [] : [options.action])
+
+  const hide = (entry: Entry) => {
+    dismiss(entry.id)
+    if (entry.hides === undefined) return
+    hidden.set(String(entry.id), entry.hides)
+    void claude.store.set(hiddenKey, Object.fromEntries(hidden)).catch((error: unknown) => claude.ui.log(`${name}: could not remember the failure you hid: ${messageOf(error)}`, { to: 'debug' }))
+  }
 
   const toast: Toast = Object.assign(show('default'), {
     success: show('success'),
@@ -132,7 +174,47 @@ export function createToaster(claude: Claude, name: string): Toaster {
   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 }))
+      .catch((error: unknown) => fail({ id: `press:${entry.id}`, message: `${entry.message}: the press failed`, error }))
+
+  const fail = ({ id, message, error, description = error === undefined ? undefined : describe(error), retry }: Failure): ToastId => {
+    const hides = `${version() ?? ''}\n${message}\n${error === undefined ? '' : describe(error)}`
+    if (hidden.get(id) === hides) return id
+    hidden.delete(id)
+    const stack = error instanceof Error && error.stack !== undefined ? `\n\n${error.stack}` : ''
+    const details = async () => {
+      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 `${name} ${modVersion}, @cmodjs/core ${coreVersion}\n${message}${description === undefined ? '' : `\n${description}`}${stack}`
+    }
+    const startReporting = async () => {
+      const shown = entries.get(id)
+      if (shown === undefined) return
+      shown.reporting = { contact: await contactOf(claude), details: await details() }
+      disarm(shown)
+      changed()
+      if (bandId === undefined) return
+      const focused = await claude.ui.focus({ requestId: bandId, key: `toast:${id}:ask-claude` })
+      if ('deny' in focused) claude.ui.log(`${name}: the Report choices did not take the keys: ${String(focused.deny)}`, { to: 'debug' })
+    }
+    const tryAgain = async () => {
+      const shown = entries.get(id)
+      if (shown === undefined || retry === undefined || shown.trying !== undefined) return
+      shown.trying = 'Starting'
+      changed()
+      try {
+        await retry()
+      } finally {
+        if (entries.get(id) === shown) {
+          shown.trying = undefined
+          changed()
+        }
+      }
+    }
+    const actions = [...(retry === undefined ? [] : [{ label: 'Retry', onClick: tryAgain }]), { label: 'Report', onClick: startReporting }]
+    return put('error', message, { id, ...(description === undefined ? {} : { description }), duration: Infinity }, actions, hides)
+  }
 
   const toggle = (entry: Entry) => () => {
     entry.isOpen = !entry.isOpen
@@ -141,31 +223,72 @@ export function createToaster(claude: Claude, name: string): Toaster {
   }
 
   const row = (entry: Entry): RenderElement => {
-    const { description, action } = entry.options
+    const { description } = 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 icon = entry.type === 'loading' || entry.trying !== undefined ? { 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 })
+    const close = Button({ plain: true, dimColor: true, key: `toast:${entry.id}:close`, label: entry.hides === undefined ? '✕' : 'Hide', onPress: () => hide(entry) })
+    const actions = entry.actions.map((action, index) => Button({ plain: true, key: `toast:${entry.id}:${index === 0 ? 'action' : `action-${index}`}`, label: action.label, onPress: press(entry, action.onClick) }))
+    const buttons = Box({ gap: 2, flexWrap: 'wrap', children: [...actions, close] })
+    const trying = entry.trying === undefined ? undefined : Box({ gap: 1, children: [Text({ dimColor: true, children: 'Trying again:' }), typeof entry.trying === 'string' ? Text({ dimColor: true, wrap: 'truncate-end', children: entry.trying }) : entry.trying] })
+    const text = details === undefined ? [message] : [message, trying ?? details]
+    const under = trying !== undefined && details === undefined ? [trying] : entry.reporting === undefined ? [buttons] : reportChoices(entry, entry.reporting)
     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) })),
+        Box({ flexDirection: 'column', flexGrow: 1, flexShrink: 1, children: entry.hides === undefined ? text : [...text, ...under] }),
+        ...(entry.hides === undefined ? [...actions.map(fixed), fixed(close)] : []),
       ],
     })
   }
 
+  const reportChoices = (entry: Entry, { contact, details, status }: Reporting): RenderElement[] => {
+    const say = (said: string) => {
+      entry.reporting = { contact, details, status: said }
+      changed()
+    }
+    const back = () => {
+      entry.reporting = undefined
+      changed()
+    }
+    const askClaude = async () => {
+      await claude.prompt.submit({ text: reportPrompt(name, contact, details), asUser: true })
+      back()
+    }
+    const copyError = async () => {
+      const copied = await claude.ui.copy({ text: details })
+      say(copied.isCopied ? 'Copied the error.' : `Could not copy it: ${copied.reason}`)
+    }
+    const report = contact === undefined ? [] : [Link({ href: reportLink(contact, name, entry.message, details), label: contact.kind === 'github' ? 'Report it on GitHub (opens your browser)' : 'Email the author (opens your mail app)' })]
+    return [
+      Text({ dimColor: true, children: 'Claude writes up the problem and files it with your tools. You approve each step before anything is posted.' }),
+      Box({
+        gap: 2,
+        flexWrap: 'wrap',
+        children: [
+          Button({ plain: true, key: `toast:${entry.id}:ask-claude`, label: 'Ask Claude to report it', onPress: press(entry, askClaude) }),
+          ...report,
+          Button({ plain: true, key: `toast:${entry.id}:copy`, label: 'Copy the error', onPress: press(entry, copyError) }),
+          Button({ plain: true, dimColor: true, key: `toast:${entry.id}:back`, label: 'Back', onPress: back }),
+        ],
+      }),
+      ...(status === undefined ? [] : [Text({ dimColor: true, children: status })]),
+    ]
+  }
+
   return {
     toast,
     copy,
+    fail,
     get shown() {
       return [...entries.values()].map(({ type, message, options }) => ({ type, message, ...(typeof options.description === 'string' ? { description: options.description } : {}) }))
     },
-    draw(drawn, table, band) {
+    draw(drawn, table, band, drawnIn) {
+      bandId = drawnIn
       isHeld = band.hasSurvey === true
       if (isHeld || entries.size === 0) return drawn
       const all = [...entries.values()]
@@ -186,28 +309,6 @@ export function createToaster(claude: Claude, name: string): Toaster {
   }
 }
 
-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) {
@@ -216,3 +317,40 @@ function describe(error: unknown): string {
   }
   return messages.join('\n')
 }
+
+async function contactOf(claude: Claude): Promise<Contact | undefined> {
+  const manifest: Record<string, unknown> = await claude.fs
+    .read(`${claude.plugin.root}/.claude-plugin/plugin.json`)
+    .then((text) => JSON.parse(text) as Record<string, unknown>)
+    .catch((error: unknown) => {
+      claude.ui.log(`${claude.plugin.name}: could not read whom to report to: ${messageOf(error)}`, { to: 'debug' })
+      return {}
+    })
+  const repositoryUrl = isObject(manifest['repository']) ? manifest['repository']['url'] : manifest['repository']
+  const repository = [manifest['supportUrl'], repositoryUrl].map((url) => (typeof url === 'string' ? githubRepository.exec(url)?.[1] : undefined)).find((found) => found !== undefined)
+  if (repository !== undefined) return { kind: 'github', repository }
+  const author = manifest['author']
+  const address = isObject(author) ? author['email'] : undefined
+  return typeof address === 'string' && address !== '' ? { kind: 'email', address } : undefined
+}
+
+function reportLink(contact: Contact, name: string, message: string, details: string): string {
+  const title = `${name}: ${message}`.slice(0, 120)
+  const linkOf = (body: string) =>
+    contact.kind === 'github'
+      ? `https://github.com/${contact.repository}/issues/new?title=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`
+      : `mailto:${contact.address}?subject=${encodeURIComponent(title)}&body=${encodeURIComponent(body)}`
+  let body = details
+  while (linkOf(body).length > linkLimit && body.length > 0) body = `${body.slice(0, Math.floor(body.length * 0.8))}…`
+  return linkOf(body)
+}
+
+function reportPrompt(name: string, contact: Contact | undefined, details: string): string {
+  const where =
+    contact === undefined
+      ? `${name} names no place to report it, so find its author from its plugin.json or its marketplace.`
+      : contact.kind === 'github'
+        ? `Report it as an issue on https://github.com/${contact.repository}.`
+        : `Email it to ${contact.address}.`
+  return `The ${name} mod failed. Report it to its author. ${where} First check whether it is reported already, and add to that report instead of filing a new one. Show me the report before you post it.\n\n${details}`
+}

package/src/runtime/ui.ts

@@ -107,6 +107,15 @@ export function createUi<State extends object>({ name, claude, router, toaster,
   const panes = new Map<string, Pane<State>>()
   const paneLogs = new Map<string, (failure: string) => void>()
   const openPanes = new Set<string>()
+  const paneStates = new Map<string, { readonly isShown: boolean; readonly isFocused: boolean }>()
+  const syncPanes = async () => {
+    for (const open of await claude.ui.panes()) {
+      if (!panes.has(open.id)) continue
+      if (open.isPlaced) openPanes.add(open.id)
+      paneStates.set(open.id, { isShown: open.isShown, isFocused: open.isFocused })
+    }
+  }
+  const readPanes = () => void syncPanes().catch((error: unknown) => claude.ui.log(`${name} keeps its panes' shown and focused state from before: ${messageOf(error)}`, { to: 'debug' }))
   const requestedSizes = new Map<string, PaneSize>()
   const renders = new Set<string>()
   const markdownRenders = new Map<string, MarkdownRender>()
@@ -197,6 +206,8 @@ export function createUi<State extends object>({ name, claude, router, toaster,
       const pane = panes.get(e.requestId)
       if (pane === undefined || e.component !== 'Pane') return next(e)
       openPanes.add(pane.id)
+      paneStates.set(pane.id, { isShown: true, isFocused: e.props.isFocused })
+      readPanes()
       const table = claude.ui.resolve(e)
       try {
         return drawWith(table, () => pane.render(mod(), e.props), markdownIn(table))
@@ -214,6 +225,8 @@ export function createUi<State extends object>({ name, claude, router, toaster,
     })
     router.add('ui.close', async (e, next) => {
       openPanes.delete(e.id)
+      paneStates.delete(e.id)
+      readPanes()
       const closed = await next(e)
       const pane = panes.get(e.id)
       if (pane?.onClose !== undefined) await handle(pane, 'onClose', () => pane.onClose?.(mod(), e))
@@ -241,13 +254,22 @@ export function createUi<State extends object>({ name, claude, router, toaster,
           get isOpen() {
             return openPanes.has(pane.id)
           },
+          get isShown() {
+            return paneStates.get(pane.id)?.isShown ?? false
+          },
+          get isFocused() {
+            return paneStates.get(pane.id)?.isFocused ?? false
+          },
           async open(options) {
             const { isPlaced } = await openAt(pane, paneSize(pane, mod().state), options?.focus)
             if (isPlaced) openPanes.add(pane.id)
+            await syncPanes()
           },
           async close() {
             await claude.ui.close({ id: pane.id })
             openPanes.delete(pane.id)
+            paneStates.delete(pane.id)
+            await syncPanes()
           },
           toggle: (options) => (openPanes.has(pane.id) ? handle.close() : handle.open(options)),
         }
@@ -316,10 +338,7 @@ export function createUi<State extends object>({ name, claude, router, toaster,
       })
     },
     async restorePanes() {
-      if (panes.size === 0) return
-      for (const open of await claude.ui.panes()) {
-        if (open.isPlaced && panes.has(open.id)) openPanes.add(open.id)
-      }
+      if (panes.size > 0) await syncPanes()
     },
   }
 }

package/src/session/context/context.ts

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

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

@@ -112,7 +112,7 @@ function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
     })
   }
   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>>[]
+  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 }]
@@ -122,6 +122,44 @@ function unplacedOf(row: Row, isInTask: boolean): Unplaced[] {
   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 ''

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

@@ -1,3 +1,4 @@
+import type { RecordPart } from '../../session.js'
 import type { Message } from './message/message.js'
 import type { Prompt } from './message/prompt.js'
 
@@ -5,7 +6,7 @@ export const TurnStart = 'turnStart'
 
 export const TurnEnd = 'turnEnd'
 
-export type Turn = {
+export type Turn = RecordPart & {
   readonly prompt: Prompt
   readonly context: number
   readonly openedAt: string