@vibe-forge/client 0.10.1 → 0.11.1

package/src/components/chat/tools/adapter-claude/claude-tool-shared.ts

@@ -0,0 +1,185 @@
+export type ClaudeToolFieldFormat = 'inline' | 'text' | 'code' | 'list' | 'json' | 'questions'
+
+export interface ClaudeToolQuestionOption {
+  label: string
+  description?: string
+}
+
+export interface ClaudeToolQuestion {
+  header?: string
+  question: string
+  options: ClaudeToolQuestionOption[]
+  multiSelect: boolean
+}
+
+export interface ClaudeToolField {
+  labelKey: string
+  fallbackLabel: string
+  format: ClaudeToolFieldFormat
+  value: unknown
+  lang?: string
+}
+
+export interface ClaudeToolPresentation {
+  baseName: string
+  titleKey: string
+  fallbackTitle: string
+  icon: string
+  primary?: string
+  fields: ClaudeToolField[]
+}
+
+export const CLAUDE_TOOL_META: Record<string, Pick<ClaudeToolPresentation, 'titleKey' | 'fallbackTitle' | 'icon'>> = {
+  AskUserQuestion: { titleKey: 'chat.tools.askUserQuestion', fallbackTitle: 'Ask User Question', icon: 'help' },
+  Bash: { titleKey: 'chat.tools.bash', fallbackTitle: 'Bash', icon: 'terminal' },
+  Edit: { titleKey: 'chat.tools.editTool', fallbackTitle: 'Edit File', icon: 'edit' },
+  EnterPlanMode: { titleKey: 'chat.tools.enterPlanMode', fallbackTitle: 'Enter Plan Mode', icon: 'rule_settings' },
+  ExitPlanMode: { titleKey: 'chat.tools.exitPlanMode', fallbackTitle: 'Exit Plan Mode', icon: 'exit_to_app' },
+  Glob: { titleKey: 'chat.tools.globTool', fallbackTitle: 'Glob', icon: 'search' },
+  Grep: { titleKey: 'chat.tools.grepTool', fallbackTitle: 'Grep', icon: 'find_in_page' },
+  LS: { titleKey: 'chat.tools.lsTool', fallbackTitle: 'List Directory', icon: 'folder_open' },
+  NotebookEdit: { titleKey: 'chat.tools.notebookEdit', fallbackTitle: 'Notebook Edit', icon: 'edit_note' },
+  Read: { titleKey: 'chat.tools.read', fallbackTitle: 'Read File', icon: 'visibility' },
+  Skill: { titleKey: 'chat.tools.skill', fallbackTitle: 'Skill', icon: 'auto_awesome' },
+  Task: { titleKey: 'chat.tools.claudeTask', fallbackTitle: 'Claude Task', icon: 'smart_toy' },
+  TaskCreate: { titleKey: 'chat.tools.taskCreate', fallbackTitle: 'Create Task', icon: 'add_task' },
+  TaskGet: { titleKey: 'chat.tools.taskGet', fallbackTitle: 'Get Task', icon: 'info' },
+  TaskList: { titleKey: 'chat.tools.taskList', fallbackTitle: 'List Tasks', icon: 'list_alt' },
+  TaskUpdate: { titleKey: 'chat.tools.taskUpdate', fallbackTitle: 'Update Task', icon: 'edit_calendar' },
+  TodoWrite: { titleKey: 'chat.tools.todo', fallbackTitle: 'Task Planning', icon: 'task_alt' },
+  WebFetch: { titleKey: 'chat.tools.webFetch', fallbackTitle: 'Web Fetch', icon: 'language' },
+  WebSearch: { titleKey: 'chat.tools.webSearch', fallbackTitle: 'Web Search', icon: 'travel_explore' },
+  Write: { titleKey: 'chat.tools.write', fallbackTitle: 'Write File', icon: 'edit_note' }
+}
+
+export const isRecord = (value: unknown): value is Record<string, unknown> => (
+  value != null && typeof value === 'object' && !Array.isArray(value)
+)
+
+export const asString = (value: unknown) => (
+  typeof value === 'string' && value.trim() !== '' ? value : undefined
+)
+
+export const asNumber = (value: unknown) => (
+  typeof value === 'number' && Number.isFinite(value) ? value : undefined
+)
+
+export const asBoolean = (value: unknown) => (
+  typeof value === 'boolean' ? value : undefined
+)
+
+export const asStringArray = (value: unknown) => {
+  if (!Array.isArray(value)) {
+    return undefined
+  }
+
+  const items = value
+    .filter(item => typeof item === 'string' && item.trim() !== '')
+    .map(item => item.trim())
+  return items.length > 0 ? items : undefined
+}
+
+export const pushField = (
+  fields: ClaudeToolField[],
+  usedKeys: Set<string>,
+  key: string,
+  field: Omit<ClaudeToolField, 'value'> & { value: unknown }
+) => {
+  const { value } = field
+  if (value == null || value === '') {
+    return
+  }
+  if (Array.isArray(value) && value.length === 0) {
+    return
+  }
+  if (isRecord(value) && Object.keys(value).length === 0) {
+    return
+  }
+
+  usedKeys.add(key)
+  fields.push(field)
+}
+
+export const toQuestionList = (value: unknown): ClaudeToolQuestion[] | undefined => {
+  if (!Array.isArray(value)) {
+    return undefined
+  }
+
+  const questions: ClaudeToolQuestion[] = []
+  for (const item of value) {
+    if (!isRecord(item)) {
+      continue
+    }
+
+    const question = asString(item.question)
+    if (question == null) {
+      continue
+    }
+
+    const options: ClaudeToolQuestionOption[] = []
+    if (Array.isArray(item.options)) {
+      for (const option of item.options) {
+        if (!isRecord(option)) {
+          continue
+        }
+
+        const label = asString(option.label)
+        if (label == null) {
+          continue
+        }
+
+        options.push({
+          label,
+          description: asString(option.description)
+        })
+      }
+    }
+
+    questions.push({
+      header: asString(item.header),
+      question,
+      options,
+      multiSelect: item.multiSelect === true
+    })
+  }
+
+  return questions.length > 0 ? questions : undefined
+}
+
+export const getDescriptionTitle = (value: string | undefined) => (
+  value != null && value !== '' ? value.split('\n')[0]?.trim() || value : undefined
+)
+
+export const addDetailsField = (
+  fields: ClaudeToolField[],
+  record: Record<string, unknown> | null,
+  usedKeys: Set<string>
+) => {
+  if (record == null) {
+    return
+  }
+
+  const details = Object.fromEntries(
+    Object.entries(record).filter(([key, value]) => {
+      if (usedKeys.has(key) || value == null) {
+        return false
+      }
+      if (typeof value === 'string') {
+        return value.trim() !== ''
+      }
+      if (Array.isArray(value)) {
+        return value.length > 0
+      }
+      return !isRecord(value) || Object.keys(value).length > 0
+    })
+  )
+
+  if (Object.keys(details).length > 0) {
+    fields.push({
+      labelKey: 'chat.tools.fields.details',
+      fallbackLabel: 'Details',
+      format: 'json',
+      value: details
+    })
+  }
+}

package/src/components/chat/tools/adapter-claude/claude-tool-summary.ts

@@ -0,0 +1,76 @@
+import { buildClaudeToolPresentation, getClaudeToolBaseName } from './claude-tool-presentation'
+import { isRecord, toQuestionList } from './claude-tool-shared'
+import { getFileInfo } from './utils'
+
+type Translate = (key: string, options?: Record<string, unknown>) => string
+
+const getRecord = (input: unknown) => (isRecord(input) ? input : null)
+
+const joinSummary = (title: string, primary?: string) => (
+  primary != null && primary !== '' ? `${title} ${primary}` : title
+)
+
+export function getClaudeToolSummaryText(name: string, input: unknown, t: Translate) {
+  const baseName = getClaudeToolBaseName(name)
+  const record = getRecord(input)
+
+  if (baseName === 'Bash') {
+    const description = [record?.description, record?.reason, record?.thought]
+      .find(value => typeof value === 'string' && value.trim() !== '')
+    const command = typeof record?.command === 'string' ? record.command : ''
+    const commandLine = command.split('\n')[0]?.trim()
+    return typeof description === 'string' && description.trim() !== ''
+      ? description.trim()
+      : joinSummary(t('chat.tools.bash', { defaultValue: 'Bash' }), commandLine)
+  }
+
+  if (baseName === 'Read' || baseName === 'Write' || baseName === 'Edit') {
+    const pathValue = typeof record?.file_path === 'string' ? getFileInfo(record.file_path).filePath : undefined
+    const titleKey = baseName === 'Read'
+      ? 'chat.tools.read'
+      : baseName === 'Write'
+      ? 'chat.tools.write'
+      : 'chat.tools.editTool'
+    const fallback = baseName === 'Read' ? 'Read File' : baseName === 'Write' ? 'Write File' : 'Edit File'
+    return joinSummary(t(titleKey, { defaultValue: fallback }), pathValue)
+  }
+
+  if (baseName === 'NotebookEdit') {
+    const notebookPath = typeof record?.notebook_path === 'string'
+      ? getFileInfo(record.notebook_path).filePath
+      : undefined
+    return joinSummary(t('chat.tools.notebookEdit', { defaultValue: 'Notebook Edit' }), notebookPath)
+  }
+
+  if (baseName === 'LS') {
+    const pathValue = typeof record?.path === 'string' && record.path !== '' ? record.path : 'current directory'
+    return joinSummary(t('chat.tools.lsTool', { defaultValue: 'List Directory' }), pathValue)
+  }
+
+  if (baseName === 'Glob') {
+    const pattern = typeof record?.pattern === 'string' && record.pattern !== '' ? record.pattern : '*'
+    return joinSummary(t('chat.tools.globTool', { defaultValue: 'Glob' }), pattern)
+  }
+
+  if (baseName === 'Grep') {
+    const pattern = typeof record?.pattern === 'string' ? record.pattern : undefined
+    return joinSummary(t('chat.tools.grepTool', { defaultValue: 'Grep' }), pattern)
+  }
+
+  if (baseName === 'TodoWrite') {
+    const count = Array.isArray(record?.todos) ? record.todos.length : 0
+    return joinSummary(t('chat.tools.todo', { defaultValue: 'Task Planning' }), count > 0 ? `${count}` : undefined)
+  }
+
+  if (baseName === 'AskUserQuestion') {
+    const firstQuestion = toQuestionList(record?.questions)?.[0]
+    return joinSummary(
+      t('chat.tools.askUserQuestion', { defaultValue: 'Ask User Question' }),
+      firstQuestion?.header ?? firstQuestion?.question
+    )
+  }
+
+  const presentation = buildClaudeToolPresentation(name, input)
+  const title = t(presentation.titleKey, { defaultValue: presentation.fallbackTitle })
+  return joinSummary(title, presentation.primary)
+}

package/src/components/chat/tools/adapter-claude/claude-tool-system-builders.ts

@@ -0,0 +1,125 @@
+import { asBoolean, asString, asStringArray, pushField, toQuestionList } from './claude-tool-shared'
+import type { ClaudeToolField } from './claude-tool-shared'
+
+interface BuilderParams {
+  baseName: string
+  record: Record<string, unknown> | null
+  fields: ClaudeToolField[]
+  usedKeys: Set<string>
+}
+
+export function buildClaudeSystemToolPresentation(params: BuilderParams) {
+  const { baseName, record, fields, usedKeys } = params
+
+  if (baseName === 'WebFetch') {
+    pushField(fields, usedKeys, 'prompt', {
+      labelKey: 'chat.tools.fields.prompt',
+      fallbackLabel: 'Prompt',
+      format: 'text',
+      value: asString(record?.prompt)
+    })
+    usedKeys.add('url')
+    return { handled: true, primary: asString(record?.url) }
+  }
+
+  if (baseName === 'WebSearch') {
+    pushField(fields, usedKeys, 'allowed_domains', {
+      labelKey: 'chat.tools.fields.allowedDomains',
+      fallbackLabel: 'Allowed Domains',
+      format: 'list',
+      value: asStringArray(record?.allowed_domains)
+    })
+    pushField(fields, usedKeys, 'blocked_domains', {
+      labelKey: 'chat.tools.fields.blockedDomains',
+      fallbackLabel: 'Blocked Domains',
+      format: 'list',
+      value: asStringArray(record?.blocked_domains)
+    })
+    usedKeys.add('query')
+    return { handled: true, primary: asString(record?.query) }
+  }
+
+  if (baseName === 'AskUserQuestion') {
+    const questions = toQuestionList(record?.questions)
+
+    pushField(fields, usedKeys, 'questions', {
+      labelKey: 'chat.tools.fields.questions',
+      fallbackLabel: 'Questions',
+      format: 'questions',
+      value: questions
+    })
+    pushField(fields, usedKeys, 'answers', {
+      labelKey: 'chat.tools.fields.answers',
+      fallbackLabel: 'Answers',
+      format: 'json',
+      value: record?.answers != null && typeof record.answers === 'object' ? record.answers : undefined
+    })
+    pushField(fields, usedKeys, 'metadata', {
+      labelKey: 'chat.tools.fields.metadata',
+      fallbackLabel: 'Metadata',
+      format: 'json',
+      value: record?.metadata != null && typeof record.metadata === 'object' ? record.metadata : undefined
+    })
+    return { handled: true, primary: questions?.[0]?.header ?? questions?.[0]?.question }
+  }
+
+  if (baseName === 'Skill') {
+    pushField(fields, usedKeys, 'args', {
+      labelKey: 'chat.tools.fields.args',
+      fallbackLabel: 'Args',
+      format: 'text',
+      value: asString(record?.args)
+    })
+    usedKeys.add('skill')
+    return { handled: true, primary: asString(record?.skill) }
+  }
+
+  if (baseName === 'EnterPlanMode') {
+    return { handled: true }
+  }
+
+  if (baseName !== 'ExitPlanMode') {
+    return { handled: false }
+  }
+
+  pushField(fields, usedKeys, 'pushToRemote', {
+    labelKey: 'chat.tools.fields.pushToRemote',
+    fallbackLabel: 'Push To Remote',
+    format: 'inline',
+    value: asBoolean(record?.pushToRemote) != null ? String(record?.pushToRemote) : undefined
+  })
+  pushField(fields, usedKeys, 'remoteSessionId', {
+    labelKey: 'chat.tools.fields.remoteSession',
+    fallbackLabel: 'Remote Session',
+    format: 'inline',
+    value: asString(record?.remoteSessionId)
+  })
+  pushField(fields, usedKeys, 'remoteSessionUrl', {
+    labelKey: 'chat.tools.fields.remoteSessionUrl',
+    fallbackLabel: 'Remote Session URL',
+    format: 'text',
+    value: asString(record?.remoteSessionUrl)
+  })
+  pushField(fields, usedKeys, 'allowedPrompts', {
+    labelKey: 'chat.tools.fields.allowedPrompts',
+    fallbackLabel: 'Allowed Prompts',
+    format: 'list',
+    value: Array.isArray(record?.allowedPrompts)
+      ? record.allowedPrompts.flatMap((item) => {
+        if (item == null || typeof item !== 'object') {
+          return []
+        }
+        const data = item as Record<string, unknown>
+        const tool = asString(data.tool)
+        const prompt = asString(data.prompt)
+        return prompt != null ? [`${tool ?? 'Tool'}: ${prompt}`] : []
+      })
+      : undefined
+  })
+  usedKeys.add('remoteSessionTitle')
+
+  return {
+    handled: true,
+    primary: asString(record?.remoteSessionTitle) ?? asString(record?.remoteSessionId)
+  }
+}

package/src/components/chat/tools/adapter-claude/claude-tool-task-builders.ts

@@ -0,0 +1,148 @@
+import { asBoolean, asNumber, asString, asStringArray, getDescriptionTitle, pushField } from './claude-tool-shared'
+import type { ClaudeToolField } from './claude-tool-shared'
+
+interface BuilderParams {
+  baseName: string
+  record: Record<string, unknown> | null
+  fields: ClaudeToolField[]
+  usedKeys: Set<string>
+}
+
+export function buildClaudeTaskToolPresentation(params: BuilderParams) {
+  const { baseName, record, fields, usedKeys } = params
+
+  if (baseName === 'Task') {
+    const description = asString(record?.description)
+
+    pushField(fields, usedKeys, 'description', {
+      labelKey: 'chat.tools.fields.description',
+      fallbackLabel: 'Description',
+      format: 'text',
+      value: description
+    })
+    pushField(fields, usedKeys, 'prompt', {
+      labelKey: 'chat.tools.fields.prompt',
+      fallbackLabel: 'Prompt',
+      format: 'text',
+      value: asString(record?.prompt)
+    })
+    pushField(fields, usedKeys, 'subagent_type', {
+      labelKey: 'chat.tools.fields.subagentType',
+      fallbackLabel: 'Subagent Type',
+      format: 'inline',
+      value: asString(record?.subagent_type)
+    })
+    pushField(fields, usedKeys, 'model', {
+      labelKey: 'chat.tools.fields.model',
+      fallbackLabel: 'Model',
+      format: 'inline',
+      value: asString(record?.model)
+    })
+    pushField(fields, usedKeys, 'resume', {
+      labelKey: 'chat.tools.fields.resume',
+      fallbackLabel: 'Resume',
+      format: 'inline',
+      value: asString(record?.resume)
+    })
+    pushField(fields, usedKeys, 'run_in_background', {
+      labelKey: 'chat.tools.fields.runInBackground',
+      fallbackLabel: 'Run In Background',
+      format: 'inline',
+      value: asBoolean(record?.run_in_background) != null ? String(record?.run_in_background) : undefined
+    })
+    pushField(fields, usedKeys, 'max_turns', {
+      labelKey: 'chat.tools.fields.maxTurns',
+      fallbackLabel: 'Max Turns',
+      format: 'inline',
+      value: asNumber(record?.max_turns)
+    })
+    return { handled: true, primary: getDescriptionTitle(description) ?? asString(record?.subagent_type) }
+  }
+
+  if (baseName === 'TaskCreate') {
+    pushField(fields, usedKeys, 'description', {
+      labelKey: 'chat.tools.fields.description',
+      fallbackLabel: 'Description',
+      format: 'text',
+      value: asString(record?.description)
+    })
+    pushField(fields, usedKeys, 'activeForm', {
+      labelKey: 'chat.tools.fields.activeForm',
+      fallbackLabel: 'Active Form',
+      format: 'text',
+      value: asString(record?.activeForm)
+    })
+    pushField(fields, usedKeys, 'metadata', {
+      labelKey: 'chat.tools.fields.metadata',
+      fallbackLabel: 'Metadata',
+      format: 'json',
+      value: record?.metadata != null && typeof record.metadata === 'object' ? record.metadata : undefined
+    })
+    usedKeys.add('subject')
+    return { handled: true, primary: asString(record?.subject) }
+  }
+
+  if (baseName === 'TaskGet') {
+    usedKeys.add('taskId')
+    return { handled: true, primary: asString(record?.taskId) }
+  }
+
+  if (baseName === 'TaskUpdate') {
+    pushField(fields, usedKeys, 'subject', {
+      labelKey: 'chat.tools.fields.subject',
+      fallbackLabel: 'Subject',
+      format: 'text',
+      value: asString(record?.subject)
+    })
+    pushField(fields, usedKeys, 'description', {
+      labelKey: 'chat.tools.fields.description',
+      fallbackLabel: 'Description',
+      format: 'text',
+      value: asString(record?.description)
+    })
+    pushField(fields, usedKeys, 'activeForm', {
+      labelKey: 'chat.tools.fields.activeForm',
+      fallbackLabel: 'Active Form',
+      format: 'text',
+      value: asString(record?.activeForm)
+    })
+    pushField(fields, usedKeys, 'status', {
+      labelKey: 'chat.tools.fields.status',
+      fallbackLabel: 'Status',
+      format: 'inline',
+      value: asString(record?.status)
+    })
+    pushField(fields, usedKeys, 'owner', {
+      labelKey: 'chat.tools.fields.owner',
+      fallbackLabel: 'Owner',
+      format: 'inline',
+      value: asString(record?.owner)
+    })
+    pushField(fields, usedKeys, 'addBlocks', {
+      labelKey: 'chat.tools.fields.addBlocks',
+      fallbackLabel: 'Add Blocks',
+      format: 'list',
+      value: asStringArray(record?.addBlocks)
+    })
+    pushField(fields, usedKeys, 'addBlockedBy', {
+      labelKey: 'chat.tools.fields.addBlockedBy',
+      fallbackLabel: 'Add Blocked By',
+      format: 'list',
+      value: asStringArray(record?.addBlockedBy)
+    })
+    pushField(fields, usedKeys, 'metadata', {
+      labelKey: 'chat.tools.fields.metadata',
+      fallbackLabel: 'Metadata',
+      format: 'json',
+      value: record?.metadata != null && typeof record.metadata === 'object' ? record.metadata : undefined
+    })
+    usedKeys.add('taskId')
+    return { handled: true, primary: asString(record?.taskId) }
+  }
+
+  if (baseName === 'TaskList') {
+    return { handled: true }
+  }
+
+  return { handled: false }
+}

package/src/components/chat/tools/adapter-claude/index.ts

@@ -1,22 +1,31 @@
 import type {} from '@vibe-forge/adapter-claude-code/schema'
 
 import { defineToolRenders } from '../defineToolRender'
-import { BashTool } from './BashTool'
-import { GlobTool } from './GlobTool'
-import { GrepTool } from './GrepTool'
-import { LsTool } from './LSTool'
-import { ReadTool } from './ReadTool'
-import { TodoTool } from './TodoTool'
-import { WriteTool } from './WriteTool'
+import { GenericClaudeTool } from './GenericClaudeTool'
+export { buildClaudeToolPresentation, getClaudeToolBaseName, isClaudeToolName } from './claude-tool-presentation'
+export { getClaudeToolSummaryText } from './claude-tool-summary'
 
 export const adapterClaudeToolRenders = defineToolRenders({
-  Bash: BashTool,
-  LS: LsTool,
-  Glob: GlobTool,
-  Grep: GrepTool,
-  Read: ReadTool,
-  Write: WriteTool,
-  TodoWrite: TodoTool
+  AskUserQuestion: GenericClaudeTool,
+  Bash: GenericClaudeTool,
+  Edit: GenericClaudeTool,
+  EnterPlanMode: GenericClaudeTool,
+  ExitPlanMode: GenericClaudeTool,
+  LS: GenericClaudeTool,
+  Glob: GenericClaudeTool,
+  Grep: GenericClaudeTool,
+  NotebookEdit: GenericClaudeTool,
+  Read: GenericClaudeTool,
+  Skill: GenericClaudeTool,
+  Task: GenericClaudeTool,
+  TaskCreate: GenericClaudeTool,
+  TaskGet: GenericClaudeTool,
+  TaskList: GenericClaudeTool,
+  TaskUpdate: GenericClaudeTool,
+  WebFetch: GenericClaudeTool,
+  WebSearch: GenericClaudeTool,
+  Write: GenericClaudeTool,
+  TodoWrite: GenericClaudeTool
 }, { namespace: 'adapter:claude-code:' })
 
-export { BashTool, GlobTool, GrepTool, LsTool, ReadTool, TodoTool, WriteTool }
+export { GenericClaudeTool }