@codeany/open-agent-sdk 0.2.1 → 0.2.3

package/src/tools/index.ts

@@ -1,240 +0,0 @@
-/**
- * Tool Registry - All built-in tool definitions
- *
- * 30+ tools covering file I/O, execution, search, web, agents,
- * tasks, teams, messaging, worktree, planning, scheduling, and more.
- */
-
-import type { ToolDefinition } from '../types.js'
-
-// File I/O
-import { BashTool } from './bash.js'
-import { FileReadTool } from './read.js'
-import { FileWriteTool } from './write.js'
-import { FileEditTool } from './edit.js'
-import { GlobTool } from './glob.js'
-import { GrepTool } from './grep.js'
-import { NotebookEditTool } from './notebook-edit.js'
-
-// Web
-import { WebFetchTool } from './web-fetch.js'
-import { WebSearchTool } from './web-search.js'
-
-// Agent & Multi-agent
-import { AgentTool } from './agent-tool.js'
-import { SendMessageTool } from './send-message.js'
-import { TeamCreateTool, TeamDeleteTool } from './team-tools.js'
-
-// Tasks
-import {
-  TaskCreateTool,
-  TaskListTool,
-  TaskUpdateTool,
-  TaskGetTool,
-  TaskStopTool,
-  TaskOutputTool,
-} from './task-tools.js'
-
-// Worktree
-import { EnterWorktreeTool, ExitWorktreeTool } from './worktree-tools.js'
-
-// Planning
-import { EnterPlanModeTool, ExitPlanModeTool } from './plan-tools.js'
-
-// User interaction
-import { AskUserQuestionTool } from './ask-user.js'
-
-// Discovery
-import { ToolSearchTool } from './tool-search.js'
-
-// MCP Resources
-import { ListMcpResourcesTool, ReadMcpResourceTool } from './mcp-resource-tools.js'
-
-// Scheduling
-import { CronCreateTool, CronDeleteTool, CronListTool, RemoteTriggerTool } from './cron-tools.js'
-
-// LSP
-import { LSPTool } from './lsp-tool.js'
-
-// Config
-import { ConfigTool } from './config-tool.js'
-
-// Todo
-import { TodoWriteTool } from './todo-tool.js'
-
-// Skill
-import { SkillTool } from './skill-tool.js'
-
-/**
- * All built-in tools (30+).
- */
-const ALL_TOOLS: ToolDefinition[] = [
-  // Core file I/O & execution
-  BashTool,
-  FileReadTool,
-  FileWriteTool,
-  FileEditTool,
-  GlobTool,
-  GrepTool,
-  NotebookEditTool,
-
-  // Web
-  WebFetchTool,
-  WebSearchTool,
-
-  // Agent & Multi-agent
-  AgentTool,
-  SendMessageTool,
-  TeamCreateTool,
-  TeamDeleteTool,
-
-  // Tasks
-  TaskCreateTool,
-  TaskListTool,
-  TaskUpdateTool,
-  TaskGetTool,
-  TaskStopTool,
-  TaskOutputTool,
-
-  // Worktree
-  EnterWorktreeTool,
-  ExitWorktreeTool,
-
-  // Planning
-  EnterPlanModeTool,
-  ExitPlanModeTool,
-
-  // User interaction
-  AskUserQuestionTool,
-
-  // Discovery
-  ToolSearchTool,
-
-  // MCP Resources
-  ListMcpResourcesTool,
-  ReadMcpResourceTool,
-
-  // Scheduling
-  CronCreateTool,
-  CronDeleteTool,
-  CronListTool,
-  RemoteTriggerTool,
-
-  // LSP
-  LSPTool,
-
-  // Config
-  ConfigTool,
-
-  // Todo
-  TodoWriteTool,
-
-  // Skill
-  SkillTool,
-]
-
-/**
- * Get all built-in tools.
- */
-export function getAllBaseTools(): ToolDefinition[] {
-  return [...ALL_TOOLS]
-}
-
-/**
- * Filter tools by allowed/disallowed lists.
- */
-export function filterTools(
-  tools: ToolDefinition[],
-  allowedTools?: string[],
-  disallowedTools?: string[],
-): ToolDefinition[] {
-  let filtered = tools
-
-  if (allowedTools && allowedTools.length > 0) {
-    const allowed = new Set(allowedTools)
-    filtered = filtered.filter((t) => allowed.has(t.name))
-  }
-
-  if (disallowedTools && disallowedTools.length > 0) {
-    const disallowed = new Set(disallowedTools)
-    filtered = filtered.filter((t) => !disallowed.has(t.name))
-  }
-
-  return filtered
-}
-
-/**
- * Assemble tool pool: base tools + MCP tools, with deduplication.
- */
-export function assembleToolPool(
-  baseTools: ToolDefinition[],
-  mcpTools: ToolDefinition[] = [],
-  allowedTools?: string[],
-  disallowedTools?: string[],
-): ToolDefinition[] {
-  const combined = [...baseTools, ...mcpTools]
-
-  // Deduplicate by name (later definitions override)
-  const byName = new Map<string, ToolDefinition>()
-  for (const tool of combined) {
-    byName.set(tool.name, tool)
-  }
-
-  let tools = Array.from(byName.values())
-  return filterTools(tools, allowedTools, disallowedTools)
-}
-
-// Re-export individual tools
-export {
-  // Core
-  BashTool,
-  FileReadTool,
-  FileWriteTool,
-  FileEditTool,
-  GlobTool,
-  GrepTool,
-  NotebookEditTool,
-  WebFetchTool,
-  WebSearchTool,
-  // Agent
-  AgentTool,
-  SendMessageTool,
-  TeamCreateTool,
-  TeamDeleteTool,
-  // Tasks
-  TaskCreateTool,
-  TaskListTool,
-  TaskUpdateTool,
-  TaskGetTool,
-  TaskStopTool,
-  TaskOutputTool,
-  // Worktree
-  EnterWorktreeTool,
-  ExitWorktreeTool,
-  // Planning
-  EnterPlanModeTool,
-  ExitPlanModeTool,
-  // User
-  AskUserQuestionTool,
-  // Discovery
-  ToolSearchTool,
-  // MCP
-  ListMcpResourcesTool,
-  ReadMcpResourceTool,
-  // Scheduling
-  CronCreateTool,
-  CronDeleteTool,
-  CronListTool,
-  RemoteTriggerTool,
-  // LSP
-  LSPTool,
-  // Config
-  ConfigTool,
-  // Todo
-  TodoWriteTool,
-  // Skill
-  SkillTool,
-}
-
-// Re-export helpers
-export { defineTool, toApiTool } from './types.js'

package/src/tools/lsp-tool.ts

@@ -1,163 +0,0 @@
-/**
- * LSPTool - Language Server Protocol integration
- *
- * Provides code intelligence: go-to-definition, find-references,
- * hover, document symbols, workspace symbols, etc.
- */
-
-import { execSync } from 'child_process'
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-export const LSPTool: ToolDefinition = {
-  name: 'LSP',
-  description: 'Language Server Protocol operations for code intelligence. Supports go-to-definition, find-references, hover, and symbol lookup.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      operation: {
-        type: 'string',
-        enum: [
-          'goToDefinition',
-          'findReferences',
-          'hover',
-          'documentSymbol',
-          'workspaceSymbol',
-          'goToImplementation',
-          'prepareCallHierarchy',
-          'incomingCalls',
-          'outgoingCalls',
-        ],
-        description: 'LSP operation to perform',
-      },
-      file_path: { type: 'string', description: 'File path for the operation' },
-      line: { type: 'number', description: 'Line number (0-based)' },
-      character: { type: 'number', description: 'Character position (0-based)' },
-      query: { type: 'string', description: 'Symbol name (for workspace symbol search)' },
-    },
-    required: ['operation'],
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Code intelligence via Language Server Protocol.' },
-  async call(input: any, context: { cwd: string }): Promise<ToolResult> {
-    const { operation, file_path, line, character, query } = input
-
-    // LSP requires a running language server. In standalone mode,
-    // we fall back to basic grep/ripgrep-based symbol lookup.
-    try {
-      switch (operation) {
-        case 'goToDefinition':
-        case 'goToImplementation': {
-          if (!file_path || line === undefined) {
-            return { type: 'tool_result', tool_use_id: '', content: 'file_path and line required', is_error: true }
-          }
-          // Use grep to find definition
-          const symbol = await getSymbolAtPosition(file_path, line, character || 0, context.cwd)
-          if (!symbol) {
-            return { type: 'tool_result', tool_use_id: '', content: 'Could not identify symbol at position' }
-          }
-          const results = execSync(
-            `rg -n "(?:function|class|interface|type|const|let|var|export)\\s+${symbol}" --type-add 'src:*.{ts,tsx,js,jsx,py,go,rs,java}' -t src ${context.cwd} 2>/dev/null || grep -rn "(?:function|class|interface|type|const|let|var|export)\\s*${symbol}" ${context.cwd} --include='*.ts' --include='*.js' 2>/dev/null`,
-            { encoding: 'utf-8', timeout: 10000 },
-          ).trim()
-          return { type: 'tool_result', tool_use_id: '', content: results || `No definition found for "${symbol}"` }
-        }
-
-        case 'findReferences': {
-          if (!file_path || line === undefined) {
-            return { type: 'tool_result', tool_use_id: '', content: 'file_path and line required', is_error: true }
-          }
-          const sym = await getSymbolAtPosition(file_path, line, character || 0, context.cwd)
-          if (!sym) {
-            return { type: 'tool_result', tool_use_id: '', content: 'Could not identify symbol at position' }
-          }
-          const refs = execSync(
-            `rg -n "${sym}" ${context.cwd} --type-add 'src:*.{ts,tsx,js,jsx,py,go,rs,java}' -t src 2>/dev/null | head -50`,
-            { encoding: 'utf-8', timeout: 10000 },
-          ).trim()
-          return { type: 'tool_result', tool_use_id: '', content: refs || `No references found for "${sym}"` }
-        }
-
-        case 'hover': {
-          return {
-            type: 'tool_result',
-            tool_use_id: '',
-            content: 'Hover information requires a running language server. Use Read tool to examine the file content.',
-          }
-        }
-
-        case 'documentSymbol': {
-          if (!file_path) {
-            return { type: 'tool_result', tool_use_id: '', content: 'file_path required', is_error: true }
-          }
-          const symbols = execSync(
-            `rg -n "^\\s*(export\\s+)?(function|class|interface|type|const|let|var|enum)\\s+" ${JSON.stringify(file_path)} 2>/dev/null || grep -n "^\\s*\\(export\\s\\+\\)\\?\\(function\\|class\\|interface\\|type\\|const\\|let\\|var\\|enum\\)\\s" ${JSON.stringify(file_path)} 2>/dev/null`,
-            { encoding: 'utf-8', cwd: context.cwd, timeout: 10000 },
-          ).trim()
-          return { type: 'tool_result', tool_use_id: '', content: symbols || 'No symbols found' }
-        }
-
-        case 'workspaceSymbol': {
-          if (!query) {
-            return { type: 'tool_result', tool_use_id: '', content: 'query required', is_error: true }
-          }
-          const wsSymbols = execSync(
-            `rg -n "${query}" ${context.cwd} --type-add 'src:*.{ts,tsx,js,jsx,py,go,rs,java}' -t src 2>/dev/null | head -30`,
-            { encoding: 'utf-8', timeout: 10000 },
-          ).trim()
-          return { type: 'tool_result', tool_use_id: '', content: wsSymbols || `No symbols found for "${query}"` }
-        }
-
-        default:
-          return {
-            type: 'tool_result',
-            tool_use_id: '',
-            content: `LSP operation "${operation}" requires a running language server.`,
-          }
-      }
-    } catch (err: any) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `LSP error: ${err.message}`,
-        is_error: true,
-      }
-    }
-  },
-}
-
-/**
- * Get the symbol at a given position in a file.
- */
-async function getSymbolAtPosition(
-  filePath: string,
-  line: number,
-  character: number,
-  cwd: string,
-): Promise<string | null> {
-  try {
-    const { readFile } = await import('fs/promises')
-    const { resolve } = await import('path')
-    const content = await readFile(resolve(cwd, filePath), 'utf-8')
-    const lines = content.split('\n')
-
-    if (line >= lines.length) return null
-
-    const lineText = lines[line]
-    if (!lineText || character >= lineText.length) return null
-
-    // Extract word at position
-    const wordMatch = /\b\w+\b/g
-    let match
-    while ((match = wordMatch.exec(lineText)) !== null) {
-      if (match.index <= character && match.index + match[0].length >= character) {
-        return match[0]
-      }
-    }
-
-    return null
-  } catch {
-    return null
-  }
-}

package/src/tools/mcp-resource-tools.ts

@@ -1,125 +0,0 @@
-/**
- * MCP Resource Tools
- *
- * ListMcpResources / ReadMcpResource - Access resources from MCP servers.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-import type { MCPConnection } from '../mcp/client.js'
-
-// Registry of MCP connections (set by the agent)
-let mcpConnections: MCPConnection[] = []
-
-/**
- * Set MCP connections for resource access.
- */
-export function setMcpConnections(connections: MCPConnection[]): void {
-  mcpConnections = connections
-}
-
-export const ListMcpResourcesTool: ToolDefinition = {
-  name: 'ListMcpResources',
-  description: 'List available resources from connected MCP servers. Resources can include files, databases, and other data sources.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      server: { type: 'string', description: 'Filter by MCP server name' },
-    },
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'List MCP resources.' },
-  async call(input: any): Promise<ToolResult> {
-    const connections = input.server
-      ? mcpConnections.filter(c => c.name === input.server)
-      : mcpConnections
-
-    if (connections.length === 0) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: 'No MCP servers connected.',
-      }
-    }
-
-    const results: string[] = []
-
-    for (const conn of connections) {
-      if (conn.status !== 'connected') continue
-
-      try {
-        // Access the underlying client to list resources
-        const resources = (conn as any)._client?.listResources?.()
-        if (resources) {
-          results.push(`Server: ${conn.name}`)
-          for (const r of resources) {
-            results.push(`  - ${r.name}: ${r.description || r.uri || ''}`)
-          }
-        } else {
-          results.push(`Server: ${conn.name} (${conn.tools.length} tools available)`)
-        }
-      } catch {
-        results.push(`Server: ${conn.name} (resource listing not supported)`)
-      }
-    }
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: results.join('\n') || 'No resources found.',
-    }
-  },
-}
-
-export const ReadMcpResourceTool: ToolDefinition = {
-  name: 'ReadMcpResource',
-  description: 'Read a specific resource from an MCP server.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      server: { type: 'string', description: 'MCP server name' },
-      uri: { type: 'string', description: 'Resource URI to read' },
-    },
-    required: ['server', 'uri'],
-  },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Read an MCP resource.' },
-  async call(input: any): Promise<ToolResult> {
-    const conn = mcpConnections.find(c => c.name === input.server)
-    if (!conn) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `MCP server not found: ${input.server}`,
-        is_error: true,
-      }
-    }
-
-    try {
-      const result = await (conn as any)._client?.readResource?.({ uri: input.uri })
-      if (result?.contents) {
-        const texts = result.contents.map((c: any) => c.text || JSON.stringify(c)).join('\n')
-        return {
-          type: 'tool_result',
-          tool_use_id: '',
-          content: texts,
-        }
-      }
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: 'Resource read returned no content.',
-      }
-    } catch (err: any) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Error reading resource: ${err.message}`,
-        is_error: true,
-      }
-    }
-  },
-}

package/src/tools/notebook-edit.ts

@@ -1,93 +0,0 @@
-/**
- * NotebookEditTool - Edit Jupyter notebooks
- */
-
-import { readFile, writeFile } from 'fs/promises'
-import { resolve } from 'path'
-import { defineTool } from './types.js'
-
-export const NotebookEditTool = defineTool({
-  name: 'NotebookEdit',
-  description: 'Edit Jupyter notebook (.ipynb) cells. Can insert, replace, or delete cells.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      file_path: {
-        type: 'string',
-        description: 'Path to the .ipynb file',
-      },
-      command: {
-        type: 'string',
-        enum: ['insert', 'replace', 'delete'],
-        description: 'The edit operation to perform',
-      },
-      cell_number: {
-        type: 'number',
-        description: 'Cell index (0-based) to operate on',
-      },
-      cell_type: {
-        type: 'string',
-        enum: ['code', 'markdown'],
-        description: 'Type of cell (for insert/replace)',
-      },
-      source: {
-        type: 'string',
-        description: 'Cell content (for insert/replace)',
-      },
-    },
-    required: ['file_path', 'command', 'cell_number'],
-  },
-  isReadOnly: false,
-  isConcurrencySafe: false,
-  async call(input, context) {
-    const filePath = resolve(context.cwd, input.file_path)
-
-    try {
-      const content = await readFile(filePath, 'utf-8')
-      const notebook = JSON.parse(content)
-
-      if (!notebook.cells || !Array.isArray(notebook.cells)) {
-        return { data: 'Error: Invalid notebook format', is_error: true }
-      }
-
-      const { command, cell_number, cell_type, source } = input
-
-      switch (command) {
-        case 'insert': {
-          const newCell = {
-            cell_type: cell_type || 'code',
-            source: (source || '').split('\n').map((l: string, i: number, arr: string[]) =>
-              i < arr.length - 1 ? l + '\n' : l
-            ),
-            metadata: {},
-            ...(cell_type !== 'markdown' ? { outputs: [], execution_count: null } : {}),
-          }
-          notebook.cells.splice(cell_number, 0, newCell)
-          break
-        }
-        case 'replace': {
-          if (cell_number >= notebook.cells.length) {
-            return { data: `Error: Cell ${cell_number} does not exist`, is_error: true }
-          }
-          notebook.cells[cell_number].source = (source || '').split('\n').map(
-            (l: string, i: number, arr: string[]) => i < arr.length - 1 ? l + '\n' : l
-          )
-          if (cell_type) notebook.cells[cell_number].cell_type = cell_type
-          break
-        }
-        case 'delete': {
-          if (cell_number >= notebook.cells.length) {
-            return { data: `Error: Cell ${cell_number} does not exist`, is_error: true }
-          }
-          notebook.cells.splice(cell_number, 1)
-          break
-        }
-      }
-
-      await writeFile(filePath, JSON.stringify(notebook, null, 1), 'utf-8')
-      return `Notebook ${command}: cell ${cell_number} in ${filePath}`
-    } catch (err: any) {
-      return { data: `Error: ${err.message}`, is_error: true }
-    }
-  },
-})

package/src/tools/plan-tools.ts

@@ -1,88 +0,0 @@
-/**
- * Plan Mode Tools
- *
- * EnterPlanMode / ExitPlanMode - Structured planning workflow.
- * Allows the agent to enter a design/planning phase before execution.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-// Track plan mode state
-let planModeActive = false
-let currentPlan: string | null = null
-
-export function isPlanModeActive(): boolean {
-  return planModeActive
-}
-
-export function getCurrentPlan(): string | null {
-  return currentPlan
-}
-
-export const EnterPlanModeTool: ToolDefinition = {
-  name: 'EnterPlanMode',
-  description: 'Enter plan/design mode for complex tasks. In plan mode, the agent focuses on designing the approach before executing.',
-  inputSchema: {
-    type: 'object',
-    properties: {},
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => true,
-  async prompt() { return 'Enter plan mode for structured planning.' },
-  async call(): Promise<ToolResult> {
-    if (planModeActive) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: 'Already in plan mode.',
-      }
-    }
-
-    planModeActive = true
-    currentPlan = null
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: 'Entered plan mode. Design your approach before executing. Use ExitPlanMode when the plan is ready.',
-    }
-  },
-}
-
-export const ExitPlanModeTool: ToolDefinition = {
-  name: 'ExitPlanMode',
-  description: 'Exit plan mode with a completed plan. The plan will be recorded and execution can proceed.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      plan: { type: 'string', description: 'The completed plan' },
-      approved: { type: 'boolean', description: 'Whether the plan is approved for execution' },
-    },
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => false,
-  isEnabled: () => true,
-  async prompt() { return 'Exit plan mode with a completed plan.' },
-  async call(input: any): Promise<ToolResult> {
-    if (!planModeActive) {
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: 'Not in plan mode.',
-        is_error: true,
-      }
-    }
-
-    planModeActive = false
-    currentPlan = input.plan || null
-
-    const status = input.approved !== false ? 'approved' : 'pending approval'
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Plan mode exited. Plan status: ${status}.${currentPlan ? `\n\nPlan:\n${currentPlan}` : ''}`,
-    }
-  },
-}