@codeany/open-agent-sdk 0.2.2 → 0.2.3

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}` : ''}`,
-    }
-  },
-}

package/src/tools/read.ts

@@ -1,73 +0,0 @@
-/**
- * FileReadTool - Read file contents with line numbers
- */
-
-import { readFile, stat } from 'fs/promises'
-import { resolve } from 'path'
-import { defineTool } from './types.js'
-
-export const FileReadTool = defineTool({
-  name: 'Read',
-  description: 'Read a file from the filesystem. Returns content with line numbers. Supports text files, images (returns visual content), and PDFs.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      file_path: {
-        type: 'string',
-        description: 'The absolute path to the file to read',
-      },
-      offset: {
-        type: 'number',
-        description: 'Line number to start reading from (0-based)',
-      },
-      limit: {
-        type: 'number',
-        description: 'Maximum number of lines to read',
-      },
-    },
-    required: ['file_path'],
-  },
-  isReadOnly: true,
-  isConcurrencySafe: true,
-  async call(input, context) {
-    const filePath = resolve(context.cwd, input.file_path)
-
-    try {
-      const fileStat = await stat(filePath)
-      if (fileStat.isDirectory()) {
-        return { data: `Error: ${filePath} is a directory, not a file. Use Bash with 'ls' to list directory contents.`, is_error: true }
-      }
-
-      // Check for binary/image files
-      const ext = filePath.split('.').pop()?.toLowerCase()
-      if (['png', 'jpg', 'jpeg', 'gif', 'webp', 'bmp', 'svg'].includes(ext || '')) {
-        return `[Image file: ${filePath} (${fileStat.size} bytes)]`
-      }
-
-      const content = await readFile(filePath, 'utf-8')
-      const lines = content.split('\n')
-
-      const offset = input.offset || 0
-      const limit = input.limit || 2000
-      const selectedLines = lines.slice(offset, offset + limit)
-
-      // Format with line numbers (cat -n style)
-      const numbered = selectedLines.map((line: string, i: number) => {
-        const lineNum = offset + i + 1
-        return `${lineNum}\t${line}`
-      }).join('\n')
-
-      let result = numbered
-      if (lines.length > offset + limit) {
-        result += `\n\n(${lines.length - offset - limit} more lines not shown)`
-      }
-
-      return result || '(empty file)'
-    } catch (err: any) {
-      if (err.code === 'ENOENT') {
-        return { data: `Error: File not found: ${filePath}`, is_error: true }
-      }
-      return { data: `Error reading file: ${err.message}`, is_error: true }
-    }
-  },
-})

package/src/tools/send-message.ts

@@ -1,96 +0,0 @@
-/**
- * SendMessageTool - Inter-agent messaging
- *
- * Supports plain text and structured protocol messages
- * between teammates in a multi-agent setup.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-/**
- * Message inbox for inter-agent communication.
- */
-export interface AgentMessage {
-  from: string
-  to: string
-  content: string
-  timestamp: string
-  type: 'text' | 'shutdown_request' | 'shutdown_response' | 'plan_approval_response'
-}
-
-const mailboxes = new Map<string, AgentMessage[]>()
-
-/**
- * Read messages from a mailbox.
- */
-export function readMailbox(agentName: string): AgentMessage[] {
-  const messages = mailboxes.get(agentName) || []
-  mailboxes.set(agentName, []) // Clear after reading
-  return messages
-}
-
-/**
- * Write to a mailbox.
- */
-export function writeToMailbox(agentName: string, message: AgentMessage): void {
-  const messages = mailboxes.get(agentName) || []
-  messages.push(message)
-  mailboxes.set(agentName, messages)
-}
-
-/**
- * Clear all mailboxes.
- */
-export function clearMailboxes(): void {
-  mailboxes.clear()
-}
-
-export const SendMessageTool: ToolDefinition = {
-  name: 'SendMessage',
-  description: 'Send a message to another agent or teammate. Supports plain text and structured protocol messages.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      to: { type: 'string', description: 'Recipient agent name or ID. Use "*" for broadcast.' },
-      content: { type: 'string', description: 'Message content' },
-      type: {
-        type: 'string',
-        enum: ['text', 'shutdown_request', 'shutdown_response', 'plan_approval_response'],
-        description: 'Message type (default: text)',
-      },
-    },
-    required: ['to', 'content'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Send a message to another agent.' },
-  async call(input: any): Promise<ToolResult> {
-    const message: AgentMessage = {
-      from: 'self',
-      to: input.to,
-      content: input.content,
-      timestamp: new Date().toISOString(),
-      type: input.type || 'text',
-    }
-
-    if (input.to === '*') {
-      // Broadcast to all known mailboxes
-      for (const [name] of mailboxes) {
-        writeToMailbox(name, { ...message, to: name })
-      }
-      return {
-        type: 'tool_result',
-        tool_use_id: '',
-        content: `Message broadcast to all agents`,
-      }
-    }
-
-    writeToMailbox(input.to, message)
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Message sent to ${input.to}`,
-    }
-  },
-}