@johpaz/hive-core 1.0.7 → 1.0.10

package/src/tools/fs.ts

@@ -0,0 +1,364 @@
+import type { Tool } from "./registry.ts";
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import { readdir, stat, mkdir, rm, rmdir, unlink, copyFile, rename } from "fs/promises";
+import * as path from "path";
+
+interface FSConfig {
+  allowedPaths: string[];
+  sandboxed: boolean;
+}
+
+function validatePath(targetPath: string, allowedPaths: string[]): void {
+  const resolved = path.resolve(targetPath);
+  const isAllowed = allowedPaths.some((allowed) => resolved.startsWith(path.resolve(allowed)));
+
+  if (!isAllowed) {
+    throw new Error(`Path ${targetPath} not in allowed paths`);
+  }
+}
+
+function getFSConfig(config: Config): FSConfig {
+  const toolsConfig = config.tools as Record<string, unknown> | undefined;
+  const fsConfig = toolsConfig?.fs as Record<string, unknown> | undefined;
+
+  return {
+    allowedPaths: (fsConfig?.allowedPaths as string[]) ?? [process.cwd()],
+    sandboxed: (fsConfig?.sandboxed as boolean) ?? true,
+  };
+}
+
+export function createFSReadTool(config: Config): Tool {
+  const log = logger.child("fs-read");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_read",
+    description: "Read a file from the filesystem",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the file to read",
+        },
+        encoding: {
+          type: "string",
+          description: "File encoding (default: utf-8)",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = params.path as string;
+      const encoding = (params.encoding as BufferEncoding) ?? "utf-8";
+
+      if (fsConfig.sandboxed) {
+        validatePath(filePath, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Reading: ${filePath}`);
+
+      const content = await Bun.file(filePath).text();
+
+      return {
+        success: true,
+        path: filePath,
+        content,
+        size: content.length,
+      };
+    },
+  };
+}
+
+export function createFSWriteTool(config: Config): Tool {
+  const log = logger.child("fs-write");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_write",
+    description: "Write content to a file",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the file to write",
+        },
+        content: {
+          type: "string",
+          description: "Content to write",
+        },
+        encoding: {
+          type: "string",
+          description: "File encoding (default: utf-8)",
+        },
+      },
+      required: ["path", "content"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const filePath = params.path as string;
+      const content = params.content as string;
+      const encoding = (params.encoding as BufferEncoding) ?? "utf-8";
+
+      if (fsConfig.sandboxed) {
+        validatePath(filePath, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Writing: ${filePath}`);
+
+      await Bun.write(filePath, content);
+
+      return {
+        success: true,
+        path: filePath,
+        bytesWritten: content.length,
+      };
+    },
+  };
+}
+
+export function createFSListTool(config: Config): Tool {
+  const log = logger.child("fs-list");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_list",
+    description: "List contents of a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to the directory",
+        },
+        recursive: {
+          type: "boolean",
+          description: "List recursively (default: false)",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const dirPath = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+
+      if (fsConfig.sandboxed) {
+        validatePath(dirPath, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Listing: ${dirPath}`);
+
+      const entries = await readdir(dirPath, { withFileTypes: true });
+
+      const results: Array<{
+        name: string;
+        path: string;
+        type: string;
+        size: number;
+        modified: string;
+      }> = [];
+
+      for (const entry of entries) {
+        const fullPath = path.join(dirPath, entry.name);
+        const stats = await stat(fullPath);
+
+        results.push({
+          name: entry.name,
+          path: fullPath,
+          type: entry.isDirectory() ? "directory" : "file",
+          size: stats.size,
+          modified: stats.mtime.toISOString(),
+        });
+      }
+
+      if (recursive) {
+        const subdirs = results.filter((r) => r.type === "directory");
+        for (const subdir of subdirs) {
+          const subParams = { path: subdir.path, recursive: true };
+          const subResult = await createFSListTool(config).execute(subParams);
+          const subFiles = (subResult as { entries: unknown[] }).entries;
+          results.push(...(subFiles as typeof results));
+        }
+      }
+
+      return {
+        success: true,
+        path: dirPath,
+        entries: results,
+        count: results.length,
+      };
+    },
+  };
+}
+
+export function createFSMkdirTool(config: Config): Tool {
+  const log = logger.child("fs-mkdir");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_mkdir",
+    description: "Create a directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to create",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const dirPath = params.path as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(dirPath, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Creating directory: ${dirPath}`);
+
+      await mkdir(dirPath, { recursive: true });
+
+      return { success: true, path: dirPath };
+    },
+  };
+}
+
+export function createFSDeleteTool(config: Config): Tool {
+  const log = logger.child("fs-delete");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_delete",
+    description: "Delete a file or directory",
+    parameters: {
+      type: "object",
+      properties: {
+        path: {
+          type: "string",
+          description: "Path to delete",
+        },
+        recursive: {
+          type: "boolean",
+          description: "Delete recursively for directories",
+        },
+      },
+      required: ["path"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const targetPath = params.path as string;
+      const recursive = (params.recursive as boolean) ?? false;
+
+      if (fsConfig.sandboxed) {
+        validatePath(targetPath, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Deleting: ${targetPath}`);
+
+      const stats = await stat(targetPath);
+
+      if (stats.isDirectory()) {
+        if (recursive) {
+          await rm(targetPath, { recursive: true });
+        } else {
+          await rmdir(targetPath);
+        }
+      } else {
+        await unlink(targetPath);
+      }
+
+      return { success: true, path: targetPath };
+    },
+  };
+}
+
+export function createFSCopyTool(config: Config): Tool {
+  const log = logger.child("fs-copy");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_copy",
+    description: "Copy a file",
+    parameters: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "Source file path",
+        },
+        destination: {
+          type: "string",
+          description: "Destination file path",
+        },
+      },
+      required: ["source", "destination"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const source = params.source as string;
+      const destination = params.destination as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(source, fsConfig.allowedPaths);
+        validatePath(destination, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Copying: ${source} -> ${destination}`);
+
+      await copyFile(source, destination);
+
+      return { success: true, source, destination };
+    },
+  };
+}
+
+export function createFSMoveTool(config: Config): Tool {
+  const log = logger.child("fs-move");
+  const fsConfig = getFSConfig(config);
+
+  return {
+    name: "fs_move",
+    description: "Move/rename a file",
+    parameters: {
+      type: "object",
+      properties: {
+        source: {
+          type: "string",
+          description: "Source file path",
+        },
+        destination: {
+          type: "string",
+          description: "Destination file path",
+        },
+      },
+      required: ["source", "destination"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const source = params.source as string;
+      const destination = params.destination as string;
+
+      if (fsConfig.sandboxed) {
+        validatePath(source, fsConfig.allowedPaths);
+        validatePath(destination, fsConfig.allowedPaths);
+      }
+
+      log.debug(`Moving: ${source} -> ${destination}`);
+
+      await rename(source, destination);
+
+      return { success: true, source, destination };
+    },
+  };
+}
+
+export function createFSTools(config: Config): Tool[] {
+  return [
+    createFSReadTool(config),
+    createFSWriteTool(config),
+    createFSListTool(config),
+    createFSMkdirTool(config),
+    createFSDeleteTool(config),
+    createFSCopyTool(config),
+    createFSMoveTool(config),
+  ];
+}

package/src/tools/index.ts

@@ -4,3 +4,4 @@ export * from "./exec.ts";
 export * from "./web.ts";
 export * from "./notify.ts";
 export * from "./cron.ts";
+export * from "./fs.ts";

package/src/tools/read.ts

@@ -1,4 +1,4 @@
-import * as fs from "node:fs";
+import { readdirSync, existsSync, mkdirSync } from "node:fs";
 import * as path from "node:path";
 import type { Tool } from "./registry.ts";
 
@@ -28,27 +28,30 @@ export const readTool: Tool = {
     const offset = (params.offset as number) ?? 1;
     const limit = (params.limit as number) ?? 2000;
 
-    if (!fs.existsSync(filePath)) {
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
       throw new Error(`File not found: ${filePath}`);
     }
 
-    const stats = fs.statSync(filePath);
-    if (stats.isDirectory()) {
-      const entries = fs.readdirSync(filePath, { withFileTypes: true });
+    // Check if it's a directory by trying readdir
+    try {
+      const entries = readdirSync(filePath, { withFileTypes: true });
       return entries.map((e) => ({
         name: e.name,
         type: e.isDirectory() ? "directory" : "file",
       }));
+    } catch {
+      // Not a directory, read as file
     }
 
-    const content = fs.readFileSync(filePath, "utf-8");
+    const content = await file.text();
     const lines = content.split("\n");
-    
+
     const start = Math.max(0, offset - 1);
     const end = Math.min(lines.length, start + limit);
-    
+
     const selected = lines.slice(start, end);
-    
+
     return selected
       .map((line, i) => `${start + i + 1}: ${line}`)
       .join("\n");
@@ -77,12 +80,12 @@ export const writeTool: Tool = {
     const content = params.content as string;
 
     const dir = path.dirname(filePath);
-    if (!fs.existsSync(dir)) {
-      fs.mkdirSync(dir, { recursive: true });
+    if (!existsSync(dir)) {
+      mkdirSync(dir, { recursive: true });
     }
 
-    fs.writeFileSync(filePath, content, "utf-8");
-    
+    await Bun.write(filePath, content);
+
     return { success: true, path: filePath, bytes: content.length };
   },
 };
@@ -118,11 +121,12 @@ export const editTool: Tool = {
     const newString = params.newString as string;
     const replaceAll = (params.replaceAll as boolean) ?? false;
 
-    if (!fs.existsSync(filePath)) {
+    const file = Bun.file(filePath);
+    if (!(await file.exists())) {
       throw new Error(`File not found: ${filePath}`);
     }
 
-    const content = fs.readFileSync(filePath, "utf-8");
+    const content = await file.text();
 
     if (!content.includes(oldString)) {
       throw new Error(`String not found in file: ${oldString.substring(0, 50)}...`);
@@ -136,19 +140,19 @@ export const editTool: Tool = {
       if (index === -1) {
         throw new Error(`String not found in file`);
       }
-      
+
       const occurrences = content.split(oldString).length - 1;
       if (occurrences > 1) {
         throw new Error(
           `Found ${occurrences} occurrences. Use replaceAll: true or provide more context.`
         );
       }
-      
+
       newContent = content.replace(oldString, newString);
     }
 
-    fs.writeFileSync(filePath, newContent, "utf-8");
-    
+    await Bun.write(filePath, newContent);
+
     return { success: true, path: filePath };
   },
 };