opencode-ai-cli 1.17.0

package/src/tools/grep-tool.ts

@@ -0,0 +1,100 @@
+import { rgPath } from "@vscode/ripgrep";
+
+import { promisify } from "node:util";
+import { execFile } from "node:child_process";
+import { AgentTool } from "../types";
+
+const execFileAsync = promisify(execFile);
+
+export const grepTool: AgentTool = {
+  name: "grep",
+  label: "find text",
+  description: "Search for specific text inside files using ripgrep.",
+  schema: {
+    type: "function",
+    function: {
+      name: "grep",
+      description:
+        "Search for a specific string or regex pattern inside files in a directory. Uses ripgrep so it respects .gitignore.",
+      parameters: {
+        type: "object",
+        properties: {
+          pattern: {
+            type: "string",
+            description: "The text or regex pattern to search for.",
+          },
+          dirPath: {
+            type: "string",
+            description:
+              "The directory to search in. Default is current directory '.'.",
+          },
+        },
+        required: ["pattern"],
+      },
+    },
+  },
+  execute: async (agrs: any) => {
+    try {
+      const pattern = agrs.pattern;
+      const targetPath = agrs.dirPath || ".";
+
+      console.log(
+        `\n system runing 'grep' for pattern ${pattern} in ${targetPath}`,
+      );
+
+      let stdout = "";
+
+      try {
+        // execFile bypasses the shell entirely, so we don't have to worry about
+        // escaping quotes or bash syntax errors!
+        const result = await execFileAsync(rgPath, [
+          "-n",
+          "-i",
+          pattern,
+          targetPath,
+        ]);
+        stdout = result.stdout;
+      } catch (execError: any) {
+        if (execError.code === 1) {
+          return {
+            content: [
+              { type: "text", text: `No matches found for text: ${pattern}` },
+            ],
+            details: {},
+          };
+        }
+        throw execError;
+      }
+
+      if (!stdout.trim()) {
+        return {
+          content: [
+            { type: "text", text: `No matches found for text: ${pattern}` },
+          ],
+          details: {},
+        };
+      }
+
+      const lines = stdout.split("\n");
+      const limit = 50;
+      let output = lines.slice(0, limit).join("\n");
+
+      if (lines.length > limit) {
+        output += `\n\n[Warning: Output truncated. ${lines.length} lines found, showing first ${limit}.]`;
+      }
+
+      return {
+        content: [{ type: "text", text: output }],
+        details: {},
+      };
+    } catch (error: any) {
+      console.error(`grep tool error ${error.message}`);
+      return {
+        content: [
+          { type: "text", text: `Failed to excuate grep: ${error.message}` },
+        ],
+        details: {},
+      };
+    }
+  },
+};

package/src/tools/index.ts

@@ -0,0 +1,37 @@
+
+import { weatherTool } from "./weather-tool";
+import { lsTool } from "./ls-tool";
+import { findTool } from "./find-tool";
+import { grepTool } from "./grep-tool";
+import { readTool } from "./read-tool";
+import { planTool } from "./plan-tool";
+import { nativeSubagentTool } from "../subagent/index";
+import { bashTool } from "./bash-tool";
+import { writeTool } from "./write-tool";
+import { editTool } from "./edit-tool";
+import { AgentTool } from "../types";
+
+export { weatherTool, lsTool };
+
+export function getAllTools(): AgentTool[] {
+  return [
+    weatherTool,
+    lsTool,
+    findTool,
+    grepTool,
+    readTool,
+    planTool,
+    nativeSubagentTool,
+    bashTool,
+    writeTool,
+    editTool
+  ];
+}
+
+export function getOrchestratorTools(): AgentTool[] {
+  return getAllTools();
+}
+
+export function getReadOnlyTools(): AgentTool[] {
+  return [lsTool, findTool, grepTool, readTool];
+}

package/src/tools/ls-tool.ts

@@ -0,0 +1,93 @@
+import fs from "node:fs/promises";
+import { AgentTool } from "../types";
+import path from "node:path";
+
+export const lsTool: AgentTool = {
+  name: "ls",
+  label: "List Directory",
+  description:
+    "List directory contents for a SINGLE folder. DO NOT use this for deep recursive searching or finding specificfile types. Use the 'find' tool instead.",
+  schema: {
+    type: "function",
+    function: {
+      name: "ls",
+      description:
+        "List directory contents for a SINGLE folder. DO NOT use this for deep recursive searching or finding specific file types. Use the 'find' tool instead.",
+      parameters: {
+        type: "object",
+        properties: {
+          dirPath: {
+            type: "string",
+            description:
+              "The directory path to list (e.g., '.', './src', '/Users/vibhu/'). Default is '.'.",
+          },
+        },
+        required: [],
+      },
+    },
+  },
+
+  execute: async (args: any) => {
+    try {
+      const targetPath = args.dirPath || ".";
+
+      console.log(`\n system runing ls for : ${targetPath}...`);
+
+      try {
+        await fs.access(targetPath);
+      } catch (error) {
+        throw new Error(`Path not found : ${targetPath}`);
+      }
+
+      const start = await fs.stat(targetPath);
+      if (!start.isDirectory()) {
+        throw new Error(`it is not a directory : ${targetPath}`);
+      }
+
+      const entires = await fs.readdir(targetPath);
+
+      // Sort alphabetically
+      entires.sort((a, b) => a.toLowerCase().localeCompare(b.toLowerCase()));
+
+      const result: string[] = [];
+
+      for (const entry of entires) {
+        const fullPath = path.join(targetPath, entry);
+
+        try {
+          const entryStart = await fs.stat(fullPath);
+
+          if (entryStart.isDirectory()) {
+            result.push(entry + "/");
+          } else {
+            result.push(entry);
+          }
+        } catch (error) {
+          // skip entries we cant read it
+          result.push(entry);
+        }
+      }
+
+      if (result.length === 0) {
+        return {
+          content: [{ type: "text", text: "(empty directory" }],
+          details: {},
+        };
+      }
+
+      const outputString = result.join("\n");
+      return {
+        content: [{ type: "text", text: outputString }],
+        details: {},
+      };
+    } catch (error: any) {
+      console.error(`Ls tool error ${error.message}`);
+      return {
+        content: [
+          { type: "text", text: `Failed to list directory: ${error.message}` },
+        ],
+        details: {},
+      };
+    }
+  },
+};

package/src/tools/plan-tool.ts

@@ -0,0 +1,35 @@
+import { AgentTool, AgentToolResult } from "../types";
+
+export const planTool: AgentTool = {
+  name: "propose_plan",
+  label: "Propose Plan",
+  description:
+    "CRITICAL: Orchestrator only. Do NOT call this tool until a scout subagent has thoroughly explored the codebase and returned evidence. Use this tool to propose a step-by-step plan for the user to review BEFORE executing mutating work.",
+  schema: {
+    type: "function",
+    function: {
+      name: "propose_plan",
+      description: "CRITICAL: Must ONLY be called AFTER the scout subagent has researched the codebase. Propose a step-by-step plan.",
+      parameters: {
+        type: "object",
+        properties: {
+          steps: {
+            type: "array",
+            items: {
+              type: "string",
+            },
+            description:
+              "An array of detailed steps explaining what you plan to do. Mention which steps are read-only and which steps require user approval because they edit, write, delete, or run mutating commands.",
+          },
+        },
+        required: ["steps"],
+      },
+    },
+  },
+  execute: async (args: any): Promise<AgentToolResult> => {
+    return {
+      content: [{ type: "text", text: JSON.stringify(args) }],
+      terminate: true,
+    };
+  },
+};

package/src/tools/read-tool.ts

@@ -0,0 +1,89 @@
+import { AgentTool } from "../types";
+import fs from "node:fs/promises";
+import path from "node:path";
+import { truncateByBytes } from "./truncate";
+
+export const readTool: AgentTool = {
+  name: "read_file",
+  label: "Read File",
+  description: "Read the text contents of a file.",
+  schema: {
+    type: "function",
+    function: {
+      name: "read_file",
+      description:
+        "Read the contents of a file. Use offset and limit for large files.",
+      parameters: {
+        type: "object",
+        properties: {
+          path: { type: "string" },
+          offset: { type: "number" },
+          limit: { type: "number" },
+        },
+
+        required: ["path"],
+      },
+    },
+  },
+
+  execute: async (args: any) => {
+    try {
+      const rawPath = args.path;
+      const offset = args.offset || 1;
+      const limit = args.limit || 500;
+
+      const filePath = path.resolve(process.cwd(), rawPath);
+      if (!filePath.startsWith(process.cwd())) {
+        throw new Error(`Permission denied: Cannot read file outside of project directory: ${rawPath}`);
+      }
+
+      console.log(`\n system runing 'read' for pattern ${rawPath}`);
+
+      await fs.access(filePath);
+
+      // read the file contents
+      const content = await fs.readFile(filePath, "utf-8");
+
+      const allLines = content.split("\n");
+      const totalLine = allLines.length;
+
+      const startIndex = Math.max(0, offset - 1);
+
+      if (startIndex >= totalLine) {
+        throw new Error(
+          `offset ${offset} is beyond the file lines ${totalLine} line total`,
+        );
+      }
+
+      // apply the limit
+      const endIndex = Math.min(startIndex + limit, totalLine);
+
+      const selectedContent = allLines.slice(startIndex, endIndex).join("\n");
+
+      let outputText = selectedContent;
+
+      if (endIndex < totalLine) {
+        const nextOffset = endIndex + 1;
+
+        outputText += `\n\n [Warning:file truncated.  more line in the file, use offset=${nextOffset} to read next chunk ]`;
+      }
+      const safeOutput = truncateByBytes(outputText);
+
+      return {
+        content: [{ type: "text", text: safeOutput }],
+        details: {},
+      };
+    } catch (error: any) {
+      console.error(`read_file tool error ${error.message}`);
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Failed to excuate read_file: ${error.message}`,
+          },
+        ],
+        details: {},
+      };
+    }
+  },
+};

package/src/tools/truncate.ts

@@ -0,0 +1,21 @@
+
+const default_max_byte = 50 * 1024;
+
+
+export function truncateByBytes(text: string, maxBytes: number = default_max_byte): string {
+
+  const buffer = Buffer.from(text, "utf-8");
+
+  if (buffer.length <= maxBytes) {
+    return text;
+    
+  }
+
+
+  const truncatedBuffer = buffer.subarray(0, maxBytes);
+
+  const safeString = truncatedBuffer.toString('utf-8');
+
+  return safeString + `\n\n [System Warning: File was too massive. It was brutally truncated at ${maxBytes / 1024}KB to prevent LLM
+        memory overload.]`
+}

package/src/tools/weather-tool.ts

@@ -0,0 +1,55 @@
+import type { AgentTool, AgentToolResult } from "../types";
+
+export const weatherTool: AgentTool = {
+  name: "get_current_weather",
+  label: "Weather",
+  description: "Gets the current weather for a specific city.",
+
+  schema: {
+    type: "function",
+    function: {
+      name: "get_current_weather",
+      description:
+        "Gets the current weather for a specific city. Use this when the user asks for weather conditions.",
+      parameters: {
+        type: "object",
+        properties: {
+          location: {
+            type: "string",
+            description: "The city name, e.g., Delhi, London",
+          },
+        },
+        required: ["location"],
+      },
+    },
+  },
+
+  execute: async (args: any): Promise<AgentToolResult> => {
+    try {
+      console.log(" args from Openaai:", JSON.stringify(args));
+      console.log(`\n[system] running whether tool for : ${args.location}...`);
+      const response = await fetch(
+        `https://api.openweathermap.org/data/2.5/weather?q=${args.location}&appid=bd5e378503939ddaee76f12ad7a97608&units=metric`,
+        {
+          method: "GET",
+          headers: {
+            "Content-Type": "application/json",
+          },
+        },
+      );
+
+      const result = await response.json();
+
+      const wheaterString = `The current wheater in ${args.location} is ${result.main.temp} C and ${result.weather[0].description}.`;
+      return {
+        content: [{ type: "text", text: wheaterString }],
+        details: {},
+      };
+    } catch (error) {
+      return {
+        content: [{ type: "text", text: "Failed to get weather from API." }],
+        details: {},
+      };
+    }
+  },
+};

package/src/tools/write-tool.ts

@@ -0,0 +1,53 @@
+import * as fs from "fs/promises";
+import * as path from "path";
+import { AgentTool, AgentToolResult } from "../types";
+
+export const writeTool: AgentTool = {
+  name: "write_file",
+  label: "Write File",
+  description:
+    "Write complete content to a new or existing file. This OVERWRITES the entire file. Use 'edit_file' for surgical changes.",
+  schema: {
+    type: "function",
+    function: {
+      name: "write_file",
+      description: "Write text content to a file.",
+      parameters: {
+        type: "object",
+        properties: {
+          file_path: {
+            type: "string",
+            description: "The path to the file to write.",
+          },
+          content: {
+            type: "string",
+            description: "The full content to write to the file.",
+          },
+        },
+        required: ["file_path", "content"],
+      },
+    },
+  },
+  execute: async (args: any): Promise<AgentToolResult> => {
+    try {
+      const fullPath = path.resolve(process.cwd(), args.file_path);
+      // Ensure the directory exists
+      await fs.mkdir(path.dirname(fullPath), { recursive: true });
+      await fs.writeFile(fullPath, args.content, "utf-8");
+
+      return {
+        content: [
+          { type: "text", text: `Successfully wrote to ${args.file_path}` },
+        ],
+        terminate: false,
+      };
+    } catch (error: any) {
+      return {
+        content: [
+          { type: "text", text: `Failed to write file: ${error.message}` },
+        ],
+        terminate: false,
+      };
+    }
+  },
+};

package/src/types.ts

@@ -0,0 +1,28 @@
+export interface AgentToolResult<T = any> {
+  content: { type: "text"; text: string }[];
+  details?: T;
+  terminate?: boolean;
+  usage?: {
+    promptTokens: number;
+    completionTokens: number;
+    totalTokens: number;
+  };
+}
+
+export interface ToolSchema {
+  type: "function";
+  function: {
+    name: string;
+    description: string;
+    parameters: any;
+  };
+}
+
+export interface AgentTool {
+  name: string;
+  label: string;
+  description: string;
+  schema: ToolSchema;
+  execute: (args: any) => Promise<AgentToolResult>;
+  executionMode?: "sequential" | "parallel";
+}