rird 1.0.200

package/src/tool/patch.ts

@@ -0,0 +1,233 @@
+import z from "zod"
+import * as path from "path"
+import * as fs from "fs/promises"
+import { Tool } from "./tool"
+import { FileTime } from "../file/time"
+import { Permission } from "../permission"
+import { Bus } from "../bus"
+import { FileWatcher } from "../file/watcher"
+import { Instance } from "../project/instance"
+import { Agent } from "../agent/agent"
+import { Patch } from "../patch"
+import { Filesystem } from "../util/filesystem"
+import { createTwoFilesPatch } from "diff"
+
+const PatchParams = z.object({
+  patchText: z.string().describe("The full patch text that describes all changes to be made"),
+})
+
+export const PatchTool = Tool.define("patch", {
+  description:
+    "Apply a patch to modify multiple files. Supports adding, updating, and deleting files with context-aware changes.",
+  parameters: PatchParams,
+  async execute(params, ctx) {
+    if (!params.patchText) {
+      throw new Error("patchText is required")
+    }
+
+    // Parse the patch to get hunks
+    let hunks: Patch.Hunk[]
+    try {
+      const parseResult = Patch.parsePatch(params.patchText)
+      hunks = parseResult.hunks
+    } catch (error) {
+      throw new Error(`Failed to parse patch: ${error}`)
+    }
+
+    if (hunks.length === 0) {
+      throw new Error("No file changes found in patch")
+    }
+
+    // Validate file paths and check permissions
+    const agent = await Agent.get(ctx.agent)
+    const fileChanges: Array<{
+      filePath: string
+      oldContent: string
+      newContent: string
+      type: "add" | "update" | "delete" | "move"
+      movePath?: string
+    }> = []
+
+    let totalDiff = ""
+
+    for (const hunk of hunks) {
+      const filePath = path.resolve(Instance.directory, hunk.path)
+
+      if (!Filesystem.contains(Instance.directory, filePath)) {
+        const parentDir = path.dirname(filePath)
+        if (agent.permission.external_directory === "ask") {
+          await Permission.ask({
+            type: "external_directory",
+            pattern: [parentDir, path.join(parentDir, "*")],
+            sessionID: ctx.sessionID,
+            messageID: ctx.messageID,
+            callID: ctx.callID,
+            title: `Patch file outside working directory: ${filePath}`,
+            metadata: {
+              filepath: filePath,
+              parentDir,
+            },
+          })
+        } else if (agent.permission.external_directory === "deny") {
+          throw new Permission.RejectedError(
+            ctx.sessionID,
+            "external_directory",
+            ctx.callID,
+            {
+              filepath: filePath,
+              parentDir,
+            },
+            `File ${filePath} is not in the current working directory`,
+          )
+        }
+      }
+
+      switch (hunk.type) {
+        case "add":
+          if (hunk.type === "add") {
+            const oldContent = ""
+            const newContent = hunk.contents
+            const diff = createTwoFilesPatch(filePath, filePath, oldContent, newContent)
+
+            fileChanges.push({
+              filePath,
+              oldContent,
+              newContent,
+              type: "add",
+            })
+
+            totalDiff += diff + "\n"
+          }
+          break
+
+        case "update":
+          // Check if file exists for update
+          const stats = await fs.stat(filePath).catch(() => null)
+          if (!stats || stats.isDirectory()) {
+            throw new Error(`File not found or is directory: ${filePath}`)
+          }
+
+          // Read file and update time tracking (like edit tool does)
+          await FileTime.assert(ctx.sessionID, filePath)
+          const oldContent = await fs.readFile(filePath, "utf-8")
+          let newContent = oldContent
+
+          // Apply the update chunks to get new content
+          try {
+            const fileUpdate = Patch.deriveNewContentsFromChunks(filePath, hunk.chunks)
+            newContent = fileUpdate.content
+          } catch (error) {
+            throw new Error(`Failed to apply update to ${filePath}: ${error}`)
+          }
+
+          const diff = createTwoFilesPatch(filePath, filePath, oldContent, newContent)
+
+          fileChanges.push({
+            filePath,
+            oldContent,
+            newContent,
+            type: hunk.move_path ? "move" : "update",
+            movePath: hunk.move_path ? path.resolve(Instance.directory, hunk.move_path) : undefined,
+          })
+
+          totalDiff += diff + "\n"
+          break
+
+        case "delete":
+          // Check if file exists for deletion
+          await FileTime.assert(ctx.sessionID, filePath)
+          const contentToDelete = await fs.readFile(filePath, "utf-8")
+          const deleteDiff = createTwoFilesPatch(filePath, filePath, contentToDelete, "")
+
+          fileChanges.push({
+            filePath,
+            oldContent: contentToDelete,
+            newContent: "",
+            type: "delete",
+          })
+
+          totalDiff += deleteDiff + "\n"
+          break
+      }
+    }
+
+    // Check permissions if needed
+    if (agent.permission.edit === "ask") {
+      await Permission.ask({
+        type: "edit",
+        sessionID: ctx.sessionID,
+        messageID: ctx.messageID,
+        callID: ctx.callID,
+        title: `Apply patch to ${fileChanges.length} files`,
+        metadata: {
+          diff: totalDiff,
+        },
+      })
+    }
+
+    // Apply the changes
+    const changedFiles: string[] = []
+
+    for (const change of fileChanges) {
+      switch (change.type) {
+        case "add":
+          // Create parent directories
+          const addDir = path.dirname(change.filePath)
+          if (addDir !== "." && addDir !== "/") {
+            await fs.mkdir(addDir, { recursive: true })
+          }
+          await fs.writeFile(change.filePath, change.newContent, "utf-8")
+          changedFiles.push(change.filePath)
+          break
+
+        case "update":
+          await fs.writeFile(change.filePath, change.newContent, "utf-8")
+          changedFiles.push(change.filePath)
+          break
+
+        case "move":
+          if (change.movePath) {
+            // Create parent directories for destination
+            const moveDir = path.dirname(change.movePath)
+            if (moveDir !== "." && moveDir !== "/") {
+              await fs.mkdir(moveDir, { recursive: true })
+            }
+            // Write to new location
+            await fs.writeFile(change.movePath, change.newContent, "utf-8")
+            // Remove original
+            await fs.unlink(change.filePath)
+            changedFiles.push(change.movePath)
+          }
+          break
+
+        case "delete":
+          await fs.unlink(change.filePath)
+          changedFiles.push(change.filePath)
+          break
+      }
+
+      // Update file time tracking
+      FileTime.read(ctx.sessionID, change.filePath)
+      if (change.movePath) {
+        FileTime.read(ctx.sessionID, change.movePath)
+      }
+    }
+
+    // Publish file change events
+    for (const filePath of changedFiles) {
+      await Bus.publish(FileWatcher.Event.Updated, { file: filePath, event: "change" })
+    }
+
+    // Generate output summary
+    const relativePaths = changedFiles.map((filePath) => path.relative(Instance.worktree, filePath))
+    const summary = `${fileChanges.length} files changed`
+
+    return {
+      title: summary,
+      metadata: {
+        diff: totalDiff,
+      },
+      output: `Patch applied successfully. ${summary}:\n${relativePaths.map((p) => `  ${p}`).join("\n")}`,
+    }
+  },
+})

package/src/tool/patch.txt

@@ -0,0 +1 @@
+do not use

package/src/tool/read.ts

@@ -0,0 +1,219 @@
+import z from "zod"
+import * as fs from "fs"
+import * as path from "path"
+import { Tool } from "./tool"
+import { LSP } from "../lsp"
+import { FileTime } from "../file/time"
+import DESCRIPTION from "./read.txt"
+import { Filesystem } from "../util/filesystem"
+import { Instance } from "../project/instance"
+import { Identifier } from "../id/id"
+import { Permission } from "../permission"
+import { Agent } from "@/agent/agent"
+import { iife } from "@/util/iife"
+
+const DEFAULT_READ_LIMIT = 2000
+const MAX_LINE_LENGTH = 2000
+
+export const ReadTool = Tool.define("read", {
+  description: DESCRIPTION,
+  parameters: z.object({
+    filePath: z.string().describe("The path to the file to read"),
+    offset: z.coerce.number().describe("The line number to start reading from (0-based)").optional(),
+    limit: z.coerce.number().describe("The number of lines to read (defaults to 2000)").optional(),
+  }),
+  async execute(params, ctx) {
+    let filepath = params.filePath
+    if (!path.isAbsolute(filepath)) {
+      filepath = path.join(process.cwd(), filepath)
+    }
+    const title = path.relative(Instance.worktree, filepath)
+    const agent = await Agent.get(ctx.agent)
+
+    if (!ctx.extra?.["bypassCwdCheck"] && !Filesystem.contains(Instance.directory, filepath)) {
+      const parentDir = path.dirname(filepath)
+      if (agent.permission.external_directory === "ask") {
+        await Permission.ask({
+          type: "external_directory",
+          pattern: [parentDir, path.join(parentDir, "*")],
+          sessionID: ctx.sessionID,
+          messageID: ctx.messageID,
+          callID: ctx.callID,
+          title: `Access file outside working directory: ${filepath}`,
+          metadata: {
+            filepath,
+            parentDir,
+          },
+        })
+      } else if (agent.permission.external_directory === "deny") {
+        throw new Permission.RejectedError(
+          ctx.sessionID,
+          "external_directory",
+          ctx.callID,
+          {
+            filepath: filepath,
+            parentDir,
+          },
+          `File ${filepath} is not in the current working directory`,
+        )
+      }
+    }
+
+    const block = iife(() => {
+      const basename = path.basename(filepath)
+      const whitelist = [".env.sample", ".env.example", ".example", ".env.template"]
+
+      if (whitelist.some((w) => basename.endsWith(w))) return false
+      // Block .env, .env.local, .env.production, etc. but not .envrc
+      if (/^\.env(\.|$)/.test(basename)) return true
+
+      return false
+    })
+
+    if (block) {
+      throw new Error(`The user has blocked you from reading ${filepath}, DO NOT make further attempts to read it`)
+    }
+
+    const file = Bun.file(filepath)
+    if (!(await file.exists())) {
+      const dir = path.dirname(filepath)
+      const base = path.basename(filepath)
+
+      const dirEntries = fs.readdirSync(dir)
+      const suggestions = dirEntries
+        .filter(
+          (entry) =>
+            entry.toLowerCase().includes(base.toLowerCase()) || base.toLowerCase().includes(entry.toLowerCase()),
+        )
+        .map((entry) => path.join(dir, entry))
+        .slice(0, 3)
+
+      if (suggestions.length > 0) {
+        throw new Error(`File not found: ${filepath}\n\nDid you mean one of these?\n${suggestions.join("\n")}`)
+      }
+
+      throw new Error(`File not found: ${filepath}`)
+    }
+
+    const isImage = file.type.startsWith("image/") && file.type !== "image/svg+xml"
+    const isPdf = file.type === "application/pdf"
+    if (isImage || isPdf) {
+      const mime = file.type
+      const msg = `${isImage ? "Image" : "PDF"} read successfully`
+      return {
+        title,
+        output: msg,
+        metadata: {
+          preview: msg,
+        },
+        attachments: [
+          {
+            id: Identifier.ascending("part"),
+            sessionID: ctx.sessionID,
+            messageID: ctx.messageID,
+            type: "file",
+            mime,
+            url: `data:${mime};base64,${Buffer.from(await file.bytes()).toString("base64")}`,
+          },
+        ],
+      }
+    }
+
+    const isBinary = await isBinaryFile(filepath, file)
+    if (isBinary) throw new Error(`Cannot read binary file: ${filepath}`)
+
+    const limit = params.limit ?? DEFAULT_READ_LIMIT
+    const offset = params.offset || 0
+    const lines = await file.text().then((text) => text.split("\n"))
+    const raw = lines.slice(offset, offset + limit).map((line) => {
+      return line.length > MAX_LINE_LENGTH ? line.substring(0, MAX_LINE_LENGTH) + "..." : line
+    })
+    const content = raw.map((line, index) => {
+      return `${(index + offset + 1).toString().padStart(5, "0")}| ${line}`
+    })
+    const preview = raw.slice(0, 20).join("\n")
+
+    let output = "<file>\n"
+    output += content.join("\n")
+
+    const totalLines = lines.length
+    const lastReadLine = offset + content.length
+    const hasMoreLines = totalLines > lastReadLine
+
+    if (hasMoreLines) {
+      output += `\n\n(File has more lines. Use 'offset' parameter to read beyond line ${lastReadLine})`
+    } else {
+      output += `\n\n(End of file - total ${totalLines} lines)`
+    }
+    output += "\n</file>"
+
+    // just warms the lsp client
+    LSP.touchFile(filepath, false)
+    FileTime.read(ctx.sessionID, filepath)
+
+    return {
+      title,
+      output,
+      metadata: {
+        preview,
+      },
+    }
+  },
+})
+
+async function isBinaryFile(filepath: string, file: Bun.BunFile): Promise<boolean> {
+  const ext = path.extname(filepath).toLowerCase()
+  // binary check for common non-text extensions
+  switch (ext) {
+    case ".zip":
+    case ".tar":
+    case ".gz":
+    case ".exe":
+    case ".dll":
+    case ".so":
+    case ".class":
+    case ".jar":
+    case ".war":
+    case ".7z":
+    case ".doc":
+    case ".docx":
+    case ".xls":
+    case ".xlsx":
+    case ".ppt":
+    case ".pptx":
+    case ".odt":
+    case ".ods":
+    case ".odp":
+    case ".bin":
+    case ".dat":
+    case ".obj":
+    case ".o":
+    case ".a":
+    case ".lib":
+    case ".wasm":
+    case ".pyc":
+    case ".pyo":
+      return true
+    default:
+      break
+  }
+
+  const stat = await file.stat()
+  const fileSize = stat.size
+  if (fileSize === 0) return false
+
+  const bufferSize = Math.min(4096, fileSize)
+  const buffer = await file.arrayBuffer()
+  if (buffer.byteLength === 0) return false
+  const bytes = new Uint8Array(buffer.slice(0, bufferSize))
+
+  let nonPrintableCount = 0
+  for (let i = 0; i < bytes.length; i++) {
+    if (bytes[i] === 0) return true
+    if (bytes[i] < 9 || (bytes[i] > 13 && bytes[i] < 32)) {
+      nonPrintableCount++
+    }
+  }
+  // If >30% non-printable characters, consider it binary
+  return nonPrintableCount / bytes.length > 0.3
+}

package/src/tool/read.txt

@@ -0,0 +1,12 @@
+Reads a file from the local filesystem. You can access any file directly by using this tool.
+Assume this tool is able to read all files on the machine. If the User provides a path to a file assume that path is valid. It is okay to read a file that does not exist; an error will be returned.
+
+Usage:
+- The filePath parameter must be an absolute path, not a relative path
+- By default, it reads up to 2000 lines starting from the beginning of the file
+- You can optionally specify a line offset and limit (especially handy for long files), but it's recommended to read the whole file by not providing these parameters
+- Any lines longer than 2000 characters will be truncated
+- Results are returned using cat -n format, with line numbers starting at 1
+- You have the capability to call multiple tools in a single response. It is always better to speculatively read multiple files as a batch that are potentially useful.
+- If you read a file that exists but has empty contents you will receive a system reminder warning in place of file contents.
+- You can read image files using this tool.

package/src/tool/registry.ts

@@ -0,0 +1,162 @@
+import { BashTool } from "./bash"
+import { EditTool } from "./edit"
+import { GlobTool } from "./glob"
+import { GrepTool } from "./grep"
+import { ListTool } from "./ls"
+import { BatchTool } from "./batch"
+import { ReadTool } from "./read"
+import { TaskTool } from "./task"
+import { TodoWriteTool, TodoReadTool } from "./todo"
+import { WebFetchTool } from "./webfetch"
+import { WriteTool } from "./write"
+import { InvalidTool } from "./invalid"
+import { SkillTool } from "./skill"
+import type { Agent } from "../agent/agent"
+import { Tool } from "./tool"
+import { Instance } from "../project/instance"
+import { Config } from "../config/config"
+import path from "path"
+import { type ToolDefinition } from "@opencode-ai/plugin"
+import z from "zod"
+import { Plugin } from "../plugin"
+import { WebSearchTool } from "./websearch"
+import { CodeSearchTool } from "./codesearch"
+import { Flag } from "@/flag/flag"
+import { Log } from "@/util/log"
+import { LspTool } from "./lsp"
+
+export namespace ToolRegistry {
+  const log = Log.create({ service: "tool.registry" })
+
+  export const state = Instance.state(async () => {
+    const custom = [] as Tool.Info[]
+    const glob = new Bun.Glob("tool/*.{js,ts}")
+
+    for (const dir of await Config.directories()) {
+      for await (const match of glob.scan({
+        cwd: dir,
+        absolute: true,
+        followSymlinks: true,
+        dot: true,
+      })) {
+        const namespace = path.basename(match, path.extname(match))
+        const mod = await import(match)
+        for (const [id, def] of Object.entries<ToolDefinition>(mod)) {
+          custom.push(fromPlugin(id === "default" ? namespace : `${namespace}_${id}`, def))
+        }
+      }
+    }
+
+    const plugins = await Plugin.list()
+    for (const plugin of plugins) {
+      for (const [id, def] of Object.entries(plugin.tool ?? {})) {
+        custom.push(fromPlugin(id, def))
+      }
+    }
+
+    return { custom }
+  })
+
+  function fromPlugin(id: string, def: ToolDefinition): Tool.Info {
+    return {
+      id,
+      init: async () => ({
+        parameters: z.object(def.args),
+        description: def.description,
+        execute: async (args, ctx) => {
+          const result = await def.execute(args as any, ctx)
+          return {
+            title: "",
+            output: result,
+            metadata: {},
+          }
+        },
+      }),
+    }
+  }
+
+  export async function register(tool: Tool.Info) {
+    const { custom } = await state()
+    const idx = custom.findIndex((t) => t.id === tool.id)
+    if (idx >= 0) {
+      custom.splice(idx, 1, tool)
+      return
+    }
+    custom.push(tool)
+  }
+
+  async function all(): Promise<Tool.Info[]> {
+    const custom = await state().then((x) => x.custom)
+    const config = await Config.get()
+
+    return [
+      InvalidTool,
+      BashTool,
+      ReadTool,
+      GlobTool,
+      GrepTool,
+      ListTool,
+      EditTool,
+      WriteTool,
+      TaskTool,
+      WebFetchTool,
+      TodoWriteTool,
+      TodoReadTool,
+      WebSearchTool,
+      CodeSearchTool,
+      SkillTool,
+      ...(Flag.RIRD_EXPERIMENTAL_LSP_TOOL ? [LspTool] : []),
+      ...(config.experimental?.batch_tool === true ? [BatchTool] : []),
+      ...custom,
+    ]
+  }
+
+  export async function ids() {
+    return all().then((x) => x.map((t) => t.id))
+  }
+
+  export async function tools(providerID: string, agent?: Agent.Info) {
+    const tools = await all()
+    const result = await Promise.all(
+      tools
+        .filter((t) => {
+          // Enable websearch/codesearch for zen users OR via enable flag
+          if (t.id === "codesearch" || t.id === "websearch") {
+            return providerID === "rird" || Flag.RIRD_ENABLE_EXA
+          }
+          return true
+        })
+        .map(async (t) => {
+          using _ = log.time(t.id)
+          return {
+            id: t.id,
+            ...(await t.init({ agent })),
+          }
+        }),
+    )
+    return result
+  }
+
+  export async function enabled(agent: Agent.Info): Promise<Record<string, boolean>> {
+    const result: Record<string, boolean> = {}
+
+    if (agent.permission.edit === "deny") {
+      result["edit"] = false
+      result["write"] = false
+    }
+    if (agent.permission.bash["*"] === "deny" && Object.keys(agent.permission.bash).length === 1) {
+      result["bash"] = false
+    }
+    if (agent.permission.webfetch === "deny") {
+      result["webfetch"] = false
+      result["codesearch"] = false
+      result["websearch"] = false
+    }
+    // Disable skill tool if all skills are denied
+    if (agent.permission.skill["*"] === "deny" && Object.keys(agent.permission.skill).length === 1) {
+      result["skill"] = false
+    }
+
+    return result
+  }
+}