@bibobonking/opensol 0.0.0-stage → 3.0.2

package/src/core/plugins/tools/grep.ts

@@ -0,0 +1,98 @@
+import type { Context } from 'cordis'
+import { executeDaemonTool } from '../../../lib/daemon'
+import type { ToolResult } from '../../types'
+
+const MAX_TOOL_OUTPUT = 28_000
+
+function truncate(value: string, limit = MAX_TOOL_OUTPUT) {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {}
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function requireString(args: Record<string, unknown>, key: string): string {
+  const value = args[key]
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`Missing string argument "${key}".`)
+  return value
+}
+
+function optionalString(args: Record<string, unknown>, key: string): string | undefined {
+  const value = args[key]
+  return typeof value === 'string' ? value : undefined
+}
+
+function numberArg(args: Record<string, unknown>, key: string, fallback: number): number {
+  const value = args[key]
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && Number.isFinite(Number(value))) return Number(value)
+  return fallback
+}
+
+function formatGrep(result: Record<string, unknown>, pattern: string): string {
+  const matches = Array.isArray(result.matches) ? result.matches : []
+  if (matches.length === 0) return `No matches for ${pattern}.`
+  const lines = matches.map((raw) => {
+    const match = record(raw)
+    return `${textValue(match.file)}:${numberValue(match.line) ?? 0}: ${textValue(match.text)}`
+  })
+  const suffix = result.truncated === true ? '\n… more matches exist. Narrow the pattern or path.' : ''
+  return lines.join('\n') + suffix
+}
+
+export const name = 'tool-grep'
+export const inject = ['tools']
+
+export function apply(ctx: Context) {
+  return ctx.tools.register({
+    name: 'grep',
+    description: 'Search workspace contents with a regular expression. Returns path, line and matching text.',
+    parameters: {
+      type: 'object',
+      properties: {
+        pattern: { type: 'string', description: 'Regular expression to search for.' },
+        path: { type: 'string', description: 'File or folder. Defaults to the workspace root.' },
+        ignoreCase: { type: 'boolean', description: 'Case-insensitive search. Defaults to false.' },
+        maxResults: { type: 'number', description: 'Maximum matches. Defaults to 80.' },
+      },
+      required: ['pattern'],
+      additionalProperties: false,
+    },
+    allowedInMode: () => true,
+    async execute(args, exec): Promise<ToolResult> {
+      const pattern = requireString(args, 'pattern')
+      const result = record(
+        (
+          await executeDaemonTool(
+            'grep',
+            {
+              pattern,
+              path: optionalString(args, 'path') ?? '',
+              ignoreCase: args.ignoreCase === true,
+            },
+            exec.mode,
+            exec.signal,
+          )
+        ).result,
+      )
+      const maxResults = Math.min(Math.max(1, Math.round(numberArg(args, 'maxResults', 80))), 200)
+      const matches = Array.isArray(result.matches) ? result.matches.slice(0, maxResults) : []
+      const clipped = {
+        ...result,
+        matches,
+        truncated: result.truncated === true || (Array.isArray(result.matches) && result.matches.length > maxResults),
+      }
+      return { output: truncate(formatGrep(clipped, pattern)), isError: false }
+    },
+  })
+}

package/src/core/plugins/tools/shell.ts

@@ -0,0 +1,88 @@
+import type { Context } from 'cordis'
+import { executeDaemonTool } from '../../../lib/daemon'
+import { useWorkspace } from '../../../store/workspace'
+import type { ToolResult } from '../../types'
+
+const MAX_TOOL_OUTPUT = 28_000
+
+function truncate(value: string, limit = MAX_TOOL_OUTPUT) {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {}
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function numberValue(value: unknown): number | undefined {
+  return typeof value === 'number' && Number.isFinite(value) ? value : undefined
+}
+
+function requireString(args: Record<string, unknown>, key: string): string {
+  const value = args[key]
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`Missing string argument "${key}".`)
+  return value
+}
+
+function numberArg(args: Record<string, unknown>, key: string, fallback: number): number {
+  const value = args[key]
+  if (typeof value === 'number' && Number.isFinite(value)) return value
+  if (typeof value === 'string' && Number.isFinite(Number(value))) return Number(value)
+  return fallback
+}
+
+function formatShell(result: Record<string, unknown>, command: string): string {
+  const parts = [`$ ${command}`, textValue(result.stdout)]
+  if (textValue(result.stderr)) parts.push(`stderr:\n${textValue(result.stderr)}`)
+  const code = numberValue(result.code)
+  if (code !== undefined && code !== 0) parts.push(`exit code: ${code}`)
+  if (result.timedOut === true) parts.push('The command timed out.')
+  return parts.filter((part) => part !== '').join('\n')
+}
+
+async function refreshTree() {
+  await useWorkspace.getState().refresh({ treeOnly: true }).catch(() => undefined)
+}
+
+export const name = 'tool-shell'
+export const inject = ['tools']
+
+export function apply(ctx: Context) {
+  return ctx.tools.register({
+    name: 'shell',
+    description:
+      'Run a shell command in the workspace root. The working directory resets between calls. Prefer dedicated file and git tools for edits. In Plan mode only read-only commands are accepted.',
+    parameters: {
+      type: 'object',
+      properties: {
+        command: { type: 'string', description: 'The shell command to run.' },
+        timeoutMs: { type: 'number', description: 'Timeout in milliseconds (max 600000).' },
+      },
+      required: ['command'],
+      additionalProperties: false,
+    },
+    allowedInMode: () => true,
+    async execute(args, exec): Promise<ToolResult> {
+      const command = requireString(args, 'command')
+      const result = record(
+        (
+          await executeDaemonTool(
+            'shell',
+            { command, timeoutMs: numberArg(args, 'timeoutMs', 120_000) },
+            exec.mode,
+            exec.signal,
+          )
+        ).result,
+      )
+      void refreshTree()
+      return {
+        output: truncate(formatShell(result, command)),
+        isError: (numberValue(result.code) ?? 0) !== 0 || result.timedOut === true,
+      }
+    },
+  })
+}

package/src/core/plugins/tools/subagent.ts

@@ -0,0 +1,36 @@
+import type { Context } from 'cordis'
+import type { ToolResult } from '../../types'
+
+const MAX_TOOL_OUTPUT = 28_000
+
+function truncate(value: string, limit = MAX_TOOL_OUTPUT) {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
+}
+
+export const name = 'tool-subagent'
+export const inject = ['tools', 'subagents']
+
+export function apply(ctx: Context) {
+  return ctx.tools.register({
+    name: 'subagent',
+    description:
+      'Delegate a focused investigation to a read-only subagent. Use it to explore a large area, trace a bug or verify assumptions without changing files. The subagent returns a concise report.',
+    parameters: {
+      type: 'object',
+      properties: {
+        task: { type: 'string', description: 'The specific question or investigation to perform.' },
+        context: { type: 'string', description: 'Optional context, constraints or files to start from.' },
+      },
+      required: ['task'],
+      additionalProperties: false,
+    },
+    allowedInMode: () => true,
+    async execute(args, exec): Promise<ToolResult> {
+      const task = typeof args.task === 'string' ? args.task : ''
+      const context = typeof args.context === 'string' ? args.context : ''
+      const output = await ctx.subagents.run(task, context, exec.signal)
+      return { output: truncate(output), isError: false }
+    },
+  })
+}

package/src/core/plugins/tools/web.ts

@@ -0,0 +1,97 @@
+import type { Context } from 'cordis'
+import { executeDaemonTool } from '../../../lib/daemon'
+import type { ToolResult } from '../../types'
+
+const MAX_TOOL_OUTPUT = 28_000
+
+function truncate(value: string, limit = MAX_TOOL_OUTPUT) {
+  if (value.length <= limit) return value
+  return `${value.slice(0, limit)}\n… truncated (${value.length - limit} more characters)`
+}
+
+function record(value: unknown): Record<string, unknown> {
+  return value && typeof value === 'object' ? (value as Record<string, unknown>) : {}
+}
+
+function textValue(value: unknown): string {
+  return typeof value === 'string' ? value : ''
+}
+
+function requireString(args: Record<string, unknown>, key: string): string {
+  const value = args[key]
+  if (typeof value !== 'string' || !value.trim()) throw new Error(`Missing string argument "${key}".`)
+  return value
+}
+
+export const name = 'tool-web'
+export const inject = ['tools']
+
+export function apply(ctx: Context) {
+  const unregisters = [
+    ctx.tools.register({
+      name: 'web_search',
+      description: 'Search the web for current information. Returns titles, URLs and snippets. Cite URLs you use.',
+      parameters: {
+        type: 'object',
+        properties: {
+          query: { type: 'string', description: 'Search query.' },
+        },
+        required: ['query'],
+        additionalProperties: false,
+      },
+      allowedInMode: () => true,
+      async execute(args, exec): Promise<ToolResult> {
+        const query = requireString(args, 'query')
+        const result = record(
+          (
+            await executeDaemonTool(
+              'web_search',
+              { query, provider: exec.settings.searchProvider },
+              exec.mode,
+              exec.signal,
+            )
+          ).result,
+        )
+        const results = Array.isArray(result.results) ? result.results : []
+        if (results.length === 0) return { output: 'No results found.', isError: false }
+        const formatted = results
+          .map((raw, index) => {
+            const item = record(raw)
+            return `${index + 1}. ${textValue(item.title)}\n   ${textValue(item.url)}${textValue(item.snippet) ? `\n   ${textValue(item.snippet)}` : ''}`
+          })
+          .join('\n\n')
+        return {
+          output: truncate(`Search: ${query}\nProvider: ${textValue(result.provider) || 'web'}\n\n${formatted}`),
+          isError: false,
+        }
+      },
+    }),
+
+    ctx.tools.register({
+      name: 'read_url',
+      description: 'Read a public web page as plain text.',
+      parameters: {
+        type: 'object',
+        properties: {
+          url: { type: 'string', description: 'The http(s) URL to read.' },
+        },
+        required: ['url'],
+        additionalProperties: false,
+      },
+      allowedInMode: () => true,
+      async execute(args, exec): Promise<ToolResult> {
+        const url = requireString(args, 'url')
+        const result = record((await executeDaemonTool('read_url', { url }, exec.mode, exec.signal)).result)
+        const title = textValue(result.title)
+        return {
+          output: truncate(
+            `Source: ${textValue(result.url) || url}${title ? `\nTitle: ${title}` : ''}\n\n${textValue(result.content)}${result.truncated === true ? '\n\n… page truncated.' : ''}`,
+          ),
+          isError: false,
+        }
+      },
+    }),
+  ]
+
+  return () => unregisters.forEach((fn) => fn())
+}