@codeany/open-agent-sdk 0.2.2 → 0.2.3

package/src/tools/edit.ts

@@ -1,74 +0,0 @@
-/**
- * FileEditTool - Precise string replacement in files
- */
-
-import { readFile, writeFile } from 'fs/promises'
-import { resolve } from 'path'
-import { defineTool } from './types.js'
-
-export const FileEditTool = defineTool({
-  name: 'Edit',
-  description: 'Perform exact string replacements in files. The old_string must match exactly (including whitespace and indentation). Use replace_all to change every occurrence.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      file_path: {
-        type: 'string',
-        description: 'The absolute path to the file to modify',
-      },
-      old_string: {
-        type: 'string',
-        description: 'The exact text to find and replace',
-      },
-      new_string: {
-        type: 'string',
-        description: 'The replacement text',
-      },
-      replace_all: {
-        type: 'boolean',
-        description: 'Replace all occurrences (default false)',
-      },
-    },
-    required: ['file_path', 'old_string', 'new_string'],
-  },
-  isReadOnly: false,
-  isConcurrencySafe: false,
-  async call(input, context) {
-    const filePath = resolve(context.cwd, input.file_path)
-    const { old_string, new_string, replace_all } = input
-
-    if (old_string === new_string) {
-      return { data: 'Error: old_string and new_string are identical', is_error: true }
-    }
-
-    try {
-      let content = await readFile(filePath, 'utf-8')
-
-      if (!content.includes(old_string)) {
-        return { data: `Error: old_string not found in ${filePath}. Make sure it matches exactly including whitespace.`, is_error: true }
-      }
-
-      if (!replace_all) {
-        // Check uniqueness
-        const count = content.split(old_string).length - 1
-        if (count > 1) {
-          return {
-            data: `Error: old_string appears ${count} times in the file. Provide more context to make it unique, or set replace_all: true.`,
-            is_error: true,
-          }
-        }
-        content = content.replace(old_string, new_string)
-      } else {
-        content = content.split(old_string).join(new_string)
-      }
-
-      await writeFile(filePath, content, 'utf-8')
-      return `File edited: ${filePath}`
-    } catch (err: any) {
-      if (err.code === 'ENOENT') {
-        return { data: `Error: File not found: ${filePath}`, is_error: true }
-      }
-      return { data: `Error editing file: ${err.message}`, is_error: true }
-    }
-  },
-})

package/src/tools/glob.ts

@@ -1,77 +0,0 @@
-/**
- * GlobTool - File pattern matching
- */
-
-import { resolve } from 'path'
-import { defineTool } from './types.js'
-
-export const GlobTool = defineTool({
-  name: 'Glob',
-  description: 'Find files matching a glob pattern. Returns matching file paths sorted by modification time. Supports patterns like "**/*.ts", "src/**/*.js".',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      pattern: {
-        type: 'string',
-        description: 'The glob pattern to match files against',
-      },
-      path: {
-        type: 'string',
-        description: 'The directory to search in (defaults to cwd)',
-      },
-    },
-    required: ['pattern'],
-  },
-  isReadOnly: true,
-  isConcurrencySafe: true,
-  async call(input, context) {
-    const searchDir = input.path ? resolve(context.cwd, input.path) : context.cwd
-    const { pattern } = input
-
-    try {
-      // Use Node.js glob (available in Node 22+) or fall back to bash find
-      const { glob } = await import('fs/promises')
-
-      // @ts-ignore - glob is available in Node 22+
-      if (typeof glob === 'function') {
-        const matches: string[] = []
-        // @ts-ignore
-        for await (const entry of glob(pattern, { cwd: searchDir })) {
-          matches.push(entry)
-          if (matches.length >= 500) break
-        }
-        if (matches.length === 0) {
-          return `No files matching pattern "${pattern}" in ${searchDir}`
-        }
-        return matches.join('\n')
-      }
-    } catch {
-      // Fall through to bash-based approach
-    }
-
-    // Fallback: use bash find/glob
-    const { spawn } = await import('child_process')
-    return new Promise<string>((resolvePromise) => {
-      // Use bash glob expansion or find
-      const cmd = `shopt -s globstar nullglob 2>/dev/null; cd ${JSON.stringify(searchDir)} && ls -1d ${pattern} 2>/dev/null | head -500`
-      const proc = spawn('bash', ['-c', cmd], {
-        cwd: searchDir,
-        timeout: 30000,
-      })
-
-      const chunks: Buffer[] = []
-      proc.stdout?.on('data', (d: Buffer) => chunks.push(d))
-      proc.on('close', () => {
-        const result = Buffer.concat(chunks).toString('utf-8').trim()
-        if (!result) {
-          resolvePromise(`No files matching pattern "${pattern}" in ${searchDir}`)
-        } else {
-          resolvePromise(result)
-        }
-      })
-      proc.on('error', () => {
-        resolvePromise(`Error searching for files with pattern "${pattern}"`)
-      })
-    })
-  },
-})

package/src/tools/grep.ts

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

@@ -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'