@johpaz/hive 1.1.0

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

@@ -0,0 +1,436 @@
+import type { Tool } from "../agent/native-tools.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 on any topic. Use this to find up-to-date information, news, research, or current events.",
+    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 triggered: "${query}"`, { numResults });
+
+      // Try multiple search endpoints for better results
+      const searchResults = await searchWithFallbacks(query, numResults, timeout, log);
+
+      return {
+        results: searchResults,
+        query,
+        count: searchResults.length,
+      };
+    },
+  };
+}
+
+async function searchWithFallbacks(
+  query: string,
+  numResults: number,
+  timeout: number,
+  log: any
+): Promise<SearchResult[]> {
+  // Fallback 1: DuckDuckGo HTML search (more reliable)
+  try {
+    return await searchDuckDuckGoHTML(query, numResults, timeout, log);
+  } catch (error) {
+    log.warn(`DuckDuckGo HTML failed: ${(error as Error).message}`);
+  }
+
+  // Fallback 2: DuckDuckGo API
+  try {
+    return await searchDuckDuckGoAPI(query, numResults, timeout, log);
+  } catch (error) {
+    log.warn(`DuckDuckGo API failed: ${(error as Error).message}`);
+  }
+
+  // Fallback 3: Bing (via HTML scraping)
+  try {
+    return await searchBing(query, numResults, timeout, log);
+  } catch (error) {
+    log.warn(`Bing failed: ${(error as Error).message}`);
+  }
+
+  throw new Error("All search providers failed");
+}
+
+async function searchDuckDuckGoHTML(
+  query: string,
+  numResults: number,
+  timeout: number,
+  log: any
+): 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),
+    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",
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`DuckDuckGo HTML failed: ${response.status}`);
+  }
+
+  const html = await response.text();
+  log.debug(`HTML response length: ${html.length} chars`);
+
+  const results: SearchResult[] = [];
+
+  // DuckDuckGo HTML structure: result snippets are in <div class="result"> elements
+  // More robust parsing
+  const resultBlockRegex = /<div[^>]*class="result[^"]*"[^>]*>([\s\S]*?)<\/div>/gi;
+  let resultBlock;
+
+  while ((resultBlock = resultBlockRegex.exec(html)) && results.length < numResults) {
+    const block = resultBlock[1];
+
+    // Extract title
+    const titleMatch = block.match(/<a[^>]*class="result__a"[^>]*href="([^"]*)"[^>]*>([^<]*)<\/a>/i);
+    if (!titleMatch) continue;
+
+    const url = decodeDuckDuckGoUrl(titleMatch[1]);
+    const title = titleMatch[2].replace(/<[^>]+>/g, "").trim();
+
+    // Extract snippet
+    const snippetMatch = block.match(/<a[^>]*class="result__snippet"[^>]*>([\s\S]*?)<\/a>/i);
+    const snippet = snippetMatch
+      ? snippetMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim()
+      : "";
+
+    if (url && title && url.startsWith("http")) {
+      results.push({ title, url, snippet });
+      log.debug(`Found result: ${title} - ${url}`);
+    }
+  }
+
+  log.debug(`Found ${results.length} results from DuckDuckGo HTML`);
+
+  // If no results found with class-based parsing, try alternative approach
+  if (results.length === 0) {
+    log.debug("Trying alternative parsing method...");
+    // Try to find any links that look like search results
+    const linkRegex = /<a[^>]*href="(https?:\/\/[^"]+)"[^>]*>([^<]+)<\/a>/gi;
+    let linkMatch;
+    let count = 0;
+
+    while ((linkMatch = linkRegex.exec(html)) && count < numResults) {
+      const url = linkMatch[1];
+      const title = linkMatch[2].replace(/<[^>]+>/g, "").trim();
+
+      // Filter out DuckDuckGo's own links
+      if (!url.includes("duckduckgo.com") &&
+        !url.includes("about:") &&
+        !url.includes("javascript:") &&
+        title.length > 10) {
+        results.push({ title, url, snippet: "" });
+        count++;
+      }
+    }
+
+    log.debug(`Alternative parsing found ${results.length} results`);
+  }
+
+  return results;
+}
+
+function decodeDuckDuckGoUrl(url: string): string {
+  // DuckDuckGo uses a redirect URL, extract the actual URL
+  if (url.includes("uddg=")) {
+    const match = url.match(/uddg=([^&]+)/);
+    if (match) {
+      return decodeURIComponent(match[1]);
+    }
+  }
+  // If it's a relative URL or starts with http, return as is
+  if (url.startsWith("http://") || url.startsWith("https://")) {
+    return url;
+  }
+  return url;
+}
+
+async function searchDuckDuckGoAPI(
+  query: string,
+  numResults: number,
+  timeout: number,
+  log: any
+): Promise<SearchResult[]> {
+  const searchUrl = `https://api.duckduckgo.com/?q=${encodeURIComponent(query)}&format=json&no_html=1&no_redirect=1&skip_disambig=1`;
+
+  log.info(`Requesting DuckDuckGo API: ${searchUrl}`);
+
+  const response = await fetch(searchUrl, {
+    signal: AbortSignal.timeout(timeout),
+    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 API failed: ${response.status}`);
+  }
+
+  const data = await response.json() as {
+    AbstractText?: string;
+    AbstractURL?: string;
+    Heading?: string;
+    RelatedTopics?: Array<{
+      Text?: string;
+      FirstURL?: string;
+      Content?: string;
+      Topics?: Array<{ Text?: string; FirstURL?: string }>;
+    }>;
+    Results?: Array<{ Text?: string; FirstURL?: string }>;
+  };
+
+  log.debug(`DuckDuckGo API response: ${JSON.stringify({
+    hasAbstract: !!data.AbstractText,
+    relatedTopics: data.RelatedTopics?.length || 0,
+    results: data.Results?.length || 0
+  })}`);
+
+  const results: SearchResult[] = [];
+
+  // Add abstract if available
+  if (data.AbstractText && data.AbstractURL) {
+    results.push({
+      title: data.Heading || "Summary",
+      url: data.AbstractURL,
+      snippet: data.AbstractText,
+    });
+  }
+
+  // Add RelatedTopics (can be nested)
+  if (data.RelatedTopics) {
+    for (const topic of data.RelatedTopics) {
+      if (results.length >= numResults) break;
+
+      // Direct topic
+      if (topic.Text && topic.FirstURL) {
+        results.push({
+          title: topic.Text.split(" - ")[0] ?? "Result",
+          url: topic.FirstURL,
+          snippet: topic.Text,
+        });
+      }
+      // Nested topics
+      else if (topic.Topics) {
+        for (const subTopic of topic.Topics) {
+          if (results.length >= numResults) break;
+          if (subTopic.Text && subTopic.FirstURL) {
+            results.push({
+              title: subTopic.Text.split(" - ")[0] ?? "Result",
+              url: subTopic.FirstURL,
+              snippet: subTopic.Text,
+            });
+          }
+        }
+      }
+    }
+  }
+
+  // Add Results if available
+  if (data.Results) {
+    for (const result of data.Results) {
+      if (results.length >= numResults) break;
+      if (result.Text && result.FirstURL) {
+        results.push({
+          title: result.Text.split(" - ")[0] ?? "Result",
+          url: result.FirstURL,
+          snippet: result.Text,
+        });
+      }
+    }
+  }
+
+  log.debug(`Found ${results.length} results from DuckDuckGo API`);
+  return results;
+}
+
+async function searchBing(
+  query: string,
+  numResults: number,
+  timeout: number,
+  log: any
+): Promise<SearchResult[]> {
+  const searchUrl = `https://www.bing.com/search?q=${encodeURIComponent(query)}`;
+
+  log.info(`Requesting Bing: ${searchUrl}`);
+
+  const response = await fetch(searchUrl, {
+    signal: AbortSignal.timeout(timeout),
+    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",
+      "Accept": "text/html,application/xhtml+xml,application/xml;q=0.9,image/webp,*/*;q=0.8",
+      "Accept-Language": "en-US,en;q=0.5",
+    },
+  });
+
+  if (!response.ok) {
+    throw new Error(`Bing failed: ${response.status}`);
+  }
+
+  const html = await response.text();
+  log.debug(`Bing HTML response: ${html.length} chars`);
+
+  const results: SearchResult[] = [];
+
+  // Bing result structure: <li class="b_algo"> contains each result
+  const algoRegex = /<li[^>]*class="[^"]*b_algo[^"]*"[^>]*>([\s\S]*?)<\/li>/gi;
+  let algoMatch;
+
+  while ((algoMatch = algoRegex.exec(html)) && results.length < numResults) {
+    const content = algoMatch[1];
+
+    // Extract title and URL from <h2><a>
+    const linkMatch = content.match(/<h2[^>]*><a[^>]*href="([^"]+)"[^>]*>([^<]+)<\/a>/i);
+    if (!linkMatch) continue;
+
+    const url = linkMatch[1];
+    const title = linkMatch[2].replace(/<[^>]+>/g, "").trim();
+
+    // Extract snippet from <p class="b_caption">
+    const snippetMatch = content.match(/<p[^>]*class="[^"]*b_caption[^"]*"[^>]*>([\s\S]*?)<\/p>/i);
+    const snippet = snippetMatch
+      ? snippetMatch[1].replace(/<[^>]+>/g, " ").replace(/\s+/g, " ").trim()
+      : "";
+
+    if (url && title && url.startsWith("http")) {
+      results.push({ title, url, snippet });
+      log.debug(`Bing result: ${title}`);
+    }
+  }
+
+  log.debug(`Found ${results.length} results from Bing`);
+  return results;
+}
+
+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.info(`Web fetch triggered: ${url}`, { maxLength });
+
+      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/packages/core/src/tools/workspace.ts

@@ -0,0 +1,171 @@
+import type { Tool } from "../agent/native-tools.ts";
+import type { WorkspaceLoader } from "../agent/workspace.ts";
+
+export function createWorkspaceTools(loader: WorkspaceLoader): Tool[] {
+  return [
+    {
+      name: "workspace_read",
+      description:
+        "Lee el contenido actual de SOUL.md (tu identidad), " +
+        "USER.md (contexto del usuario) o ETHICS.md (lineamientos éticos). " +
+        "Usa esta herramienta cuando necesites consultar tu configuración actual " +
+        "o verificar qué información tienes sobre el usuario.",
+      parameters: {
+        type: "object",
+        properties: {
+          file: {
+            type: "string",
+            enum: ["soul", "user", "ethics"],
+            description:
+              "soul = tu identidad y personalidad, " +
+              "user = información sobre el usuario, " +
+              "ethics = lineamientos éticos (solo lectura)",
+          },
+        },
+        required: ["file"],
+      },
+      execute: async (params: Record<string, unknown>) => {
+        const file = params.file as "soul" | "user" | "ethics";
+        const content = await loader.read(file);
+        return {
+          file,
+          content,
+          length: content.length,
+        };
+      },
+    },
+
+    {
+      name: "workspace_write",
+      description:
+        "Reescribe completamente SOUL.md o USER.md. " +
+        "Usa esta herramienta solo cuando necesites hacer cambios extensos. " +
+        "Para cambios pequeños, usa workspace_patch en su lugar. " +
+        "NUNCA puedes escribir en ETHICS.md.",
+      parameters: {
+        type: "object",
+        properties: {
+          file: {
+            type: "string",
+            enum: ["soul", "user"],
+            description: "El archivo a escribir. ETHICS.md no está permitido.",
+          },
+          content: {
+            type: "string",
+            description: "El contenido completo del archivo en formato Markdown.",
+          },
+          reason: {
+            type: "string",
+            description:
+              "Razón del cambio. Se registra en los logs. " +
+              "Ej: 'Usuario indicó nueva ubicación'",
+          },
+        },
+        required: ["file", "content", "reason"],
+      },
+      execute: async (params: Record<string, unknown>) => {
+        const file = params.file as "soul" | "user";
+        const content = params.content as string;
+        const reason = params.reason as string;
+        await loader.write(file, content);
+        return {
+          ok: true,
+          file,
+          reason,
+          savedAt: new Date().toISOString(),
+          message: `${file}.md actualizado correctamente`,
+        };
+      },
+    },
+
+    {
+      name: "workspace_patch",
+      description:
+        "Modifica una sección específica de SOUL.md o USER.md " +
+        "sin reescribir el archivo completo. " +
+        "Esta es la herramienta preferida para cambios pequeños y precisos. " +
+        "La sección se identifica por su encabezado Markdown (## Sección). " +
+        "Si la sección no existe, se crea al final del archivo.",
+      parameters: {
+        type: "object",
+        properties: {
+          file: {
+            type: "string",
+            enum: ["soul", "user"],
+            description: "El archivo a modificar.",
+          },
+          section: {
+            type: "string",
+            description:
+              "El nombre de la sección a modificar, sin los ## del encabezado. " +
+              "Ej: 'Ubicación', 'Preferencias', 'Trabajo'",
+          },
+          newContent: {
+            type: "string",
+            description: "El nuevo contenido de esa sección en Markdown.",
+          },
+          reason: {
+            type: "string",
+            description: "Razón del cambio para el registro de logs.",
+          },
+        },
+        required: ["file", "section", "newContent", "reason"],
+      },
+      execute: async (params: Record<string, unknown>) => {
+        const file = params.file as "soul" | "user";
+        const section = params.section as string;
+        const newContent = params.newContent as string;
+        const reason = params.reason as string;
+        await loader.patch(file, section, newContent);
+        return {
+          ok: true,
+          file,
+          section,
+          reason,
+          savedAt: new Date().toISOString(),
+          message: `Sección "${section}" de ${file}.md actualizada`,
+        };
+      },
+    },
+
+    {
+      name: "workspace_append",
+      description:
+        "Añade nueva información a una sección de USER.md " +
+        "sin eliminar el contenido existente. " +
+        "Ideal para acumular información sobre el usuario con el tiempo.",
+      parameters: {
+        type: "object",
+        properties: {
+          section: {
+            type: "string",
+            description: "El nombre de la sección donde añadir la información.",
+          },
+          content: {
+            type: "string",
+            description: "La información a añadir.",
+          },
+          reason: {
+            type: "string",
+            description: "Por qué se añade esta información.",
+          },
+        },
+        required: ["section", "content", "reason"],
+      },
+      execute: async (params: Record<string, unknown>) => {
+        const section = params.section as string;
+        const content = params.content as string;
+        const reason = params.reason as string;
+        await loader.append("user", section, content);
+        return {
+          ok: true,
+          file: "user",
+          section,
+          reason,
+          savedAt: new Date().toISOString(),
+          message: `Información añadida a la sección "${section}" de USER.md`,
+        };
+      },
+    },
+  ];
+}

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

@@ -0,0 +1,80 @@
+/**
+ * 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();
+    }
+}