add tool tests

js/bun.lock

@@ -9,6 +9,7 @@
         "@flystorage/local-fs": "^1.1.0",
         "@hono/zod-validator": "^0.5.0",
         "ai": "^5.0.0-alpha.2",
+        "cac": "^6.7.14",
         "clipanion": "^4.0.0-rc.4",
         "hono": "^4.7.10",
         "hono-openapi": "^0.4.8",
@@ -96,6 +97,8 @@
 
     "bun-types": ["[email protected]", "", { "dependencies": { "@types/node": "*" } }, "sha512-rRjA1T6n7wto4gxhAO/ErZEtOXyEZEmnIHQfl0Dt1QQSB4QV0iP6BZ9/YB5fZaHFQ2dwHFrmPaRQ9GGMX01k9Q=="],
 
+    "cac": ["[email protected]", "", {}, "sha512-b6Ilus+c3RrdDk+JhLKUAQfzzgLEPy6wcXqS7f/xe1EETvsDP6GORG7SFuOs6cID5YkqchW/LXZbX5bc8j7ZcQ=="],
+
     "camelcase": ["[email protected]", "", {}, "sha512-faqwZqnWxbxn+F1d399ygeamQNy3lPp/H9H6rNrqYh4FSVCtcY+3cub1MxA8o9mDd55mM8Aghuu/kuyYA6VTsA=="],
 
     "chalk": ["[email protected]", "", {}, "sha512-zgVZuo2WcZgfUEmsn6eO3kINexW8RAE4maiQ8QNs8CtpPCSyMiYsULR3HQYkm3w8FIA3SberyMJMSldGsW+U3w=="],

js/package.json

@@ -23,6 +23,7 @@
     "@flystorage/local-fs": "^1.1.0",
     "@hono/zod-validator": "^0.5.0",
     "ai": "^5.0.0-alpha.2",
+    "cac": "^6.7.14",
     "clipanion": "^4.0.0-rc.4",
     "hono": "^4.7.10",
     "hono-openapi": "^0.4.8",

js/scrap.ts

@@ -0,0 +1,30 @@
+// This is a dummy file for testing purposes
+console.log('Hello, world!');
+
+export function dummyFunction(): void {
+  console.log('This is a dummy function');
+}
+
+export function anotherDummyFunction(): string {
+  return 'This is another dummy function';
+}
+
+export function newDummyFunction(): number {
+  return 42;
+}
+
+export function extraDummyFunction(): boolean {
+  return true;
+}
+
+export function superDummyFunction(): void {
+  console.log('This is a super dummy function');
+}
+
+export function ultraDummyFunction(): object {
+  return { dummy: true };
+}
+
+export function megaDummyFunction(): Array<string> {
+  return ['dummy', 'mega', 'function'];
+}

js/src/app/index.ts

@@ -11,15 +11,16 @@ export namespace App {
 
   const ctx = Context.create<Info>("app");
 
-  export async function create(input: { directory: string }) {
+  async function create(input: { directory: string }) {
+    const dataDir = AppPath.data(input.directory);
+    await fs.mkdir(dataDir, { recursive: true });
+    await Log.file(input.directory);
+
     log.info("creating");
 
     const config = await Config.load(input.directory);
 
-    const dataDir = AppPath.data(input.directory);
-    await fs.mkdir(dataDir, { recursive: true });
     log.info("created", { path: dataDir });
-    Log.file(input.directory);
 
     const services = new Map<any, any>();
 
@@ -55,5 +56,11 @@ export namespace App {
     return ctx.use();
   }
 
-  export const provide = ctx.provide;
+  export async function provide<T extends (app: Info) => any>(
+    input: { directory: string },
+    cb: T,
+  ) {
+    const app = await create(input);
+    return ctx.provide(app, () => cb(app));
+  }
 }

js/src/index.ts

@@ -1,89 +1,73 @@
 import { App } from "./app";
 import { Server } from "./server/server";
-import { Cli, Command, Option } from "clipanion";
 import fs from "fs/promises";
 import path from "path";
 import { Bus } from "./bus";
 import { Session } from "./session/session";
-import { LSP } from "./lsp";
+import cac from "cac";
+import { Storage } from "./storage/storage";
 
-const cli = new Cli({
-  binaryLabel: `opencode`,
-  binaryName: `opencode`,
-  binaryVersion: `1.0.0`,
-});
-
-cli.register(
-  class extends Command {
-    async execute() {
-      const app = await App.create({
-        directory: process.cwd(),
-      });
+const cli = cac("opencode");
 
-      await App.provide(app, async () => {
-        const server = Server.listen();
-      });
-    }
-  },
-);
+cli.command("", "Start the opencode in interactive mode").action(async () => {
+  await App.provide({ directory: process.cwd() }, () => {
+    Server.listen();
+  });
+});
 
-cli.register(
-  class extends Command {
-    static paths = [["generate"]];
-    async execute() {
-      const specs = await Server.openapi();
-      const dir = "gen";
-      await fs.rmdir(dir, { recursive: true }).catch(() => {});
-      await fs.mkdir(dir, { recursive: true });
-      await Bun.write(
-        path.join(dir, "openapi.json"),
-        JSON.stringify(specs, null, 2),
-      );
-      await Bun.write(
-        path.join(dir, "event.json"),
-        JSON.stringify(Bus.specs(), null, 2),
-      );
-    }
-  },
-);
+cli.command("generate", "Generate OpenAPI and event specs").action(async () => {
+  const specs = await Server.openapi();
+  const dir = "gen";
+  await fs.rmdir(dir, { recursive: true }).catch(() => {});
+  await fs.mkdir(dir, { recursive: true });
+  await Bun.write(
+    path.join(dir, "openapi.json"),
+    JSON.stringify(specs, null, 2),
+  );
+  await Bun.write(
+    path.join(dir, "event.json"),
+    JSON.stringify(Bus.specs(), null, 2),
+  );
+});
 
-cli.register(
-  class extends Command {
-    static paths = [["run"]];
-    message = Option.Rest();
+cli
+  .command("run [...message]", "Run a chat message")
+  .action(async (message: string[]) => {
+    await App.provide({ directory: process.cwd() }, async () => {
+      console.log("Thinking...");
+      Bus.subscribe(Storage.Event.Write, (evt) => {
+        const splits = evt.properties.key.split("/");
 
-    async execute() {
-      const app = await App.create({
-        directory: process.cwd(),
+        if (splits[0] === "session" && splits[1] === "message") {
+          console.log("opencode:", evt.properties.body);
+        }
+      });
+      const session = await Session.create();
+      const result = await Session.chat(session.id, {
+        type: "text",
+        text: message.join(" "),
       });
 
-      await App.provide(app, async () => {
-        console.log("Thinking...");
-        const session = await Session.create();
-        const result = await Session.chat(session.id, {
-          type: "text",
-          text: this.message.join(" "),
-        });
-        for (const part of result.parts) {
-          if (part.type === "text") {
-            console.log("opencode:", part.text);
-          }
-          if (part.type === "tool-invocation") {
-            console.log(
-              "tool:",
-              part.toolInvocation.toolName,
-              part.toolInvocation.args,
-              part.toolInvocation.state === "result"
-                ? part.toolInvocation.result
-                : "",
-            );
-          }
+      for (const part of result.parts) {
+        if (part.type === "text") {
+          console.log("opencode:", part.text);
         }
-      });
+        if (part.type === "tool-invocation") {
+          console.log(
+            "tool:",
+            part.toolInvocation.toolName,
+            part.toolInvocation.args,
+            part.toolInvocation.state === "result"
+              ? part.toolInvocation.result
+              : "",
+          );
+        }
+      }
 
       process.exit(0);
-    }
-  },
-);
-const [_bun, _app, ...args] = process.argv;
-cli.runExit(args);
+    });
+  });
+
+cli.help();
+cli.version("1.0.0");
+cli.parse();

js/src/lsp/client.ts

@@ -2,7 +2,6 @@ import { spawn } from "child_process";
 import path from "path";
 import {
   createMessageConnection,
-  Disposable,
   StreamMessageReader,
   StreamMessageWriter,
 } from "vscode-jsonrpc/node";

js/src/session/session.ts

@@ -14,9 +14,7 @@ import {
   type UIMessagePart,
 } from "ai";
 import { z } from "zod";
-import { BashTool } from "../tool/bash";
-import { EditTool } from "../tool/edit";
-import { ViewTool } from "../tool/view";
+import * as tools from "../tool";
 
 import ANTHROPIC_PROMPT from "./prompt/anthropic.txt";
 import type { Tool } from "../tool/tool";
@@ -173,11 +171,7 @@ export namespace Session {
       maxSteps: 1000,
       messages: convertToModelMessages(msgs),
       temperature: 0,
-      tools: {
-        ...BashTool,
-        ...ViewTool,
-        ...EditTool,
-      },
+      tools,
       model,
     });
     const next: Message = {
@@ -192,7 +186,7 @@ export namespace Session {
         tool: {},
       },
     };
-    const metadata = next.metadata!;
+
     msgs.push(next);
     let text: TextUIPart | undefined;
     const reader = result.toUIMessageStream().getReader();

js/src/tool/bash.ts

@@ -1,5 +1,5 @@
 import { z } from "zod";
-import { Tool, tool } from "./tool";
+import { Tool } from "./tool";
 
 const MAX_OUTPUT_LENGTH = 30000;
 const BANNED_COMMANDS = [
@@ -170,7 +170,7 @@ Important:
 - Return an empty response - the user will see the gh output directly
 - Never update git config`;
 
-export const BashTool = Tool.define({
+export const bash = Tool.define({
   name: "bash",
   description: DESCRIPTION,
   parameters: z.object({
@@ -182,7 +182,7 @@ export const BashTool = Tool.define({
       .describe("Optional timeout in milliseconds")
       .optional(),
   }),
-  async execute(params, opts) {
+  async execute(params) {
     const timeout = Math.min(params.timeout ?? DEFAULT_TIMEOUT, MAX_TIMEOUT);
     if (BANNED_COMMANDS.some((item) => params.command.startsWith(item)))
       throw new Error(`Command '${params.command}' is not allowed`);

js/src/tool/edit.ts

@@ -1,5 +1,4 @@
 import { z } from "zod";
-import * as fs from "fs";
 import * as path from "path";
 import { Log } from "../util/log";
 import { Tool } from "./tool";
@@ -8,67 +7,6 @@ import { LSP } from "../lsp";
 
 const log = Log.create({ service: "tool.edit" });
 
-// Simple diff generation
-function generateDiff(
-  oldContent: string,
-  newContent: string,
-  filePath: string,
-): {
-  diff: string;
-  additions: number;
-  removals: number;
-} {
-  const oldLines = oldContent.split("\n");
-  const newLines = newContent.split("\n");
-
-  let diff = `--- ${filePath}\n+++ ${filePath}\n`;
-  let additions = 0;
-  let removals = 0;
-
-  // Very simple diff implementation - in a real implementation, you'd use a proper diff algorithm
-  if (oldContent === "") {
-    // New file
-    diff += "@@ -0,0 +1," + newLines.length + " @@\n";
-    for (const line of newLines) {
-      diff += "+" + line + "\n";
-      additions++;
-    }
-  } else if (newContent === "") {
-    // Deleted content
-    diff += "@@ -1," + oldLines.length + " +0,0 @@\n";
-    for (const line of oldLines) {
-      diff += "-" + line + "\n";
-      removals++;
-    }
-  } else {
-    // Modified content
-    diff += "@@ -1," + oldLines.length + " +1," + newLines.length + " @@\n";
-
-    // This is a very simplified diff - a real implementation would use a proper diff algorithm
-    const maxLines = Math.max(oldLines.length, newLines.length);
-    for (let i = 0; i < maxLines; i++) {
-      if (i < oldLines.length && i < newLines.length) {
-        if (oldLines[i] !== newLines[i]) {
-          diff += "-" + oldLines[i] + "\n";
-          diff += "+" + newLines[i] + "\n";
-          removals++;
-          additions++;
-        } else {
-          diff += " " + oldLines[i] + "\n";
-        }
-      } else if (i < oldLines.length) {
-        diff += "-" + oldLines[i] + "\n";
-        removals++;
-      } else if (i < newLines.length) {
-        diff += "+" + newLines[i] + "\n";
-        additions++;
-      }
-    }
-  }
-
-  return { diff, additions, removals };
-}
-
 const DESCRIPTION = `Edits files by replacing text, creating new files, or deleting content. For moving or renaming files, use the Bash tool with the 'mv' command instead. For larger file edits, use the FileWrite tool to overwrite files.
 
 Before using this tool:
@@ -117,7 +55,7 @@ When making edits:
 
 Remember: when making multiple file edits in a row to the same file, you should prefer to send all edits in a single message with multiple calls to this tool, rather than multiple messages with a single call each.`;
 
-export const EditTool = Tool.define({
+export const edit = Tool.define({
   name: "edit",
   description: DESCRIPTION,
   parameters: z.object({
@@ -137,7 +75,7 @@ export const EditTool = Tool.define({
 
     await (async () => {
       if (params.old_string === "") {
-        await createNewFile(filePath, params.new_string);
+        await Bun.write(filePath, params.new_string);
         return;
       }
 
@@ -173,7 +111,6 @@ export const EditTool = Tool.define({
         params.new_string +
         content.substring(index + params.old_string.length);
 
-      console.log(newContent);
       await file.write(newContent);
     })();
 
@@ -193,45 +130,9 @@ export const EditTool = Tool.define({
         output += `\n<project_diagnostics>\n${JSON.stringify(params)}\n</project_diagnostics>\n`;
       }
     }
-    console.log(output);
 
     return {
       output,
     };
   },
 });
-
-async function createNewFile(
-  filePath: string,
-  content: string,
-): Promise<string> {
-  try {
-    try {
-      const fileStats = fs.statSync(filePath);
-      if (fileStats.isDirectory()) {
-        throw new Error(`Path is a directory, not a file: ${filePath}`);
-      }
-      throw new Error(`File already exists: ${filePath}`);
-    } catch (err: any) {
-      if (err.code !== "ENOENT") {
-        throw err;
-      }
-    }
-
-    const dir = path.dirname(filePath);
-    fs.mkdirSync(dir, { recursive: true });
-
-    const { diff, additions, removals } = generateDiff("", content, filePath);
-
-    fs.writeFileSync(filePath, content);
-
-    FileTimes.write(filePath);
-    FileTimes.read(filePath);
-
-    return `File created: ${filePath}`;
-  } catch (err: any) {
-    throw new Error(`Failed to create file: ${err.message}`);
-  }
-}
-
-function getFile(filePath: string) {}

js/src/tool/glob.ts

@@ -0,0 +1,96 @@
+import { z } from "zod";
+import { Tool } from "./tool";
+import { App } from "../app";
+
+const DESCRIPTION = `Fast file pattern matching tool that finds files by name and pattern, returning matching paths sorted by modification time (newest first).
+
+WHEN TO USE THIS TOOL:
+- Use when you need to find files by name patterns or extensions
+- Great for finding specific file types across a directory structure
+- Useful for discovering files that match certain naming conventions
+
+HOW TO USE:
+- Provide a glob pattern to match against file paths
+- Optionally specify a starting directory (defaults to current working directory)
+- Results are sorted with most recently modified files first
+
+GLOB PATTERN SYNTAX:
+- '*' matches any sequence of non-separator characters
+- '**' matches any sequence of characters, including separators
+- '?' matches any single non-separator character
+- '[...]' matches any character in the brackets
+- '[!...]' matches any character not in the brackets
+
+COMMON PATTERN EXAMPLES:
+- '*.js' - Find all JavaScript files in the current directory
+- '**/*.js' - Find all JavaScript files in any subdirectory
+- 'src/**/*.{ts,tsx}' - Find all TypeScript files in the src directory
+- '*.{html,css,js}' - Find all HTML, CSS, and JS files
+
+LIMITATIONS:
+- Results are limited to 100 files (newest first)
+- Does not search file contents (use Grep tool for that)
+- Hidden files (starting with '.') are skipped
+
+TIPS:
+- For the most useful results, combine with the Grep tool: first find files with Glob, then search their contents with Grep
+- When doing iterative exploration that may require multiple rounds of searching, consider using the Agent tool instead
+- Always check if results are truncated and refine your search pattern if needed`;
+
+export const glob = Tool.define({
+  name: "glob",
+  description: DESCRIPTION,
+  parameters: z.object({
+    pattern: z.string().describe("The glob pattern to match files against"),
+    path: z
+      .string()
+      .describe(
+        "The directory to search in. Defaults to the current working directory.",
+      )
+      .optional(),
+  }),
+  async execute(params) {
+    const app = await App.use();
+    const search = params.path || app.root;
+    const limit = 100;
+    const glob = new Bun.Glob(params.pattern);
+    const files = [];
+    let truncated = false;
+    for await (const file of glob.scan({ cwd: search })) {
+      if (files.length >= limit) {
+        truncated = true;
+        break;
+      }
+      const stats = await Bun.file(file)
+        .stat()
+        .then((x) => x.mtime.getTime())
+        .catch(() => 0);
+      files.push({
+        path: file,
+        mtime: stats,
+      });
+    }
+    files.sort((a, b) => b.mtime - a.mtime);
+
+    const output = [];
+    if (files.length === 0) output.push("No files found");
+    if (files.length > 0) {
+      output.push(...files.map((f) => f.path));
+      if (truncated) {
+        output.push("");
+        output.push(
+          "(Results are truncated. Consider using a more specific path or pattern.)",
+        );
+      }
+    }
+
+    return {
+      metadata: {
+        count: files.length,
+        truncated,
+      },
+      output: output.join("\n"),
+    };
+  },
+});
+

js/src/tool/index.ts

@@ -0,0 +1,4 @@
+export * from "./bash";
+export * from "./edit";
+export * from "./view";
+export * from "./glob";

js/src/tool/tool.ts

@@ -4,49 +4,53 @@ import { Log } from "../util/log";
 const log = Log.create({ service: "tool" });
 
 export namespace Tool {
-  export interface Metadata {
-    properties: Record<string, any>;
+  export interface Metadata<
+    Properties extends Record<string, any> = Record<string, any>,
+  > {
+    properties: Properties;
     time: {
       start: number;
       end: number;
     };
   }
-  export function define<Params, Output>(
-    input: AITool<Params, { metadata?: any; output: Output }> & {
-      name: string;
+  export function define<
+    Params,
+    Output extends { metadata?: any; output: any },
+    Name extends string,
+  >(
+    input: AITool<Params, Output> & {
+      name: Name;
     },
   ) {
-    return {
-      [input.name]: tool({
-        ...input,
-        execute: async (params, opts) => {
-          log.info("invoking", {
-            id: opts.toolCallId,
-            name: input.name,
-            ...params,
+    return tool({
+      ...input,
+      execute: async (params, opts) => {
+        log.info("invoking", {
+          id: opts.toolCallId,
+          name: input.name,
+          ...params,
+        });
+        try {
+          const start = Date.now();
+          const result = await input.execute!(params, opts);
+          const metadata: Metadata<Output["metadata"]> = {
+            ...result.metadata,
+            time: {
+              start,
+              end: Date.now(),
+            },
+          };
+          return {
+            metadata,
+            output: result.output,
+          };
+        } catch (e: any) {
+          log.error("error", {
+            msg: e.toString(),
           });
-          try {
-            const start = Date.now();
-            const result = await input.execute!(params, opts);
-            const metadata: Metadata = {
-              properties: result.metadata,
-              time: {
-                start,
-                end: Date.now(),
-              },
-            };
-            return {
-              metadata,
-              output: result.output,
-            };
-          } catch (e: any) {
-            log.error("error", {
-              msg: e.toString(),
-            });
-            return "An error occurred: " + e.toString();
-          }
-        },
-      }),
-    };
+          return "An error occurred: " + e.toString();
+        }
+      },
+    });
   }
 }

js/src/tool/view.ts

@@ -40,7 +40,7 @@ TIPS:
 - For code exploration, first use Grep to find relevant files, then View to examine them
 - When viewing large files, use the offset parameter to read specific sections`;
 
-export const ViewTool = Tool.define({
+export const view = Tool.define({
   name: "view",
   description: DESCRIPTION,
   parameters: z.object({
@@ -84,29 +84,25 @@ export const ViewTool = Tool.define({
       throw new Error(`File not found: ${filePath}`);
     }
     const stats = await file.stat();
-    if (stats.isDirectory())
-      throw new Error(`Path is a directory, not a file: ${filePath}`);
 
-    if (stats.size > MAX_READ_SIZE) {
+    if (stats.size > MAX_READ_SIZE)
       throw new Error(
         `File is too large (${stats.size} bytes). Maximum size is ${MAX_READ_SIZE} bytes`,
       );
-    }
     const limit = params.limit ?? DEFAULT_READ_LIMIT;
     const offset = params.offset || 0;
     const isImage = isImageFile(filePath);
-    if (isImage) {
+    if (isImage)
       throw new Error(
         `This is an image file of type: ${isImage}\nUse a different tool to process images`,
       );
-    }
     const lines = await file.text().then((text) => text.split("\n"));
     const content = lines.slice(offset, offset + limit).map((line, index) => {
       line =
         line.length > MAX_LINE_LENGTH
           ? line.substring(0, MAX_LINE_LENGTH) + "..."
           : line;
-      return `${index + offset + 1}|${line}`;
+      return `${(index + offset + 1).toString().padStart(5, "0")}| ${line}`;
     });
 
     let output = "<file>\n";

js/src/util/log.ts

@@ -1,4 +1,3 @@
-import fs from "node:fs";
 import path from "node:path";
 import { AppPath } from "../app/path";
 export namespace Log {
@@ -11,16 +10,23 @@ export namespace Log {
     },
   };
 
-  export function file(directory: string) {
-    return;
+  export async function file(directory: string) {
     const out = Bun.file(
       path.join(AppPath.data(directory), "opencode.out.log"),
-    ).writer();
+    );
     const err = Bun.file(
       path.join(AppPath.data(directory), "opencode.err.log"),
-    ).writer();
-    write["out"] = (msg) => out.write(msg);
-    write["err"] = (msg) => err.write(msg);
+    );
+    const outWriter = out.writer();
+    const errWriter = err.writer();
+    write["out"] = (msg) => {
+      outWriter.write(msg);
+      outWriter.flush();
+    };
+    write["err"] = (msg) => {
+      errWriter.write(msg);
+      errWriter.flush();
+    };
   }
 
   export function create(tags?: Record<string, any>) {

js/test/tool/tool.test.ts

@@ -0,0 +1,37 @@
+import { describe, expect, test } from "bun:test";
+import { App } from "../../src/app";
+import { glob } from "../../src/tool/glob";
+
+describe("tool.glob", () => {
+  test("truncate", async () => {
+    await App.provide({ directory: process.cwd() }, async () => {
+      let result = await glob.execute(
+        {
+          pattern: "./node_modules/**/*",
+        },
+        {
+          toolCallId: "test",
+          messages: [],
+        },
+      );
+      expect(result.metadata.truncated).toBe(true);
+    });
+  });
+  test("basic", async () => {
+    await App.provide({ directory: process.cwd() }, async () => {
+      let result = await glob.execute(
+        {
+          pattern: "*.json",
+        },
+        {
+          toolCallId: "test",
+          messages: [],
+        },
+      );
+      expect(result.metadata).toMatchObject({
+        truncated: false,
+        count: 3,
+      });
+    });
+  });
+});