@johpaz/hive-core 1.0.7 → 1.0.10

package/src/tools/dynamic-registry.ts

@@ -0,0 +1,258 @@
+import { z } from "zod";
+import { eventBus } from "../events/event-bus.ts";
+import { logger } from "../utils/logger.ts";
+import type { ToolDefinition, ParameterDefinition } from "../plugins/api.ts";
+import type { Tool } from "./registry.ts";
+
+function parameterToZod(param: ParameterDefinition): z.ZodTypeAny {
+  let schema: z.ZodTypeAny;
+
+  switch (param.type) {
+    case "string":
+      schema = z.string();
+      if (param.enum && param.enum.length > 0) {
+        schema = z.enum([param.enum[0]!, ...param.enum.slice(1)]);
+      }
+      break;
+    case "number":
+      schema = z.number();
+      break;
+    case "boolean":
+      schema = z.boolean();
+      break;
+    case "array":
+      schema = param.items
+        ? z.array(parameterToZod(param.items))
+        : z.array(z.unknown());
+      break;
+    case "object":
+      if (param.properties) {
+        const shape: Record<string, z.ZodTypeAny> = {};
+        for (const [key, value] of Object.entries(param.properties)) {
+          shape[key] = parameterToZod(value);
+        }
+        schema = z.object(shape);
+      } else {
+        schema = z.record(z.string(), z.unknown());
+      }
+      break;
+    default:
+      schema = z.unknown();
+  }
+
+  if (!param.required && param.default === undefined) {
+    schema = schema.optional();
+  }
+
+  return schema;
+}
+
+function buildSchemaFromParameters(
+  parameters: Record<string, ParameterDefinition>
+): z.ZodObject<any> {
+  const shape: Record<string, z.ZodTypeAny> = {};
+
+  for (const [key, param] of Object.entries(parameters)) {
+    shape[key] = parameterToZod(param);
+  }
+
+  return z.object(shape);
+}
+
+export interface RegisteredTool extends ToolDefinition {
+  schema: z.ZodObject<any>;
+  registeredAt: number;
+  pluginName?: string;
+}
+
+export class DynamicToolRegistry {
+  private tools: Map<string, RegisteredTool> = new Map();
+  private log = logger.child("tools");
+
+  register(definition: ToolDefinition, pluginName?: string): void {
+    if (this.tools.has(definition.name)) {
+      this.log.warn(`Tool ${definition.name} already registered, replacing`);
+    }
+
+    const schema = buildSchemaFromParameters(definition.parameters);
+
+    const wrappedExecute = this.wrapWithValidation(
+      definition.execute,
+      schema,
+      definition.name
+    );
+
+    const registered: RegisteredTool = {
+      ...definition,
+      execute: wrappedExecute,
+      schema,
+      registeredAt: Date.now(),
+      pluginName,
+    };
+
+    this.tools.set(definition.name, registered);
+
+    eventBus.emit("tool:completed", {
+      toolName: definition.name,
+      result: { registered: true },
+      duration: 0,
+      success: true,
+    });
+
+    this.log.info(`Tool registered: ${definition.name}`, {
+      plugin: pluginName ?? "core",
+    });
+  }
+
+  unregister(name: string): void {
+    if (!this.tools.has(name)) {
+      this.log.warn(`Tool ${name} not found, cannot unregister`);
+      return;
+    }
+
+    this.tools.delete(name);
+
+    this.log.info(`Tool unregistered: ${name}`);
+  }
+
+  private wrapWithValidation(
+    fn: (args: Record<string, unknown>) => Promise<unknown>,
+    schema: z.ZodObject<any>,
+    toolName: string
+  ): (args: Record<string, unknown>) => Promise<unknown> {
+    return async (args: Record<string, unknown>) => {
+      const startTime = Date.now();
+
+      try {
+        const validated = schema.parse(args);
+        const result = await fn(validated);
+
+        const duration = Date.now() - startTime;
+        eventBus.emit("tool:completed", {
+          toolName,
+          result,
+          duration,
+          success: true,
+        });
+
+        return result;
+      } catch (error) {
+        const duration = Date.now() - startTime;
+
+        if (error instanceof z.ZodError) {
+          const zodErr = error as z.ZodError;
+          const errorMessages = zodErr.issues
+            .map((e: z.ZodIssue) => `${e.path.join(".")}: ${e.message}`)
+            .join(", ");
+
+          const validationError = new Error(
+            `Validation failed for tool ${toolName}: ${errorMessages}`
+          );
+          (validationError as any).zodError = error;
+
+          eventBus.emit("tool:error", {
+            toolName,
+            error: validationError,
+            args,
+          });
+
+          throw validationError;
+        }
+
+        eventBus.emit("tool:error", {
+          toolName,
+          error: error as Error,
+          args,
+        });
+
+        throw error;
+      }
+    };
+  }
+
+  get(name: string): RegisteredTool | undefined {
+    return this.tools.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  list(): RegisteredTool[] {
+    return Array.from(this.tools.values());
+  }
+
+  listByPlugin(pluginName: string): RegisteredTool[] {
+    return this.list().filter((t) => t.pluginName === pluginName);
+  }
+
+  listNames(): string[] {
+    return Array.from(this.tools.keys());
+  }
+
+  clear(): void {
+    this.tools.clear();
+    this.log.info("All tools cleared");
+  }
+
+  toToolInterface(name: string): Tool | undefined {
+    const registered = this.tools.get(name);
+    if (!registered) return undefined;
+
+    return {
+      name: registered.name,
+      description: registered.description,
+      parameters: {
+        type: "object",
+        properties: this.parametersToProperties(registered.parameters),
+        required: Object.entries(registered.parameters)
+          .filter(([, p]) => p.required)
+          .map(([key]) => key),
+      },
+      execute: registered.execute,
+    };
+  }
+
+  private parametersToProperties(
+    parameters: Record<string, ParameterDefinition>
+  ): Record<string, { type: string; description?: string }> {
+    const properties: Record<string, { type: string; description?: string }> = {};
+
+    for (const [key, param] of Object.entries(parameters)) {
+      properties[key] = {
+        type: param.type,
+        description: param.description,
+      };
+    }
+
+    return properties;
+  }
+
+  getStats(): {
+    total: number;
+    byPlugin: Record<string, number>;
+    oldestRegistration?: number;
+    newestRegistration?: number;
+  } {
+    const byPlugin: Record<string, number> = {};
+    let oldest: number | undefined;
+    let newest: number | undefined;
+
+    for (const tool of this.tools.values()) {
+      const plugin = tool.pluginName ?? "core";
+      byPlugin[plugin] = (byPlugin[plugin] ?? 0) + 1;
+
+      if (!oldest || tool.registeredAt < oldest) oldest = tool.registeredAt;
+      if (!newest || tool.registeredAt > newest) newest = tool.registeredAt;
+    }
+
+    return {
+      total: this.tools.size,
+      byPlugin,
+      oldestRegistration: oldest,
+      newestRegistration: newest,
+    };
+  }
+}
+
+export const dynamicToolRegistry = new DynamicToolRegistry();

package/src/tools/fs.test.ts

@@ -0,0 +1,127 @@
+import { describe, it, expect, beforeEach, afterEach } from "bun:test";
+import * as fs from "fs/promises";
+import * as path from "path";
+import type { Config } from "../config/loader.ts";
+import { createFSReadTool, createFSWriteTool, createFSListTool, createFSMkdirTool, createFSDeleteTool } from "./fs.ts";
+
+const TEST_DIR = "/tmp/hive-fs-test";
+
+describe("FileSystem Tools", () => {
+  const config = {
+    tools: {
+      fs: {
+        allowedPaths: [TEST_DIR],
+        sandboxed: true,
+      },
+    },
+  } as unknown as Config;
+
+  beforeEach(async () => {
+    await fs.mkdir(TEST_DIR, { recursive: true });
+  });
+
+  afterEach(async () => {
+    await fs.rm(TEST_DIR, { recursive: true, force: true });
+  });
+
+  describe("fs_read", () => {
+    it("should read file content", async () => {
+      const tool = createFSReadTool(config);
+      const testFile = path.join(TEST_DIR, "test.txt");
+      await fs.writeFile(testFile, "Hello World");
+
+      const result = (await tool.execute({ path: testFile })) as {
+        success: boolean;
+        content: string;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.content).toBe("Hello World");
+    });
+
+    it("should reject paths outside allowed paths", async () => {
+      const tool = createFSReadTool(config);
+
+      await expect(tool.execute({ path: "/etc/passwd" })).rejects.toThrow("not in allowed paths");
+    });
+  });
+
+  describe("fs_write", () => {
+    it("should write content to file", async () => {
+      const tool = createFSWriteTool(config);
+      const testFile = path.join(TEST_DIR, "output.txt");
+
+      const result = (await tool.execute({ path: testFile, content: "Test content" })) as {
+        success: boolean;
+        bytesWritten: number;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.bytesWritten).toBe(12);
+
+      const content = await fs.readFile(testFile, "utf-8");
+      expect(content).toBe("Test content");
+    });
+  });
+
+  describe("fs_list", () => {
+    it("should list directory contents", async () => {
+      const tool = createFSListTool(config);
+      await fs.writeFile(path.join(TEST_DIR, "file1.txt"), "content");
+      await fs.mkdir(path.join(TEST_DIR, "subdir"));
+
+      const result = (await tool.execute({ path: TEST_DIR })) as {
+        success: boolean;
+        count: number;
+        entries: Array<{ name: string; type: string }>;
+      };
+
+      expect(result.success).toBe(true);
+      expect(result.count).toBe(2);
+      expect(result.entries).toContainEqual(
+        expect.objectContaining({ name: "file1.txt", type: "file" })
+      );
+      expect(result.entries).toContainEqual(
+        expect.objectContaining({ name: "subdir", type: "directory" })
+      );
+    });
+  });
+
+  describe("fs_mkdir", () => {
+    it("should create directory", async () => {
+      const tool = createFSMkdirTool(config);
+      const newDir = path.join(TEST_DIR, "newdir");
+
+      const result = (await tool.execute({ path: newDir })) as { success: boolean };
+
+      expect(result.success).toBe(true);
+
+      const stat = await fs.stat(newDir);
+      expect(stat.isDirectory()).toBe(true);
+    });
+  });
+
+  describe("fs_delete", () => {
+    it("should delete file", async () => {
+      const tool = createFSDeleteTool(config);
+      const testFile = path.join(TEST_DIR, "todelete.txt");
+      await fs.writeFile(testFile, "delete me");
+
+      const result = (await tool.execute({ path: testFile })) as { success: boolean };
+
+      expect(result.success).toBe(true);
+      await expect(fs.stat(testFile)).rejects.toThrow();
+    });
+
+    it("should delete directory with recursive flag", async () => {
+      const tool = createFSDeleteTool(config);
+      const testDir = path.join(TEST_DIR, "toDelete");
+      await fs.mkdir(testDir);
+      await fs.writeFile(path.join(testDir, "file.txt"), "content");
+
+      const result = (await tool.execute({ path: testDir, recursive: true })) as { success: boolean };
+
+      expect(result.success).toBe(true);
+    });
+  });
+});