@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,106 +0,0 @@
-/**
- * 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

@@ -1,63 +0,0 @@
-/**
- * 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

@@ -1,108 +0,0 @@
-/**
- * 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

@@ -1,129 +0,0 @@
-/**
- * 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

@@ -1,72 +0,0 @@
-/**
- * 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

@@ -1,67 +0,0 @@
-/**
- * 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

@@ -1,34 +0,0 @@
-/**
- * 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";

package/packages/core/src/tools/filesystem/workspace-guard.ts

@@ -1,62 +0,0 @@
-/**
- * Workspace Guard — enforces that filesystem tool paths stay inside the agent workspace.
- *
- * If the agent has no workspace configured the guard is a no-op and all paths are allowed.
- * If a workspace is set, any path that resolves outside it is rejected with a clear error.
- */
-
-import * as path from "node:path"
-import * as os from "node:os"
-
-/** Expand ~ to the home directory */
-export function expandPath(p: string): string {
-  if (p.startsWith("~")) {
-    return path.join(os.homedir(), p.slice(1))
-  }
-  return p
-}
-
-/**
- * Resolve a user-supplied path against the workspace root.
- *
- * - If `workspace` is not set (null / undefined / empty), all paths pass through unchanged.
- * - Relative paths are resolved relative to `workspace`.
- * - Absolute paths must be inside `workspace`; otherwise an error is thrown.
- *
- * @throws Error when the resolved path is outside the workspace.
- */
-export function resolveInWorkspace(
-  filePath: string,
-  workspace: string | null | undefined
-): string {
-  if (!workspace) {
-    // No workspace configured — allow any path
-    return filePath
-  }
-
-  const wsRoot = path.resolve(expandPath(workspace))
-
-  let resolved: string
-  if (path.isAbsolute(filePath)) {
-    resolved = path.normalize(filePath)
-  } else {
-    resolved = path.resolve(wsRoot, filePath)
-  }
-
-  // Ensure the resolved path is inside the workspace
-  const relative = path.relative(wsRoot, resolved)
-  if (relative.startsWith("..") || path.isAbsolute(relative)) {
-    throw new Error(
-      `[Workspace] Access denied: '${filePath}' resolves outside workspace '${wsRoot}'.`
-    )
-  }
-
-  return resolved
-}
-
-/**
- * Extract workspace from tool config (passed by agent-loop as config.configurable.workspace).
- */
-export function getWorkspace(config?: any): string | null | undefined {
-  return config?.configurable?.workspace ?? null
-}