ethagent 3.3.4 → 4.0.0

package/src/runtime/toolExecution.ts

@@ -1,304 +0,0 @@
-import { getTool } from '../tools/registry.js'
-import {
-  buildPermissionRule,
-  matchPermissionRule,
-  shouldPersistPermissionDecision,
-} from '../tools/permissionRules.js'
-import { ZodError } from 'zod'
-import type {
-  PermissionDecision,
-  PermissionMode,
-  PermissionRequest,
-  SessionPermissionRule,
-  Tool,
-  ToolExecutionContext,
-  ToolResult,
-} from '../tools/contracts.js'
-import { setCwd as setRuntimeCwd } from './cwd.js'
-import type { EthagentConfig } from '../storage/config.js'
-import type { SessionMessage } from '../storage/sessions.js'
-import { toolResultContentForRow, toolResultDiffForRow } from '../chat/chatScreenUtils.js'
-import type { MessageRow } from '../chat/MessageList.js'
-import { modePolicy, toPermissionMode, type SessionMode } from './sessionMode.js'
-
-export type ToolExecutorOptions = {
-  name: string
-  input: Record<string, unknown>
-  permissionMode: PermissionMode
-  cwd: string
-  config?: EthagentConfig
-  abortSignal?: AbortSignal
-  checkpoint?: ToolExecutionContext['checkpoint']
-  dynamicTools?: Tool[]
-  mcp?: ToolExecutionContext['mcp']
-  getPermissionRules: () => SessionPermissionRule[]
-  requestPermission: (request: PermissionRequest) => Promise<PermissionDecision>
-  onDirectoryChange: (next: string) => void
-}
-
-export type ToolExecutionOutcome = {
-  result: ToolResult
-  sessionRule?: SessionPermissionRule
-  persistRule?: boolean
-}
-
-export async function executeToolWithPermissions(
-  options: ToolExecutorOptions,
-): Promise<ToolExecutionOutcome> {
-  const tool = getTool(options.name, { dynamicTools: options.dynamicTools })
-  if (!tool) {
-    return {
-      result: {
-        ok: false,
-        summary: `Unknown tool ${options.name}`,
-        content: `Tool '${options.name}' is not registered`,
-      },
-    }
-  }
-
-  let parsedInput: ReturnType<typeof tool.parse>
-  try {
-    parsedInput = tool.parse(options.input)
-  } catch (err: unknown) {
-    return {
-      result: {
-        ok: false,
-        summary: `${options.name} rejected input`,
-        content: formatToolParseError(err, options.name),
-      },
-    }
-  }
-
-  const context: ToolExecutionContext = {
-    workspaceRoot: options.cwd,
-    config: options.config,
-    abortSignal: options.abortSignal,
-    mcp: options.mcp,
-    checkpoint: options.checkpoint,
-    changeDirectory: next => {
-      const updated = setRuntimeCwd(next, options.cwd)
-      options.onDirectoryChange(updated)
-    },
-  }
-
-  let request: PermissionRequest
-  try {
-    request = await tool.buildPermissionRequest(parsedInput, context)
-  } catch (err: unknown) {
-    return {
-      result: {
-        ok: false,
-        summary: `${options.name} failed before execution`,
-        content: (err as Error).message,
-      },
-    }
-  }
-
-  if (
-    options.permissionMode === 'plan' &&
-    request.kind !== 'read' &&
-    request.kind !== 'private-continuity-read' &&
-    request.kind !== 'private-skill-read' &&
-    !(request.kind === 'mcp' && request.readOnly)
-  ) {
-    return {
-      result: {
-        ok: false,
-        summary: `${options.name} blocked in plan mode`,
-        content: 'plan mode allows inspection only. switch modes before changing files, directories, or running shell commands.',
-      },
-    }
-  }
-
-  const matchedRule = matchPermissionRule(options.getPermissionRules(), request)
-  const decision: PermissionDecision =
-    modePolicy(options.permissionMode).autoAllowToolKind(tool.kind)
-      ? 'allow-once'
-      : matchedRule
-        ? 'allow-once'
-        : await options.requestPermission(request)
-
-  if (decision === 'deny') {
-    return {
-      result: {
-        ok: false,
-        summary: `${options.name} denied`,
-        content: 'tool use denied by the user',
-      },
-    }
-  }
-
-  const rule = buildPermissionRule(decision, request)
-  const persistRule = rule !== undefined && shouldPersistPermissionDecision(decision)
-
-  try {
-    const result = await tool.execute(parsedInput, context)
-    return { result, sessionRule: rule, persistRule }
-  } catch (err: unknown) {
-    return {
-      result: {
-        ok: false,
-        summary: `${options.name} failed`,
-        content: (err as Error).message || 'tool execution failed',
-      },
-      sessionRule: rule,
-      persistRule,
-    }
-  }
-}
-
-function formatToolParseError(err: unknown, toolName?: string): string {
-  const withToolHint = (message: string): string => {
-    if (toolName !== 'propose_private_continuity_edit') return message
-    return [
-      message,
-      'private continuity edit input requires `file` plus one complete edit mode.',
-      'The tool resolves the identity vault path; do not search workspace folders for SOUL.md or MEMORY.md.',
-      'For new memory/preferences, use {"file":"MEMORY.md","appendToSection":"Durable User Preferences","appendText":"- User preference or memory note."}',
-      'For persona or standing behavior, use {"file":"SOUL.md","appendToSection":"Persona","appendText":"- Persona or standing behavior note."}',
-      'Do not call propose_private_continuity_edit with empty input or file-only input.',
-    ].filter(Boolean).join('\n')
-  }
-
-  if (err instanceof ZodError) {
-    const missing: string[] = []
-    const invalid: string[] = []
-
-    for (const issue of err.issues) {
-      const field = issue.path.join('.') || 'input'
-      if (issue.code === 'invalid_type' && issue.received === 'undefined') {
-        missing.push(field)
-      } else {
-        invalid.push(`${field}: ${issue.message}`)
-      }
-    }
-
-    const parts: string[] = []
-    if (missing.length > 0) parts.push(`missing required fields: ${missing.join(', ')}`)
-    if (invalid.length > 0) parts.push(`invalid fields: ${invalid.join('; ')}`)
-    return withToolHint(parts.join('\n') || 'tool input did not match the required schema')
-  }
-
-  return withToolHint((err as Error).message || 'tool input did not match the required schema')
-}
-
-export type PendingToolUse = {
-  id: string
-  name: string
-  input: Record<string, unknown>
-}
-
-export type CompletedToolUse = {
-  id: string
-  name: string
-  input: Record<string, unknown>
-  result: ToolResult
-  cwd: string
-}
-
-type ExecuteToolResult = {
-  result: ToolResult
-  sessionRule?: SessionPermissionRule
-  persistRule?: boolean
-}
-
-export type ToolUseRunnerResult = {
-  cancelled: boolean
-  completedTools: CompletedToolUse[]
-}
-
-export async function runPendingToolUses(args: {
-  pendingToolUses: PendingToolUse[]
-  nextRowId: () => string
-  nowIso: () => string
-  mode: SessionMode
-  getCwd: () => string
-  getConfig: () => EthagentConfig
-  turnId?: string
-  controller: AbortController
-  updateRows: (updater: (prev: MessageRow[]) => MessageRow[]) => void
-  pushNote: (text: string, kind?: 'info' | 'error' | 'dim') => void
-  persistTurnMessage: (message: SessionMessage) => Promise<void>
-  executeTool: (
-    name: string,
-    input: Record<string, unknown>,
-    mode: ReturnType<typeof toPermissionMode>,
-  ) => Promise<ExecuteToolResult>
-  applySessionRule: (rule?: SessionPermissionRule, persistRule?: boolean) => Promise<void>
-}): Promise<ToolUseRunnerResult> {
-  const completedTools: CompletedToolUse[] = []
-
-  for (const toolUse of args.pendingToolUses) {
-    const rowId = args.nextRowId()
-    args.updateRows(prev => [
-      ...prev,
-      {
-        role: 'tool_call',
-        id: rowId,
-        name: toolUse.name,
-        summary: toolUse.name,
-        input: toolUse.input,
-      },
-    ])
-    await args.persistTurnMessage({
-      version: 2,
-      role: 'tool_use',
-      toolUseId: toolUse.id,
-      name: toolUse.name,
-      input: toolUse.input,
-      createdAt: args.nowIso(),
-      turnId: args.turnId,
-    })
-
-    const cwd = args.getCwd()
-    const { result, sessionRule, persistRule } = await args.executeTool(
-      toolUse.name,
-      toolUse.input,
-      toPermissionMode(args.mode),
-    )
-    completedTools.push({ ...toolUse, result, cwd })
-
-    if (args.controller.signal.aborted) {
-      return { cancelled: true, completedTools }
-    }
-
-    await args.applySessionRule(sessionRule, persistRule)
-    await recordToolResult(args, toolUse, result, rowId)
-  }
-
-  return { cancelled: false, completedTools }
-}
-
-async function recordToolResult(
-  args: Pick<
-    Parameters<typeof runPendingToolUses>[0],
-    'nextRowId' | 'nowIso' | 'turnId' | 'updateRows' | 'persistTurnMessage'
-  >,
-  toolUse: PendingToolUse,
-  result: ToolResult,
-  rowId: string,
-): Promise<void> {
-  const isError = !result.ok
-  const resultContent = toolResultContentForRow(toolUse.name, result.content, isError)
-  const diff = toolResultDiffForRow(result.content, isError)
-  args.updateRows(prev => prev.map(row =>
-    row.role === 'tool_call' && row.id === rowId
-      ? {
-          ...row,
-          result: diff
-            ? { content: resultContent, summary: result.summary, isError, diff }
-            : { content: resultContent, summary: result.summary, isError },
-        }
-      : row,
-  ))
-  await args.persistTurnMessage({
-    version: 2,
-    role: 'tool_result',
-    toolUseId: toolUse.id,
-    name: toolUse.name,
-    content: result.content,
-    isError,
-    createdAt: args.nowIso(),
-    turnId: args.turnId,
-  })
-}

package/src/runtime/toolIntent.ts

@@ -1,143 +0,0 @@
-import type { PendingToolUse } from './turn.js'
-import { unsupportedToolStateClaims, type ToolEvidence } from './toolClaimGuards.js'
-export { parseLocalModelTextToolUses as extractLocalTextToolUses } from './textToolParser.js'
-
-export type ToolIntent = {
-  name: string
-  input: Record<string, unknown>
-  reason: string
-}
-
-export function detectDirectToolIntent(userText: string): ToolIntent | null {
-  const uses = directToolUsesForUserText(userText)
-  if (uses.length === 0) return null
-  const first = uses[0]!
-  const reason = intentReason(first.name, first.input)
-  return { name: first.name, input: first.input, reason }
-}
-
-export function validateAssistantTextAgainstTurnEvidence(
-  text: string,
-  evidence: ToolEvidence[],
-): 'ok' | 'needs-tool' {
-  const unsupported = unsupportedToolStateClaims(text, evidence)
-  return unsupported.length > 0 ? 'needs-tool' : 'ok'
-}
-
-function intentReason(name: string, input: Record<string, unknown>): string {
-  switch (name) {
-    case 'change_directory':
-      return `user requested directory change to ${input.path ?? '.'}`
-    case 'list_directory':
-      return input.path ? `user requested listing of ${input.path}` : 'user requested directory listing'
-    case 'read_file':
-      return `user requested read of ${input.path ?? '<unknown>'}`
-    default:
-      return `user requested ${name}`
-  }
-}
-
-export function directToolUsesForUserText(userText: string, iterationIndex = 0): PendingToolUse[] {
-  const text = userText.trim()
-  if (!text || text.startsWith('/')) return []
-
-  const cdPath = parseChangeDirectoryIntent(text)
-  if (cdPath) {
-    return [{
-      id: `direct-tool-${iterationIndex}-0`,
-      name: 'change_directory',
-      input: { path: cdPath },
-    }]
-  }
-
-  const listPath = parseListDirectoryIntent(text)
-  if (listPath !== null) {
-    return [{
-      id: `direct-tool-${iterationIndex}-0`,
-      name: 'list_directory',
-      input: listPath ? { path: listPath } : {},
-    }]
-  }
-
-  const readPath = parseReadFileIntent(text)
-  if (readPath) {
-    return [{
-      id: `direct-tool-${iterationIndex}-0`,
-      name: 'read_file',
-      input: { path: readPath },
-    }]
-  }
-
-  return []
-}
-
-function parseChangeDirectoryIntent(text: string): string | null {
-  const normalized = trimCommandText(text)
-  const patterns = [
-    /^(?:no[, ]+)?(?:please\s+)?(?:now\s+)?(?:cd|chdir)\s+(?:to\s+|into\s+|in\s+)?(.+)$/i,
-    /^(?:no[, ]+)?(?:please\s+)?(?:now\s+)?go\s+(?:to|into|in)\s+(.+)$/i,
-    /^(?:no[, ]+)?(?:please\s+)?(?:now\s+)?change\s+(?:the\s+)?(?:current\s+)?(?:directory|folder)\s+(?:to|into)\s+(.+)$/i,
-  ]
-  return firstPathMatch(normalized, patterns)
-}
-
-function parseListDirectoryIntent(text: string): string | null {
-  const normalized = trimCommandText(text)
-  const patterns = [
-    /^(?:please\s+)?(?:ls|dir)$/i,
-    /^(?:please\s+)?(?:ls|dir)\s+(.+)$/i,
-    /^(?:please\s+)?(?:list|show)\s+(?:the\s+)?(?:files|directories|folders|entries)(?:\s+(?:in|inside|of)\s+(.+))?$/i,
-  ]
-  const match = firstPathMatch(normalized, patterns)
-  if (match) return match
-  return patterns.some(pattern => pattern.test(normalized)) ? '' : null
-}
-
-function parseReadFileIntent(text: string): string | null {
-  const normalized = trimCommandText(text)
-  const path = firstPathMatch(normalized, [
-    /^(?:please\s+)?(?:read|open|cat)\s+(.+)$/i,
-    /^(?:please\s+)?show\s+(?:me\s+)?(?:the\s+)?(?:contents\s+of\s+)?(.+)$/i,
-  ])
-  if (!path) return null
-  return looksLikeConcreteReadTarget(path) ? path : null
-}
-
-function firstPathMatch(text: string, patterns: RegExp[]): string | null {
-  for (const pattern of patterns) {
-    const match = text.match(pattern)
-    if (!match) continue
-    const raw = match[1]
-    if (raw === undefined) return ''
-    const cleaned = cleanPath(raw)
-    if (cleaned) return cleaned
-  }
-  return null
-}
-
-function trimCommandText(text: string): string {
-  return text
-    .trim()
-    .replace(/[.!?]+$/g, '')
-    .replace(/\s+/g, ' ')
-    .trim()
-}
-
-function cleanPath(value: string): string {
-  return value
-    .trim()
-    .replace(/^["'`]+|["'`]+$/g, '')
-    .replace(/\s+(?:please|now)$/i, '')
-    .trim()
-}
-
-function looksLikeConcreteReadTarget(path: string): boolean {
-  return path === '.'
-    || path.startsWith('~')
-    || path.startsWith('./')
-    || path.startsWith('../')
-    || /^[A-Za-z]:[\\/]/.test(path)
-    || path.includes('/')
-    || path.includes('\\')
-    || /\.[A-Za-z0-9]{1,12}$/.test(path)
-}