@johpaz/hive-core 0.1.1

package/src/tools/read.ts

@@ -0,0 +1,154 @@
+import * as fs from "node:fs";
+import * as path from "node:path";
+import type { Tool } from "./registry.ts";
+
+export const readTool: Tool = {
+  name: "read",
+  description: "Read the contents of a file",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path to the file to read",
+      },
+      offset: {
+        type: "number",
+        description: "Line number to start reading from (1-indexed)",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum number of lines to read",
+      },
+    },
+    required: ["path"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const filePath = params.path as string;
+    const offset = (params.offset as number) ?? 1;
+    const limit = (params.limit as number) ?? 2000;
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const stats = fs.statSync(filePath);
+    if (stats.isDirectory()) {
+      const entries = fs.readdirSync(filePath, { withFileTypes: true });
+      return entries.map((e) => ({
+        name: e.name,
+        type: e.isDirectory() ? "directory" : "file",
+      }));
+    }
+
+    const content = fs.readFileSync(filePath, "utf-8");
+    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");
+  },
+};
+
+export const writeTool: Tool = {
+  name: "write",
+  description: "Write content to a file (creates or overwrites)",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path to the file to write",
+      },
+      content: {
+        type: "string",
+        description: "The content to write to the file",
+      },
+    },
+    required: ["path", "content"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const filePath = params.path as string;
+    const content = params.content as string;
+
+    const dir = path.dirname(filePath);
+    if (!fs.existsSync(dir)) {
+      fs.mkdirSync(dir, { recursive: true });
+    }
+
+    fs.writeFileSync(filePath, content, "utf-8");
+    
+    return { success: true, path: filePath, bytes: content.length };
+  },
+};
+
+export const editTool: Tool = {
+  name: "edit",
+  description: "Edit a file by replacing specific text",
+  parameters: {
+    type: "object",
+    properties: {
+      path: {
+        type: "string",
+        description: "The path to the file to edit",
+      },
+      oldString: {
+        type: "string",
+        description: "The text to search for",
+      },
+      newString: {
+        type: "string",
+        description: "The text to replace with",
+      },
+      replaceAll: {
+        type: "boolean",
+        description: "Replace all occurrences",
+      },
+    },
+    required: ["path", "oldString", "newString"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const filePath = params.path as string;
+    const oldString = params.oldString as string;
+    const newString = params.newString as string;
+    const replaceAll = (params.replaceAll as boolean) ?? false;
+
+    if (!fs.existsSync(filePath)) {
+      throw new Error(`File not found: ${filePath}`);
+    }
+
+    const content = fs.readFileSync(filePath, "utf-8");
+
+    if (!content.includes(oldString)) {
+      throw new Error(`String not found in file: ${oldString.substring(0, 50)}...`);
+    }
+
+    let newContent: string;
+    if (replaceAll) {
+      newContent = content.split(oldString).join(newString);
+    } else {
+      const index = content.indexOf(oldString);
+      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");
+    
+    return { success: true, path: filePath };
+  },
+};

package/src/tools/registry.ts

@@ -0,0 +1,115 @@
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: Record<string, unknown>;
+  execute: (params: Record<string, unknown>) => Promise<unknown>;
+}
+
+export interface ToolResult {
+  success: boolean;
+  result?: unknown;
+  error?: string;
+}
+
+export class ToolRegistry {
+  private tools: Map<string, Tool> = new Map();
+  private config: Config;
+  private log = logger.child("tools");
+
+  constructor(config: Config) {
+    this.config = config;
+  }
+
+  register(tool: Tool): void {
+    if (this.tools.has(tool.name)) {
+      this.log.warn(`Tool ${tool.name} already registered, overwriting`);
+    }
+    this.tools.set(tool.name, tool);
+    this.log.debug(`Registered tool: ${tool.name}`);
+  }
+
+  unregister(name: string): boolean {
+    return this.tools.delete(name);
+  }
+
+  get(name: string): Tool | undefined {
+    return this.tools.get(name);
+  }
+
+  has(name: string): boolean {
+    return this.tools.has(name);
+  }
+
+  list(): Tool[] {
+    return Array.from(this.tools.values());
+  }
+
+  isAllowed(name: string, sessionType?: "main" | "dm" | "group"): boolean {
+    const deny = this.config.tools?.deny ?? [];
+    const allow = this.config.tools?.allow ?? [];
+
+    if (deny.includes(name)) {
+      return false;
+    }
+
+    if (sessionType === "dm") {
+      const dmDeny = this.config.tools?.sandbox?.dm?.deny ?? [];
+      if (dmDeny.includes(name)) {
+        return false;
+      }
+    }
+
+    if (sessionType === "group") {
+      const groupDeny = this.config.tools?.sandbox?.group?.deny ?? [];
+      if (groupDeny.includes(name)) {
+        return false;
+      }
+    }
+
+    if (allow.length === 0) {
+      return true;
+    }
+
+    return allow.includes(name);
+  }
+
+  async execute(
+    name: string,
+    params: Record<string, unknown>,
+    sessionType?: "main" | "dm" | "group"
+  ): Promise<ToolResult> {
+    if (!this.isAllowed(name, sessionType)) {
+      return {
+        success: false,
+        error: `Tool ${name} is not allowed for this session type`,
+      };
+    }
+
+    const tool = this.tools.get(name);
+    if (!tool) {
+      return {
+        success: false,
+        error: `Tool ${name} not found`,
+      };
+    }
+
+    try {
+      this.log.debug(`Executing tool: ${name}`, { params });
+      const result = await tool.execute(params);
+      return { success: true, result };
+    } catch (error) {
+      this.log.error(`Tool ${name} failed: ${(error as Error).message}`);
+      return {
+        success: false,
+        error: (error as Error).message,
+      };
+    }
+  }
+}
+
+export function createToolRegistry(config: Config): ToolRegistry {
+  return new ToolRegistry(config);
+}

package/src/tools/web.ts

@@ -0,0 +1,186 @@
+import type { Tool } from "./registry.ts";
+import type { Config } from "../config/loader.ts";
+import { logger } from "../utils/logger.ts";
+import { retry } from "../utils/retry.ts";
+
+export interface SearchResult {
+  title: string;
+  url: string;
+  snippet: string;
+}
+
+export function createWebSearchTool(config: Config): Tool {
+  const webConfig = config.tools?.web ?? {};
+  const allowlist = webConfig.allowlist ?? [];
+  const denylist = webConfig.denylist ?? ["file://", "ftp://"];
+  const timeout = (webConfig.timeoutSeconds ?? 30) * 1000;
+
+  const log = logger.child("web");
+
+  const isUrlAllowed = (url: string): boolean => {
+    for (const denied of denylist) {
+      if (url.startsWith(denied)) return false;
+    }
+    if (allowlist.length === 0) return true;
+    return allowlist.some((allowed) => url.includes(allowed));
+  };
+
+  return {
+    name: "web_search",
+    description: "Search the web for current information",
+    parameters: {
+      type: "object",
+      properties: {
+        query: {
+          type: "string",
+          description: "The search query",
+        },
+        numResults: {
+          type: "number",
+          description: "Number of results to return (default: 5)",
+        },
+      },
+      required: ["query"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const query = params.query as string;
+      const numResults = (params.numResults as number) ?? 5;
+
+      log.debug(`Searching: ${query}`);
+
+      const searchUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1`;
+
+      try {
+        const response = await fetch(searchUrl, {
+          signal: AbortSignal.timeout(timeout),
+        });
+
+        if (!response.ok) {
+          throw new Error(`Search failed: ${response.status}`);
+        }
+
+        const data = await response.json() as {
+          AbstractText?: string;
+          AbstractURL?: string;
+          RelatedTopics?: Array<{ Text?: string; FirstURL?: string }>;
+        };
+
+        const results: SearchResult[] = [];
+
+        if (data.AbstractText && data.AbstractURL) {
+          results.push({
+            title: "Summary",
+            url: data.AbstractURL,
+            snippet: data.AbstractText,
+          });
+        }
+
+        if (data.RelatedTopics) {
+          for (const topic of data.RelatedTopics.slice(0, numResults - 1)) {
+            if (topic.Text && topic.FirstURL && isUrlAllowed(topic.FirstURL)) {
+              results.push({
+                title: topic.Text.split(" - ")[0] ?? "Result",
+                url: topic.FirstURL,
+                snippet: topic.Text,
+              });
+            }
+          }
+        }
+
+        return { results, query };
+      } catch (error) {
+        log.error(`Search failed: ${(error as Error).message}`);
+        throw error;
+      }
+    },
+  };
+}
+
+export function createWebFetchTool(config: Config): Tool {
+  const webConfig = config.tools?.web ?? {};
+  const allowlist = webConfig.allowlist ?? [];
+  const denylist = webConfig.denylist ?? ["file://", "ftp://"];
+  const timeout = (webConfig.timeoutSeconds ?? 30) * 1000;
+
+  const log = logger.child("web");
+
+  const isUrlAllowed = (url: string): boolean => {
+    for (const denied of denylist) {
+      if (url.startsWith(denied)) return false;
+    }
+    if (allowlist.length === 0) return true;
+    return allowlist.some((allowed) => url.includes(allowed));
+  };
+
+  return {
+    name: "web_fetch",
+    description: "Fetch content from a URL",
+    parameters: {
+      type: "object",
+      properties: {
+        url: {
+          type: "string",
+          description: "The URL to fetch",
+        },
+        selector: {
+          type: "string",
+          description: "CSS selector to extract specific content (optional)",
+        },
+        maxLength: {
+          type: "number",
+          description: "Maximum characters to return (default: 10000)",
+        },
+      },
+      required: ["url"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const url = params.url as string;
+      const maxLength = (params.maxLength as number) ?? 10000;
+
+      if (!isUrlAllowed(url)) {
+        throw new Error(`URL not allowed: ${url}`);
+      }
+
+      log.debug(`Fetching: ${url}`);
+
+      return retry(
+        async () => {
+          const response = await fetch(url, {
+            signal: AbortSignal.timeout(timeout),
+            headers: {
+              "User-Agent": "Mozilla/5.0 (compatible; Hive/0.1)",
+            },
+          });
+
+          if (!response.ok) {
+            throw new Error(`Fetch failed: ${response.status}`);
+          }
+
+          const contentType = response.headers.get("content-type") ?? "";
+          let content: string;
+
+          if (contentType.includes("application/json")) {
+            const json = await response.json();
+            content = JSON.stringify(json, null, 2);
+          } else {
+            content = await response.text();
+            
+            content = content
+              .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
+              .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
+              .replace(/<[^>]+>/g, " ")
+              .replace(/\s+/g, " ")
+              .trim();
+          }
+
+          if (content.length > maxLength) {
+            content = content.slice(0, maxLength) + "\n... (truncated)";
+          }
+
+          return { content, url, contentType };
+        },
+        { maxAttempts: 2, initialDelayMs: 1000 }
+      );
+    },
+  };
+}

package/src/utils/crypto.ts

@@ -0,0 +1,73 @@
+import * as crypto from "node:crypto";
+
+export function generateId(): string {
+  return crypto.randomUUID();
+}
+
+export function generateShortId(length = 8): string {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let result = "";
+  const randomBytes = crypto.randomBytes(length);
+  
+  for (let i = 0; i < length; i++) {
+    result += chars[randomBytes[i]! % chars.length];
+  }
+  
+  return result;
+}
+
+export function hashString(input: string): string {
+  return crypto.createHash("sha256").update(input).digest("hex");
+}
+
+export function hashObject(obj: unknown): string {
+  return hashString(JSON.stringify(obj));
+}
+
+export async function hmacSign(
+  key: string,
+  data: string,
+  algorithm: "sha256" | "sha512" = "sha256"
+): Promise<string> {
+  return crypto.createHmac(algorithm, key).update(data).digest("hex");
+}
+
+export async function hmacVerify(
+  key: string,
+  data: string,
+  signature: string,
+  algorithm: "sha256" | "sha512" = "sha256"
+): Promise<boolean> {
+  const expected = await hmacSign(key, data, algorithm);
+  return crypto.timingSafeEqual(
+    Buffer.from(expected),
+    Buffer.from(signature)
+  );
+}
+
+export function encrypt(text: string, key: string): string {
+  const iv = crypto.randomBytes(16);
+  const derivedKey = crypto.scryptSync(key, "salt", 32);
+  const cipher = crypto.createCipheriv("aes-256-cbc", derivedKey, iv);
+  
+  let encrypted = cipher.update(text, "utf8", "hex");
+  encrypted += cipher.final("hex");
+  
+  return iv.toString("hex") + ":" + encrypted;
+}
+
+export function decrypt(encryptedData: string, key: string): string {
+  const [ivHex, encrypted] = encryptedData.split(":");
+  if (!ivHex || !encrypted) {
+    throw new Error("Invalid encrypted data format");
+  }
+  
+  const iv = Buffer.from(ivHex, "hex");
+  const derivedKey = crypto.scryptSync(key, "salt", 32);
+  const decipher = crypto.createDecipheriv("aes-256-cbc", derivedKey, iv);
+  
+  let decrypted = decipher.update(encrypted, "hex", "utf8");
+  decrypted += decipher.final("utf8");
+  
+  return decrypted;
+}

package/src/utils/index.ts

@@ -0,0 +1,3 @@
+export * from "./logger.ts";
+export * from "./retry.ts";
+export * from "./crypto.ts";