@codeany/open-agent-sdk 0.1.0

package/src/tools/grep.ts

@@ -0,0 +1,168 @@
+/**
+ * GrepTool - Search file contents using regex
+ */
+
+import { spawn } from 'child_process'
+import { resolve } from 'path'
+import { defineTool } from './types.js'
+
+export const GrepTool = defineTool({
+  name: 'Grep',
+  description: 'Search file contents using regex patterns. Uses ripgrep (rg) if available, falls back to grep. Supports file type filtering and context lines.',
+  inputSchema: {
+    type: 'object',
+    properties: {
+      pattern: {
+        type: 'string',
+        description: 'The regex pattern to search for',
+      },
+      path: {
+        type: 'string',
+        description: 'File or directory to search in (defaults to cwd)',
+      },
+      glob: {
+        type: 'string',
+        description: 'Glob pattern to filter files (e.g., "*.ts", "*.{js,jsx}")',
+      },
+      type: {
+        type: 'string',
+        description: 'File type filter (e.g., "ts", "py", "js")',
+      },
+      output_mode: {
+        type: 'string',
+        enum: ['content', 'files_with_matches', 'count'],
+        description: 'Output mode (default: files_with_matches)',
+      },
+      '-i': {
+        type: 'boolean',
+        description: 'Case insensitive search',
+      },
+      '-n': {
+        type: 'boolean',
+        description: 'Show line numbers (default: true)',
+      },
+      '-A': { type: 'number', description: 'Lines after match' },
+      '-B': { type: 'number', description: 'Lines before match' },
+      '-C': { type: 'number', description: 'Context lines' },
+      context: { type: 'number', description: 'Context lines (alias for -C)' },
+      head_limit: { type: 'number', description: 'Limit output entries (default: 250)' },
+    },
+    required: ['pattern'],
+  },
+  isReadOnly: true,
+  isConcurrencySafe: true,
+  async call(input, context) {
+    const searchPath = input.path ? resolve(context.cwd, input.path) : context.cwd
+    const outputMode = input.output_mode || 'files_with_matches'
+    const headLimit = input.head_limit ?? 250
+
+    // Build rg command (fall back to grep if rg unavailable)
+    const args: string[] = []
+
+    // Try ripgrep first
+    let cmd = 'rg'
+
+    if (outputMode === 'files_with_matches') {
+      args.push('--files-with-matches')
+    } else if (outputMode === 'count') {
+      args.push('--count')
+    } else {
+      // content mode
+      if (input['-n'] !== false) args.push('--line-number')
+    }
+
+    if (input['-i']) args.push('--ignore-case')
+    if (input['-A']) args.push('-A', String(input['-A']))
+    if (input['-B']) args.push('-B', String(input['-B']))
+    const ctx = input['-C'] ?? input.context
+    if (ctx) args.push('-C', String(ctx))
+    if (input.glob) args.push('--glob', input.glob)
+    if (input.type) args.push('--type', input.type)
+
+    args.push('--', input.pattern, searchPath)
+
+    return new Promise<string>((resolvePromise) => {
+      const proc = spawn(cmd, args, {
+        cwd: context.cwd,
+        timeout: 30000,
+      })
+
+      const chunks: Buffer[] = []
+      const errChunks: Buffer[] = []
+      proc.stdout?.on('data', (d: Buffer) => chunks.push(d))
+      proc.stderr?.on('data', (d: Buffer) => errChunks.push(d))
+
+      proc.on('close', (code) => {
+        let result = Buffer.concat(chunks).toString('utf-8').trim()
+
+        if (!result && code !== 0) {
+          // Try fallback to grep
+          const grepArgs = ['-r']
+          if (input['-i']) grepArgs.push('-i')
+          if (outputMode === 'files_with_matches') grepArgs.push('-l')
+          if (outputMode === 'count') grepArgs.push('-c')
+          if (outputMode === 'content' && input['-n'] !== false) grepArgs.push('-n')
+          if (input.glob) grepArgs.push('--include', input.glob)
+          grepArgs.push('--', input.pattern, searchPath)
+
+          const grepProc = spawn('grep', grepArgs, {
+            cwd: context.cwd,
+            timeout: 30000,
+          })
+
+          const grepChunks: Buffer[] = []
+          grepProc.stdout?.on('data', (d: Buffer) => grepChunks.push(d))
+          grepProc.on('close', () => {
+            const grepResult = Buffer.concat(grepChunks).toString('utf-8').trim()
+            if (!grepResult) {
+              resolvePromise(`No matches found for pattern "${input.pattern}"`)
+            } else {
+              // Apply head limit
+              const lines = grepResult.split('\n')
+              if (headLimit > 0 && lines.length > headLimit) {
+                resolvePromise(lines.slice(0, headLimit).join('\n') + `\n... (${lines.length - headLimit} more)`)
+              } else {
+                resolvePromise(grepResult)
+              }
+            }
+          })
+          grepProc.on('error', () => {
+            resolvePromise(`No matches found for pattern "${input.pattern}"`)
+          })
+          return
+        }
+
+        if (!result) {
+          resolvePromise(`No matches found for pattern "${input.pattern}"`)
+          return
+        }
+
+        // Apply head limit
+        const lines = result.split('\n')
+        if (headLimit > 0 && lines.length > headLimit) {
+          result = lines.slice(0, headLimit).join('\n') + `\n... (${lines.length - headLimit} more)`
+        }
+
+        resolvePromise(result)
+      })
+
+      proc.on('error', () => {
+        // rg not found, try grep directly
+        const grepArgs = ['-r', '-n', '--', input.pattern, searchPath]
+        const grepProc = spawn('grep', grepArgs, {
+          cwd: context.cwd,
+          timeout: 30000,
+        })
+        const grepChunks: Buffer[] = []
+        grepProc.stdout?.on('data', (d: Buffer) => grepChunks.push(d))
+        grepProc.on('close', () => {
+          const grepResult = Buffer.concat(grepChunks).toString('utf-8').trim()
+          resolvePromise(grepResult || `No matches found for pattern "${input.pattern}"`)
+        })
+        grepProc.on('error', () => {
+          resolvePromise(`Error: neither rg nor grep available`)
+        })
+      })
+    })
+  },
+})

package/src/tools/index.ts

@@ -0,0 +1,232 @@
+/**
+ * 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'
+
+/**
+ * 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,
+]
+
+/**
+ * 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,
+}
+
+// Re-export helpers
+export { defineTool, toApiTool } from './types.js'

package/src/tools/lsp-tool.ts

@@ -0,0 +1,163 @@
+/**
+ * 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

@@ -0,0 +1,125 @@
+/**
+ * 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,
+      }
+    }
+  },
+}