@johpaz/hive 1.1.0

package/packages/core/src/tools/exec.ts

@@ -0,0 +1,140 @@
+import type { Tool } from "../agent/native-tools.ts";
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+function getShellCommand(): { cmd: string; args: string[] } {
+  const platform = process.platform;
+
+  if (platform === "win32") {
+    return { cmd: "cmd", args: ["/c"] };
+  } else if (platform === "darwin") {
+    return { cmd: "/bin/sh", args: ["-c"] };
+  }
+
+  // Linux: use full path so posix_spawn can find the binary
+  return { cmd: "/bin/sh", args: ["-c"] };
+}
+
+function getDefaultShell(): string {
+  const platform = process.platform;
+
+  if (platform === "win32") {
+    return "cmd.exe";
+  } else if (platform === "darwin") {
+    return "/bin/zsh";
+  }
+
+  return "/bin/bash";
+}
+
+export function createExecTool(config: Config): Tool | null {
+  const execConfig = config.tools?.exec;
+
+  if (!execConfig?.enabled) {
+    return null;
+  }
+
+  const allowlist = execConfig.allowlist ?? [];
+  const denylist = execConfig.denylist ?? [
+    "rm -rf /",
+    "sudo",
+    "chmod 777",
+    "> /dev/",
+    "mkfs",
+    "del /f /s /q",
+    "format",
+  ];
+  const timeout = (execConfig.timeoutSeconds ?? 30) * 1000;
+  const workDir = execConfig.workDir?.replace(/^~/, process.env.USERPROFILE ?? process.env.HOME ?? "") ?? process.cwd();
+
+  const log = logger.child("exec");
+  const shell = getShellCommand();
+
+  const isAllowed = (command: string): { allowed: boolean; reason?: string } => {
+    if (allowlist.length > 0) {
+      const baseCmd = command.split(" ")[0] ?? "";
+      if (!allowlist.some((allowed) => baseCmd === allowed || command.startsWith(allowed))) {
+        return { allowed: false, reason: `Command not in allowlist: ${baseCmd}` };
+      }
+    }
+
+    for (const denied of denylist) {
+      if (command.includes(denied)) {
+        return { allowed: false, reason: `Command matches denylist pattern: ${denied}` };
+      }
+    }
+
+    return { allowed: true };
+  };
+
+  return {
+    name: "exec",
+    description: "Execute shell commands with allowlist/denylist restrictions. Works on Windows, macOS, and Linux.",
+    parameters: {
+      type: "object",
+      properties: {
+        command: {
+          type: "string",
+          description: "The shell command to execute",
+        },
+        timeout: {
+          type: "number",
+          description: "Timeout in seconds (optional, default from config)",
+        },
+        cwd: {
+          type: "string",
+          description: "Working directory (optional)",
+        },
+      },
+      required: ["command"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const command = params.command as string;
+      const cmdTimeout = ((params.timeout as number) ?? timeout / 1000) * 1000;
+      const cwd = (params.cwd as string)?.replace(/^~/, process.env.USERPROFILE ?? process.env.HOME ?? "") ?? workDir;
+
+      const check = isAllowed(command);
+      if (!check.allowed) {
+        throw new Error(check.reason ?? "Command not allowed");
+      }
+
+      log.debug(`Executing on ${process.platform}: ${command}`);
+
+      try {
+        const shellCmd = getShellCommand();
+        
+        const proc = Bun.spawn([shellCmd.cmd, ...shellCmd.args, command], {
+          cwd,
+          timeout: cmdTimeout,
+          maxBuffer: 10 * 1024 * 1024,
+        });
+
+        const stdout = await new Response(proc.stdout).text();
+        const stderr = await new Response(proc.stderr).text();
+        const exitCode = await proc.exited;
+
+        if (exitCode === 0) {
+          return {
+            stdout: stdout.slice(-10000),
+            stderr: stderr.slice(-5000),
+            exitCode,
+            platform: process.platform,
+            shell: getDefaultShell(),
+          };
+        } else {
+          throw new Error(`Command exited with code ${exitCode}: ${stderr.slice(0, 500)}`);
+        }
+      } catch (error) {
+        const err = error as Error;
+        if (err.message.includes("exit") || err.message.includes("ENOENT")) {
+          const shellInfo = process.platform === "win32" 
+            ? "Windows requires cmd.exe. Make sure the shell is available."
+            : "Make sure sh or bash is available.";
+          throw new Error(`Failed to execute command: ${err.message}. ${shellInfo}`);
+        }
+        log.error(`Exec failed: ${err.message}`);
+        throw new Error(`Failed to execute command: ${err.message}`);
+      }
+    },
+  };
+}

package/packages/core/src/tools/fs.ts

@@ -0,0 +1,364 @@
+import type { Tool } from "../agent/native-tools.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/packages/core/src/tools/index.ts

@@ -0,0 +1,12 @@
+export * from "./project-management.ts";
+export * from "./read.ts";
+export * from "./exec.ts";
+export * from "./web.ts";
+export * from "./notify.ts";
+export * from "./cron.ts";
+export * from "./fs.ts";
+export * from "./workspace.ts";
+export * from "./project.ts";
+export * from "./browser.ts";
+export * from "./memory.ts";
+export * from "./codebridge.ts";

package/packages/core/src/tools/memory.ts

@@ -0,0 +1,176 @@
+import type { Tool, ToolResult } from "../agent/native-tools.ts";
+import type { MemoryStore, Note } from "../memory/notes.ts";
+
+export function memoryWriteTool(memory: MemoryStore): Tool {
+  return {
+    name: "memory_write",
+    description: "Store information in long-term memory. Use this to remember important facts, user preferences, or context for future conversations.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "A descriptive title for this memory entry",
+        },
+        content: {
+          type: "string",
+          description: "The content to store in memory",
+        },
+      },
+      required: ["title", "content"],
+    },
+    execute: async (params: Record<string, unknown>): Promise<ToolResult> => {
+      const title = params.title as string;
+      const content = params.content as string;
+
+      if (!title || !content) {
+        return { success: false, error: "Title and content are required" };
+      }
+
+      const note = memory.write(title, content);
+      return {
+        success: true,
+        result: {
+          title: note.title,
+          updatedAt: note.updatedAt.toISOString(),
+        },
+      };
+    },
+  };
+}
+
+export function memoryReadTool(memory: MemoryStore): Tool {
+  return {
+    name: "memory_read",
+    description: "Retrieve information from long-term memory by title.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "The title of the memory entry to retrieve",
+        },
+      },
+      required: ["title"],
+    },
+    execute: async (params: Record<string, unknown>): Promise<ToolResult> => {
+      const title = params.title as string;
+
+      if (!title) {
+        return { success: false, error: "Title is required" };
+      }
+
+      const note = memory.read(title);
+      if (!note) {
+        return { success: false, error: `Memory not found: ${title}` };
+      }
+
+      return {
+        success: true,
+        result: {
+          title: note.title,
+          content: note.content,
+          createdAt: note.createdAt.toISOString(),
+          updatedAt: note.updatedAt.toISOString(),
+        },
+      };
+    },
+  };
+}
+
+export function memoryListTool(memory: MemoryStore): Tool {
+  return {
+    name: "memory_list",
+    description: "List all memory entries.",
+    parameters: {
+      type: "object",
+      properties: {},
+    },
+    execute: async (_params: Record<string, unknown>): Promise<ToolResult> => {
+      const notes = memory.list();
+      return {
+        success: true,
+        result: {
+          count: notes.length,
+          entries: notes.map((n) => ({ title: n.title })),
+        },
+      };
+    },
+  };
+}
+
+export function memorySearchTool(memory: MemoryStore): Tool {
+  return {
+    name: "memory_search",
+    description: "Search memory entries by content.",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query",
+        },
+      },
+      required: ["query"],
+    },
+    execute: async (params: Record<string, unknown>): Promise<ToolResult> => {
+      const query = params.query as string;
+
+      if (!query) {
+        return { success: false, error: "Query is required" };
+      }
+
+      const results = memory.search(query);
+      return {
+        success: true,
+        result: {
+          query,
+          count: results.length,
+          results: results.map((n: Note) => ({
+            title: n.title,
+            snippet: n.content.slice(0, 200) + (n.content.length > 200 ? "..." : ""),
+          })),
+        },
+      };
+    },
+  };
+}
+
+export function memoryDeleteTool(memory: MemoryStore): Tool {
+  return {
+    name: "memory_delete",
+    description: "Delete a memory entry by title.",
+    parameters: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "The title of the memory entry to delete",
+        },
+      },
+      required: ["title"],
+    },
+    execute: async (params: Record<string, unknown>): Promise<ToolResult> => {
+      const title = params.title as string;
+
+      if (!title) {
+        return { success: false, error: "Title is required" };
+      }
+
+      const deleted = memory.delete(title);
+      return {
+        success: deleted,
+        result: deleted ? { message: `Deleted: ${title}` } : { message: `Not found: ${title}` },
+        error: deleted ? undefined : `Memory not found: ${title}`,
+      };
+    },
+  };
+}
+
+export function registerMemoryTools(registry: { register: (tool: Tool) => void }, memory: MemoryStore): void {
+  registry.register(memoryWriteTool(memory));
+  registry.register(memoryReadTool(memory));
+  registry.register(memoryListTool(memory));
+  registry.register(memorySearchTool(memory));
+  registry.register(memoryDeleteTool(memory));
+}