@johpaz/hive-agents 0.0.35 → 0.0.36

package/packages/core/src/tools/filesystem/fs-delete.ts

@@ -0,0 +1,78 @@
+/**
+ * fs_delete - Delete file or directory from workspace
+ * 
+ * @category filesystem
+ * @seedId fs_delete
+ * @spanish eliminar archivo, borrar archivo, borrar carpeta
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace } from "./workspace-guard.ts";
+import * as fs from "node:fs";
+
+const log = logger.child("fs-delete");
+
+export const fsDeleteTool: Tool = {
+  name: "fs_delete",
+  description: "Delete file or directory from workspace. Spanish: eliminar archivo, borrar archivo, borrar carpeta",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the file or directory to delete",
+      },
+      recursive: {
+        type: "boolean",
+        description: "Delete recursively for directories (default: false)",
+      },
+    },
+    required: ["path"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    let targetPath: string;
+    try {
+      targetPath = resolveInWorkspace(params.path as string, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+    const recursive = (params.recursive as boolean) ?? false;
+
+    log.debug(`Deleting: ${targetPath}`);
+
+    try {
+      if (!fs.existsSync(targetPath)) {
+        return {
+          ok: false,
+          error: `Path not found: ${targetPath}`,
+        };
+      }
+
+      const stats = fs.statSync(targetPath);
+
+      if (stats.isDirectory()) {
+        if (recursive) {
+          fs.rmSync(targetPath, { recursive: true });
+        } else {
+          fs.rmdirSync(targetPath);
+        }
+      } else {
+        fs.unlinkSync(targetPath);
+      }
+
+      return {
+        ok: true,
+        path: targetPath,
+        deleted: true,
+      };
+    } catch (error) {
+      log.error(`Error deleting: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to delete: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/fs-edit.ts

@@ -0,0 +1,106 @@
+/**
+ * fs_edit - Edit specific lines or sections of a file
+ * 
+ * @category filesystem
+ * @seedId fs_edit
+ * @spanish editar archivo, modificar líneas, actualizar contenido
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace } from "./workspace-guard.ts";
+import * as fs from "node:fs";
+
+const log = logger.child("fs-edit");
+
+export const fsEditTool: Tool = {
+  name: "fs_edit",
+  description: "Edit specific lines or sections of a file. Spanish: editar archivo, modificar líneas, actualizar contenido",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the file to edit",
+      },
+      oldString: {
+        type: "string",
+        description: "The text to search for and replace",
+      },
+      newString: {
+        type: "string",
+        description: "The text to replace with",
+      },
+      replaceAll: {
+        type: "boolean",
+        description: "Replace all occurrences (default: false)",
+      },
+    },
+    required: ["path", "oldString", "newString"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    let filePath: string;
+    try {
+      filePath = resolveInWorkspace(params.path as string, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+    const oldString = params.oldString as string;
+    const newString = params.newString as string;
+    const replaceAll = (params.replaceAll as boolean) ?? false;
+
+    log.debug(`Editing file: ${filePath}`);
+
+    try {
+      if (!fs.existsSync(filePath)) {
+        return {
+          ok: false,
+          error: `File not found: ${filePath}`,
+        };
+      }
+
+      const content = fs.readFileSync(filePath, "utf-8");
+
+      if (!content.includes(oldString)) {
+        return {
+          ok: false,
+          error: `String not found in file: ${oldString.substring(0, 50)}...`,
+        };
+      }
+
+      let newContent: string;
+      let occurrences = 0;
+      if (replaceAll) {
+        occurrences = content.split(oldString).length - 1;
+        newContent = content.split(oldString).join(newString);
+      } else {
+        const index = content.indexOf(oldString);
+        occurrences = content.split(oldString).length - 1;
+
+        if (occurrences > 1) {
+          return {
+            ok: false,
+            error: `Found ${occurrences} occurrences. Use replaceAll: true or provide more context.`,
+          };
+        }
+
+        newContent = content.replace(oldString, newString);
+      }
+
+      fs.writeFileSync(filePath, newContent, "utf-8");
+
+      return {
+        ok: true,
+        path: filePath,
+        replacements: replaceAll ? occurrences : 1,
+      };
+    } catch (error) {
+      log.error(`Error editing file: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to edit file: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/fs-exists.ts

@@ -0,0 +1,63 @@
+/**
+ * fs_exists - Check if a file or directory exists
+ * 
+ * @category filesystem
+ * @seedId fs_exists
+ * @spanish verificar archivo, comprobar, existe archivo
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace } from "./workspace-guard.ts";
+import * as fs from "node:fs";
+
+const log = logger.child("fs-exists");
+
+export const fsExistsTool: Tool = {
+  name: "fs_exists",
+  description: "Check if a file or directory exists. Spanish: verificar archivo, comprobar, existe archivo",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to check for existence",
+      },
+    },
+    required: ["path"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    let filePath: string;
+    try {
+      filePath = resolveInWorkspace(params.path as string, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+
+    log.debug(`Checking existence: ${filePath}`);
+
+    try {
+      const exists = fs.existsSync(filePath);
+      let type: "file" | "directory" | "none" = "none";
+
+      if (exists) {
+        const stats = fs.statSync(filePath);
+        type = stats.isDirectory() ? "directory" : "file";
+      }
+
+      return {
+        ok: true,
+        path: filePath,
+        exists,
+        type,
+      };
+    } catch (error) {
+      log.error(`Error checking existence: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to check existence: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/fs-glob.ts

@@ -0,0 +1,108 @@
+/**
+ * fs_glob - Find files matching wildcard patterns
+ * 
+ * @category filesystem
+ * @seedId fs_glob
+ * @spanish buscar archivos, patrón, encontrar archivos
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace, expandPath } from "./workspace-guard.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("fs-glob");
+
+export const fsGlobTool: Tool = {
+  name: "fs_glob",
+  description: "Find files matching wildcard patterns. Spanish: buscar archivos, patrón, encontrar archivos",
+  parameters: {
+    type: "object",
+    properties: {
+      pattern: {
+        type: "string",
+        description: "Glob pattern (e.g., '**/*.ts', 'src/**/*.js')",
+      },
+      basePath: {
+        type: "string",
+        description: "Base path to search from (default: current directory)",
+      },
+    },
+    required: ["pattern"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    const rawBase = (params.basePath as string) ?? (workspace ? expandPath(workspace) : ".");
+    let base: string;
+    try {
+      base = resolveInWorkspace(rawBase, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+    const pattern = params.pattern as string;
+
+    log.debug(`Globbing: ${pattern} in ${base}`);
+
+    try {
+      const results: string[] = [];
+
+      function matchGlob(dir: string, pat: string, depth: number): void {
+        if (depth > 10) return;
+
+        const parts = pat.split("/");
+        const firstPart = parts[0];
+        const remainingParts = parts.slice(1);
+
+        try {
+          const entries = fs.readdirSync(dir, { withFileTypes: true });
+
+          for (const entry of entries) {
+            const fullPath = path.join(dir, entry.name);
+
+            if (firstPart === "**") {
+              if (entry.isDirectory()) {
+                matchGlob(fullPath, parts.slice(1).join("/"), depth + 1);
+                matchGlob(fullPath, pat, depth + 1);
+              }
+              if (remainingParts.length === 0 || matchesPattern(entry.name, remainingParts[0])) {
+                results.push(fullPath);
+              }
+            } else if (matchesPattern(entry.name, firstPart)) {
+              if (remainingParts.length === 0) {
+                results.push(fullPath);
+              } else if (entry.isDirectory()) {
+                matchGlob(fullPath, remainingParts.join("/"), depth + 1);
+              }
+            }
+          }
+        } catch {
+          // Ignore permission errors
+        }
+      }
+
+      function matchesPattern(name: string, pattern: string): boolean {
+        if (pattern === "*") return true;
+        if (pattern === "**") return true;
+        const regex = new RegExp("^" + pattern.replace(/\*/g, ".*").replace(/\?/g, ".") + "$");
+        return regex.test(name);
+      }
+
+      matchGlob(base, pattern, 0);
+
+      return {
+        ok: true,
+        pattern,
+        basePath: base,
+        files: results.slice(0, 100),
+        count: results.length,
+      };
+    } catch (error) {
+      log.error(`Error globbing: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to glob: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/fs-list.ts

@@ -0,0 +1,129 @@
+/**
+ * fs_list - List files and directories in workspace
+ * 
+ * @category filesystem
+ * @seedId fs_list
+ * @spanish listar archivos, ver carpeta, explorar directorio
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace, expandPath } from "./workspace-guard.ts";
+import * as fs from "node:fs";
+import * as path from "node:path";
+
+const log = logger.child("fs-list");
+
+export const fsListTool: Tool = {
+  name: "fs_list",
+  description: "List files and directories in workspace. Spanish: listar archivos, ver carpeta, explorar directorio",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the directory to list (default: current directory)",
+      },
+      recursive: {
+        type: "boolean",
+        description: "List recursively (default: false)",
+      },
+      maxDepth: {
+        type: "number",
+        description: "Maximum depth for recursive listing (default: 3)",
+      },
+    },
+    required: [],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    // Default to workspace root when no path given and workspace is configured
+    const rawPath = (params.path as string) ?? (workspace ? expandPath(workspace) : ".");
+    let dirPath: string;
+    try {
+      dirPath = resolveInWorkspace(rawPath, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+    const recursive = (params.recursive as boolean) ?? false;
+    const maxDepth = (params.maxDepth as number) ?? 3;
+
+    log.debug(`Listing directory: ${dirPath}`);
+
+    try {
+      if (!fs.existsSync(dirPath)) {
+        return {
+          ok: false,
+          error: `Directory not found: ${dirPath}`,
+        };
+      }
+
+      const stats = fs.statSync(dirPath);
+      if (!stats.isDirectory()) {
+        return {
+          ok: false,
+          error: `Not a directory: ${dirPath}`,
+        };
+      }
+
+      interface FileEntry {
+        name: string;
+        type: "file" | "directory";
+        path: string;
+        size?: number;
+        modified?: string;
+        children?: FileEntry[];
+      }
+
+      function listDir(dir: string, depth: number): FileEntry[] {
+        if (depth > maxDepth) return [];
+
+        const entries = fs.readdirSync(dir, { withFileTypes: true });
+        return entries.map((entry) => {
+          const fullPath = path.join(dir, entry.name);
+          const result: FileEntry = {
+            name: entry.name,
+            type: entry.isDirectory() ? "directory" : "file",
+            path: fullPath,
+          };
+
+          if (entry.isDirectory() && recursive && depth < maxDepth) {
+            try {
+              const subStats = fs.statSync(fullPath);
+              result.size = subStats.size;
+              result.modified = subStats.mtime.toISOString();
+              result.children = listDir(fullPath, depth + 1);
+            } catch {
+              // Ignore permission errors
+            }
+          } else {
+            try {
+              const subStats = fs.statSync(fullPath);
+              result.size = subStats.size;
+              result.modified = subStats.mtime.toISOString();
+            } catch {
+              // Ignore permission errors
+            }
+          }
+
+          return result;
+        });
+      }
+
+      const entries = listDir(dirPath, 0);
+
+      return {
+        ok: true,
+        path: dirPath,
+        entries,
+        count: entries.length,
+      };
+    } catch (error) {
+      log.error(`Error listing directory: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to list directory: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/fs-read.ts

@@ -0,0 +1,72 @@
+/**
+ * fs_read - Read file content from agent workspace
+ * 
+ * @category filesystem
+ * @seedId fs_read
+ * @spanish leer archivo, ver contenido, abrir archivo
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace } from "./workspace-guard.ts";
+
+const log = logger.child("fs-read");
+
+export const fsReadTool: Tool = {
+  name: "fs_read",
+  description: "Read file content from agent workspace. Spanish: leer archivo, ver contenido, abrir archivo",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the file to read",
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-indexed, default: 1)",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read (default: 2000)",
+      },
+    },
+    required: ["path"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    let filePath: string;
+    try {
+      filePath = resolveInWorkspace(params.path as string, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+    const offset = (params.offset as number) ?? 1;
+    const limit = (params.limit as number) ?? 2000;
+
+    log.debug(`Reading file: ${filePath}`);
+
+    try {
+      const content = await Bun.file(filePath).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 {
+        ok: true,
+        path: filePath,
+        content: selected.map((line, i) => `${start + i + 1}: ${line}`).join("\n"),
+        totalLines: lines.length,
+        linesRead: selected.length,
+      };
+    } catch (error) {
+      log.error(`Error reading file: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to read file: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/fs-write.ts

@@ -0,0 +1,67 @@
+/**
+ * fs_write - Create or overwrite file in agent workspace
+ * 
+ * @category filesystem
+ * @seedId fs_write
+ * @spanish crear archivo, guardar archivo, escribir archivo
+ */
+
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+import { resolveInWorkspace, getWorkspace } from "./workspace-guard.ts";
+import * as path from "node:path";
+import * as fs from "node:fs";
+
+const log = logger.child("fs-write");
+
+export const fsWriteTool: Tool = {
+  name: "fs_write",
+  description: "Create or overwrite file in agent workspace. Spanish: crear archivo, guardar archivo, escribir archivo",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "Path to the file to write",
+      },
+      content: {
+        type: "string",
+        description: "Content to write to the file",
+      },
+    },
+    required: ["path", "content"],
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const workspace = getWorkspace(config);
+    let filePath: string;
+    try {
+      filePath = resolveInWorkspace(params.path as string, workspace);
+    } catch (e) {
+      return { ok: false, error: (e as Error).message };
+    }
+    const content = params.content as string;
+
+    log.debug(`Writing file: ${filePath}`);
+
+    try {
+      const dir = path.dirname(filePath);
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+      }
+
+      await Bun.write(filePath, content);
+
+      return {
+        ok: true,
+        path: filePath,
+        bytesWritten: content.length,
+      };
+    } catch (error) {
+      log.error(`Error writing file: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to write file: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/filesystem/index.ts

@@ -0,0 +1,34 @@
+/**
+ * Filesystem Tools - 7 tools
+ * 
+ * @category filesystem
+ */
+
+import type { Tool } from "../types.ts";
+import { fsReadTool } from "./fs-read.ts";
+import { fsWriteTool } from "./fs-write.ts";
+import { fsEditTool } from "./fs-edit.ts";
+import { fsDeleteTool } from "./fs-delete.ts";
+import { fsListTool } from "./fs-list.ts";
+import { fsGlobTool } from "./fs-glob.ts";
+import { fsExistsTool } from "./fs-exists.ts";
+
+export function createTools(): Tool[] {
+  return [
+    fsReadTool,
+    fsWriteTool,
+    fsEditTool,
+    fsDeleteTool,
+    fsListTool,
+    fsGlobTool,
+    fsExistsTool,
+  ];
+}
+
+export * from "./fs-read.ts";
+export * from "./fs-write.ts";
+export * from "./fs-edit.ts";
+export * from "./fs-delete.ts";
+export * from "./fs-list.ts";
+export * from "./fs-glob.ts";
+export * from "./fs-exists.ts";