@codeany/open-agent-sdk 0.2.1 → 0.2.3

package/src/tools/config-tool.ts

@@ -1,89 +0,0 @@
-/**
- * ConfigTool - Dynamic configuration management
- *
- * Get/set global configuration and session settings.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-// In-memory config store
-const configStore = new Map<string, unknown>()
-
-/**
- * Get a config value.
- */
-export function getConfig(key: string): unknown {
-  return configStore.get(key)
-}
-
-/**
- * Set a config value.
- */
-export function setConfig(key: string, value: unknown): void {
-  configStore.set(key, value)
-}
-
-/**
- * Clear all config.
- */
-export function clearConfig(): void {
-  configStore.clear()
-}
-
-export const ConfigTool: ToolDefinition = {
-  name: 'Config',
-  description: 'Get or set configuration values. Supports session-scoped settings.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ['get', 'set', 'list'],
-        description: 'Operation to perform',
-      },
-      key: { type: 'string', description: 'Config key' },
-      value: { description: 'Config value (for set)' },
-    },
-    required: ['action'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Manage configuration settings.' },
-  async call(input: any): Promise<ToolResult> {
-    switch (input.action) {
-      case 'get': {
-        if (!input.key) {
-          return { type: 'tool_result', tool_use_id: '', content: 'key required for get', is_error: true }
-        }
-        const value = configStore.get(input.key)
-        return {
-          type: 'tool_result',
-          tool_use_id: '',
-          content: value !== undefined ? JSON.stringify(value) : `Config key "${input.key}" not found`,
-        }
-      }
-      case 'set': {
-        if (!input.key) {
-          return { type: 'tool_result', tool_use_id: '', content: 'key required for set', is_error: true }
-        }
-        configStore.set(input.key, input.value)
-        return {
-          type: 'tool_result',
-          tool_use_id: '',
-          content: `Config set: ${input.key} = ${JSON.stringify(input.value)}`,
-        }
-      }
-      case 'list': {
-        const entries = Array.from(configStore.entries())
-        if (entries.length === 0) {
-          return { type: 'tool_result', tool_use_id: '', content: 'No config values set.' }
-        }
-        const lines = entries.map(([k, v]) => `${k} = ${JSON.stringify(v)}`)
-        return { type: 'tool_result', tool_use_id: '', content: lines.join('\n') }
-      }
-      default:
-        return { type: 'tool_result', tool_use_id: '', content: `Unknown action: ${input.action}`, is_error: true }
-    }
-  },
-}

package/src/tools/cron-tools.ts

@@ -1,153 +0,0 @@
-/**
- * Cron/Scheduling Tools
- *
- * CronCreate, CronDelete, CronList - Schedule recurring tasks.
- * RemoteTrigger - Manage remote scheduled agent triggers.
- */
-
-import type { ToolDefinition, ToolResult } from '../types.js'
-
-/**
- * Cron job definition.
- */
-export interface CronJob {
-  id: string
-  name: string
-  schedule: string // cron expression
-  command: string
-  enabled: boolean
-  createdAt: string
-  lastRunAt?: string
-  nextRunAt?: string
-}
-
-// In-memory cron store
-const cronStore = new Map<string, CronJob>()
-let cronCounter = 0
-
-/**
- * Get all cron jobs.
- */
-export function getAllCronJobs(): CronJob[] {
-  return Array.from(cronStore.values())
-}
-
-/**
- * Clear all cron jobs.
- */
-export function clearCronJobs(): void {
-  cronStore.clear()
-  cronCounter = 0
-}
-
-export const CronCreateTool: ToolDefinition = {
-  name: 'CronCreate',
-  description: 'Create a scheduled recurring task (cron job). Supports cron expressions for scheduling.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      name: { type: 'string', description: 'Job name' },
-      schedule: { type: 'string', description: 'Cron expression (e.g., "*/5 * * * *" for every 5 minutes)' },
-      command: { type: 'string', description: 'Command or prompt to execute' },
-    },
-    required: ['name', 'schedule', 'command'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Create a scheduled cron job.' },
-  async call(input: any): Promise<ToolResult> {
-    const id = `cron_${++cronCounter}`
-    const job: CronJob = {
-      id,
-      name: input.name,
-      schedule: input.schedule,
-      command: input.command,
-      enabled: true,
-      createdAt: new Date().toISOString(),
-    }
-    cronStore.set(id, job)
-
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `Cron job created: ${id} "${job.name}" schedule="${job.schedule}"`,
-    }
-  },
-}
-
-export const CronDeleteTool: ToolDefinition = {
-  name: 'CronDelete',
-  description: 'Delete a scheduled cron job.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      id: { type: 'string', description: 'Cron job ID to delete' },
-    },
-    required: ['id'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Delete a cron job.' },
-  async call(input: any): Promise<ToolResult> {
-    if (!cronStore.has(input.id)) {
-      return { type: 'tool_result', tool_use_id: '', content: `Cron job not found: ${input.id}`, is_error: true }
-    }
-    cronStore.delete(input.id)
-    return { type: 'tool_result', tool_use_id: '', content: `Cron job deleted: ${input.id}` }
-  },
-}
-
-export const CronListTool: ToolDefinition = {
-  name: 'CronList',
-  description: 'List all scheduled cron jobs.',
-  inputSchema: { type: 'object', properties: {} },
-  isReadOnly: () => true,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'List cron jobs.' },
-  async call(): Promise<ToolResult> {
-    const jobs = getAllCronJobs()
-    if (jobs.length === 0) {
-      return { type: 'tool_result', tool_use_id: '', content: 'No cron jobs scheduled.' }
-    }
-    const lines = jobs.map(j =>
-      `[${j.id}] ${j.enabled ? '✓' : '✗'} "${j.name}" schedule="${j.schedule}" command="${j.command.slice(0, 50)}"`
-    )
-    return { type: 'tool_result', tool_use_id: '', content: lines.join('\n') }
-  },
-}
-
-export const RemoteTriggerTool: ToolDefinition = {
-  name: 'RemoteTrigger',
-  description: 'Manage remote scheduled agent triggers. Supports list, get, create, update, and run operations.',
-  inputSchema: {
-    type: 'object',
-    properties: {
-      action: {
-        type: 'string',
-        enum: ['list', 'get', 'create', 'update', 'run'],
-        description: 'Operation to perform',
-      },
-      id: { type: 'string', description: 'Trigger ID (for get/update/run)' },
-      name: { type: 'string', description: 'Trigger name (for create)' },
-      schedule: { type: 'string', description: 'Cron schedule (for create/update)' },
-      prompt: { type: 'string', description: 'Agent prompt (for create/update)' },
-    },
-    required: ['action'],
-  },
-  isReadOnly: () => false,
-  isConcurrencySafe: () => true,
-  isEnabled: () => true,
-  async prompt() { return 'Manage remote agent triggers.' },
-  async call(input: any): Promise<ToolResult> {
-    // RemoteTrigger operations are typically handled by the remote backend
-    // In standalone SDK mode, we provide a stub implementation
-    return {
-      type: 'tool_result',
-      tool_use_id: '',
-      content: `RemoteTrigger ${input.action}: This feature requires a connected remote backend. In standalone SDK mode, use CronCreate/CronList/CronDelete for local scheduling.`,
-    }
-  },
-}

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`)
-        })
-      })
-    })
-  },
-})