@johpaz/hive 1.7.2 → 1.7.3

package/packages/core/src/tools/web/browser-type.ts

@@ -1,60 +0,0 @@
-/**
- * browser_type - Type text into a form field
- * 
- * @category web
- * @seedId browser_type
- * @spanish escribir formulario, tipear, campo de texto, input
- */
-
-import type { Tool } from "../types.ts";
-import { logger } from "../../utils/logger.ts";
-
-const log = logger.child("browser-type");
-
-export const browserTypeTool: Tool = {
-  name: "browser_type",
-  description: "Type text into a form field in the browser. Spanish: escribir formulario, tipear, campo de texto, input",
-  parameters: {
-    type: "object",
-    properties: {
-      selector: {
-        type: "string",
-        description: "CSS selector of the input field",
-      },
-      text: {
-        type: "string",
-        description: "Text to type into the field",
-      },
-      url: {
-        type: "string",
-        description: "URL of the page (if not already navigated)",
-      },
-    },
-    required: ["selector", "text"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const selector = params.selector as string;
-    const text = params.text as string;
-    const url = params.url as string | undefined;
-
-    log.info(`Typing into: ${selector}`);
-
-    try {
-      // Note: Real typing would require Puppeteer/Playwright
-      // This is a placeholder implementation
-      return {
-        ok: true,
-        message: "Type functionality requires browser automation (Puppeteer/Playwright)",
-        selector,
-        text,
-        url,
-      };
-    } catch (error) {
-      log.error(`Type failed: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Failed to type: ${(error as Error).message}`,
-      };
-    }
-  },
-};

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

@@ -1,31 +0,0 @@
-/**
- * Web Tools - 6 tools
- * 
- * @category web
- */
-
-import type { Tool } from "../types.ts";
-import { webSearchTool } from "./web-search.ts";
-import { webFetchTool } from "./web-fetch.ts";
-import { browserNavigateTool } from "./browser-navigate.ts";
-import { browserScreenshotTool } from "./browser-screenshot.ts";
-import { browserClickTool } from "./browser-click.ts";
-import { browserTypeTool } from "./browser-type.ts";
-
-export function createTools(): Tool[] {
-  return [
-    webSearchTool,
-    webFetchTool,
-    browserNavigateTool,
-    browserScreenshotTool,
-    browserClickTool,
-    browserTypeTool,
-  ];
-}
-
-export * from "./web-search.ts";
-export * from "./web-fetch.ts";
-export * from "./browser-navigate.ts";
-export * from "./browser-screenshot.ts";
-export * from "./browser-click.ts";
-export * from "./browser-type.ts";

package/packages/core/src/tools/web/web-fetch.ts

@@ -1,78 +0,0 @@
-/**
- * web_fetch - Fetch plain content from a URL
- * 
- * @category web
- * @seedId web_fetch
- * @spanish obtener página, descargar contenido, extraer texto de url
- */
-
-import type { Tool } from "../types.ts";
-import { logger } from "../../utils/logger.ts";
-
-const log = logger.child("web-fetch");
-
-export const webFetchTool: Tool = {
-  name: "web_fetch",
-  description: "Fetch plain content from a URL (lightweight, no JS). Spanish: obtener página, descargar contenido, extraer texto de url",
-  parameters: {
-    type: "object",
-    properties: {
-      url: {
-        type: "string",
-        description: "The URL to fetch content from",
-      },
-    },
-    required: ["url"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const url = params.url as string;
-
-    log.info(`Fetching: ${url}`);
-
-    try {
-      const response = await fetch(url, {
-        headers: {
-          "User-Agent": "Mozilla/5.0 (compatible; HiveBot/1.0)",
-        },
-      });
-
-      if (!response.ok) {
-        throw new Error(`HTTP ${response.status}: ${response.statusText}`);
-      }
-
-      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 if (contentType.includes("text/html")) {
-        const html = await response.text();
-        // Strip HTML tags
-        content = html
-          .replace(/<script[^>]*>[\s\S]*?<\/script>/gi, "")
-          .replace(/<style[^>]*>[\s\S]*?<\/style>/gi, "")
-          .replace(/<[^>]+>/g, " ")
-          .replace(/\s+/g, " ")
-          .trim()
-          .slice(0, 50000);
-      } else {
-        content = await response.text();
-      }
-
-      return {
-        ok: true,
-        url,
-        content,
-        contentType,
-        length: content.length,
-      };
-    } catch (error) {
-      log.error(`Fetch failed: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Failed to fetch URL: ${(error as Error).message}`,
-      };
-    }
-  },
-};

package/packages/core/src/tools/web/web-search.ts

@@ -1,123 +0,0 @@
-/**
- * web_search - Search the web for current information
- *
- * @category web
- * @seedId web_search
- * @spanish buscar en internet, búsqueda web, noticias, información
- */
-
-import type { Tool } from "../types.ts";
-import { logger } from "../../utils/logger.ts";
-
-const log = logger.child("web-search");
-
-const TIMEOUT_MS = 10_000;
-
-interface SearchResult {
-  title: string;
-  url: string;
-  snippet: string;
-}
-
-function decodeUddg(href: string): string {
-  try {
-    const uddg = new URL("https:" + href).searchParams.get("uddg");
-    return uddg ? decodeURIComponent(uddg) : href;
-  } catch {
-    return href;
-  }
-}
-
-function isAdUrl(url: string): boolean {
-  return url.includes("duckduckgo.com/y.js") || url.includes("ad_provider") || url.includes("ad_domain");
-}
-
-async function searchDuckDuckGo(query: string, numResults: number): Promise<SearchResult[]> {
-  const searchUrl = `https://html.duckduckgo.com/html/?q=${encodeURIComponent(query)}`;
-
-  log.info(`Requesting DuckDuckGo HTML: ${searchUrl}`);
-
-  const response = await fetch(searchUrl, {
-    signal: AbortSignal.timeout(TIMEOUT_MS),
-    headers: {
-      "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/120.0.0.0 Safari/537.36",
-    },
-  });
-
-  if (!response.ok) {
-    throw new Error(`DuckDuckGo request failed: ${response.status}`);
-  }
-
-  const html = await response.text();
-
-  // Extract links: href contains //duckduckgo.com/l/?uddg=ENCODED_URL
-  const hrefs = [...html.matchAll(/<a[^>]+class="result__a"[^>]*href="([^"]+)"/g)].map((m) => m[1]);
-  const titles = [...html.matchAll(/<a[^>]+class="result__a"[^>]*>([^<]+)<\/a>/g)].map((m) => m[1].trim());
-  const rawSnippets = [...html.matchAll(/class="result__snippet"[^>]*>([\s\S]{0,400}?)<\/a>/g)].map((m) =>
-    m[1].replace(/<[^>]+>/g, "").trim()
-  );
-
-  log.debug(`DDG parsed: ${hrefs.length} links, ${titles.length} titles, ${rawSnippets.length} snippets`);
-
-  const results: SearchResult[] = [];
-  let snippetIdx = 0;
-
-  for (let i = 0; i < hrefs.length && results.length < numResults; i++) {
-    const rawUrl = hrefs[i] ?? "";
-    const url = decodeUddg(rawUrl);
-
-    // Skip ads
-    if (isAdUrl(url) || isAdUrl(rawUrl)) {
-      snippetIdx++; // ads also consume a snippet slot
-      continue;
-    }
-
-    // Advance snippet index past ads
-    while (snippetIdx < rawSnippets.length && isAdUrl(rawSnippets[snippetIdx] ?? "")) {
-      snippetIdx++;
-    }
-
-    results.push({
-      title: titles[i] ?? url,
-      url,
-      snippet: rawSnippets[snippetIdx] ?? "",
-    });
-    snippetIdx++;
-  }
-
-  return results;
-}
-
-export const webSearchTool: Tool = {
-  name: "web_search",
-  description: "Search the web for current information and research. Spanish: buscar en internet, búsqueda web, noticias, información",
-  parameters: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: "The search query - be specific and include relevant keywords",
-      },
-      numResults: {
-        type: "number",
-        description: "Number of results to return (default: 5, max: 10)",
-      },
-    },
-    required: ["query"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const query = params.query as string;
-    const numResults = Math.min((params.numResults as number) ?? 5, 10);
-
-    log.info(`Web search: "${query}"`);
-
-    try {
-      const results = await searchDuckDuckGo(query, numResults);
-      log.info(`Web search returned ${results.length} results for "${query}"`);
-      return { ok: true, results, query, count: results.length };
-    } catch (error) {
-      log.error(`Search failed: ${(error as Error).message}`);
-      return { ok: false, error: `Web search failed: ${(error as Error).message}` };
-    }
-  },
-};

package/packages/core/src/utils/benchmark.ts

@@ -1,80 +0,0 @@
-/**
- * Utility for measuring resource usage (time and memory).
- */
-export class Benchmark {
-    private startTime: number = 0;
-    private startMem: NodeJS.MemoryUsage | null = null;
-    private name: string;
-
-    constructor(name: string = "Benchmark") {
-        this.name = name;
-    }
-
-    /**
-     * Starts the benchmark timer and records initial memory usage.
-     */
-    start() {
-        this.startTime = performance.now();
-        this.startMem = process.memoryUsage();
-        return this;
-    }
-
-    /**
-     * Stops the benchmark and returns the metrics.
-     */
-    stop() {
-        const endTime = performance.now();
-        const endMem = process.memoryUsage();
-        const duration = endTime - this.startTime;
-
-        const metrics = {
-            name: this.name,
-            durationMs: duration.toFixed(2),
-            heapUsed: this.formatMB(endMem.heapUsed),
-            heapTotal: this.formatMB(endMem.heapTotal),
-            rss: this.formatMB(endMem.rss),
-            external: this.formatMB(endMem.external),
-            heapDelta: this.startMem
-                ? this.formatMB(endMem.heapUsed - this.startMem.heapUsed)
-                : "0.00 MB",
-            raw: {
-                duration,
-                memory: endMem,
-                delta: this.startMem
-                    ? endMem.heapUsed - this.startMem.heapUsed
-                    : 0
-            }
-        };
-
-        return metrics;
-    }
-
-    /**
-     * Pretty-prints the benchmark results to the console.
-     */
-    print() {
-        const m = this.stop();
-        console.log(`\n📊 Benchmark: ${m.name}`);
-        console.table({
-            'Time': `${m.durationMs} ms`,
-            'Heap Used': m.heapUsed,
-            'Heap Total': m.heapTotal,
-            'RSS': m.rss,
-            'External': m.external,
-            'Memory Delta': m.heapDelta
-        });
-    }
-
-    private formatMB(bytes: number) {
-        return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
-    }
-
-    /**
-     * static helper for quick one-off benchmarks.
-     */
-    static async run(name: string, fn: () => Promise<any> | any) {
-        const b = new Benchmark(name).start();
-        await fn();
-        b.print();
-    }
-}

package/packages/core/src/utils/crypto.ts

@@ -1,73 +0,0 @@
-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/packages/core/src/utils/date.ts

@@ -1,42 +0,0 @@
-/**
- * Utility functions for user-specific date and time formatting.
- */
-
-export function getUserDate(timezone: string = "UTC", date: Date = new Date()): string {
-    try {
-        const formatter = new Intl.DateTimeFormat("en-GB", {
-            timeZone: timezone,
-            year: "numeric",
-            month: "2-digit",
-            day: "2-digit",
-        });
-        const parts = formatter.formatToParts(date);
-        const year = parts.find(p => p.type === "year")?.value;
-        const month = parts.find(p => p.type === "month")?.value;
-        const day = parts.find(p => p.type === "day")?.value;
-        return `${year}-${month}-${day}`;
-    } catch (e) {
-        // Fallback to UTC if timezone is invalid
-        return date.toISOString().split("T")[0];
-    }
-}
-
-export function getUserTime(timezone: string = "UTC", date: Date = new Date()): string {
-    try {
-        const formatter = new Intl.DateTimeFormat("en-GB", {
-            timeZone: timezone,
-            hour: "2-digit",
-            minute: "2-digit",
-            second: "2-digit",
-            hour12: false,
-        });
-        const parts = formatter.formatToParts(date);
-        const hour = parts.find(p => p.type === "hour")?.value;
-        const minute = parts.find(p => p.type === "minute")?.value;
-        const second = parts.find(p => p.type === "second")?.value;
-        return `${hour}:${minute}:${second}`;
-    } catch (e) {
-        // Fallback if formatting fails
-        return date.toISOString().split("T")[1].split(".")[0];
-    }
-}

package/packages/core/src/utils/index.ts

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