@johpaz/hive 1.7.2 → 1.7.3

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

@@ -1,257 +0,0 @@
-/**
- * Core Tools - 4 tools
- *
- * @category core
- */
-
-import type { Tool } from "../types.ts";
-import { getDb } from "../../storage/sqlite.ts";
-import { logger } from "../../utils/logger.ts";
-
-const log = logger.child("core");
-
-// ─── search_knowledge ────────────────────────────────────────────────────────
-
-export const searchKnowledgeTool: Tool = {
-  name: "search_knowledge",
-  description: "Busca herramientas (tools), habilidades (skills) o reglas del playbook en la base de conocimientos. Usa búsqueda full-text (FTS5).",
-  parameters: {
-    type: "object",
-    properties: {
-      query: {
-        type: "string",
-        description: "Término de búsqueda (nombre, descripción, categoría)",
-      },
-      type: {
-        type: "string",
-        enum: ["all", "tools", "skills", "playbook"],
-        description: "Tipo de conocimiento a buscar",
-      },
-      limit: {
-        type: "number",
-        description: "Máximo de resultados (default: 10)",
-      },
-    },
-    required: ["query"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const db = getDb();
-    const query = params.query as string;
-    const type = (params.type as string) ?? "all";
-    const limit = (params.limit as number) ?? 10;
-
-    try {
-      const escapedQuery = query.replace(/'/g, "''");
-      const normalizedQuery = escapedQuery.replace(/_/g, " ").trim();
-      const ftsMatch = normalizedQuery.includes(" ")
-        ? `"${normalizedQuery}"`
-        : `"${normalizedQuery}" OR ${normalizedQuery}*`;
-
-      const result: any = { query, type, tools: [], skills: [], playbook: [] };
-
-      // Search tools
-      if (type === "all" || type === "tools") {
-        const tools = db.query(`
-          SELECT t.id, t.name, t.description, t.category, t.enabled, t.active, bm25(tools_fts) as rank
-          FROM tools_fts
-          LEFT JOIN tools t ON t.name = tools_fts.name
-          WHERE tools_fts MATCH ?
-          ORDER BY rank
-          LIMIT ?
-        `).all(ftsMatch, limit) as any[];
-
-        result.tools = tools.map((t) => ({
-          id: t.id,
-          name: t.name,
-          description: t.description,
-          category: t.category,
-          enabled: t.enabled === 1,
-          active: t.active === 1,
-          rank: t.rank,
-        }));
-      }
-
-      // Search skills
-      if (type === "all" || type === "skills") {
-        const skills = db.query(`
-          SELECT s.id, s.name, s.category, s.tools, s.triggers, s.active, bm25(skills_fts) as rank
-          FROM skills_fts
-          JOIN skills s ON s.id = skills_fts.id
-          WHERE skills_fts MATCH ?
-          ORDER BY rank
-          LIMIT ?
-        `).all(ftsMatch, limit) as any[];
-
-        result.skills = skills.map((s) => ({
-          id: s.id,
-          name: s.name,
-          category: s.category,
-          tools: s.tools,
-          triggers: s.triggers,
-          active: s.active === 1,
-          rank: s.rank,
-        }));
-      }
-
-      // Search playbook
-      if (type === "all" || type === "playbook") {
-        const playbook = db.query(`
-          SELECT p.id, p.rule, p.category, p.applicable_to, p.helpful_count, p.harmful_count, p.active, bm25(playbook_fts) as rank
-          FROM playbook_fts
-          JOIN playbook p ON p.id = playbook_fts.rowid
-          WHERE playbook_fts MATCH ?
-          ORDER BY rank
-          LIMIT ?
-        `).all(ftsMatch, limit) as any[];
-
-        result.playbook = playbook.map((p) => ({
-          id: p.id,
-          rule: p.rule,
-          category: p.category,
-          applicable_to: p.applicable_to ? JSON.parse(p.applicable_to) : null,
-          helpful_count: p.helpful_count,
-          harmful_count: p.harmful_count,
-          active: p.active === 1,
-          rank: p.rank,
-        }));
-      }
-
-      result.totalResults = result.tools.length + result.skills.length + result.playbook.length;
-
-      return { ok: true, ...result };
-    } catch (error) {
-      return {
-        ok: false,
-        error: `Search failed: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-// ─── notify ──────────────────────────────────────────────────────────────────
-
-export const notifyTool: Tool = {
-  name: "notify",
-  description: "Send a notification to the user's active channel.",
-  parameters: {
-    type: "object",
-    properties: {
-      message: {
-        type: "string",
-        description: "Notification message",
-      },
-      channel: {
-        type: "string",
-        description: "Channel ID (optional, uses active channel if not specified)",
-      },
-    },
-    required: ["message"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const message = params.message as string;
-    const channel = (params.channel as string) ?? "webchat";
-
-    log.info(`Sending notification to ${channel}: ${message}`);
-
-    // Placeholder - real notification would use channel gateway
-    return {
-      ok: true,
-      message: "Notification sent.",
-      channel,
-    };
-  },
-};
-
-// ─── save_note (scratchpad) ──────────────────────────────────────────────────
-
-export const saveNoteTool: Tool = {
-  name: "save_note",
-  description: "Save a note to the scratchpad (survives context compression).",
-  parameters: {
-    type: "object",
-    properties: {
-      key: {
-        type: "string",
-        description: "Unique key for the note",
-      },
-      value: {
-        type: "string",
-        description: "Note content",
-      },
-      thread_id: {
-        type: "string",
-        description: "Thread ID (optional, uses current thread if not specified)",
-      },
-    },
-    required: ["key", "value"],
-  },
-  execute: async (params: Record<string, unknown>, config?: any) => {
-    const db = getDb();
-    const key = params.key as string;
-    const value = params.value as string;
-    const threadId = (params.thread_id as string) ?? config?.configurable?.thread_id ?? "default";
-
-    try {
-      db.query(`
-        INSERT OR REPLACE INTO scratchpad (thread_id, key, value, source, updated_at)
-        VALUES (?, ?, ?, 'agent', unixepoch())
-      `).run(threadId, key, value);
-
-      return { ok: true, key, message: "Note saved." };
-    } catch (error) {
-      return {
-        ok: false,
-        error: `Failed to save note: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-// ─── report_progress ─────────────────────────────────────────────────────────
-
-export const reportProgressTool: Tool = {
-  name: "report_progress",
-  description: "Report progress of a task in progress.",
-  parameters: {
-    type: "object",
-    properties: {
-      progress: {
-        type: "number",
-        description: "Progress percentage (0-100)",
-      },
-      message: {
-        type: "string",
-        description: "Progress message",
-      },
-      task_id: {
-        type: "string",
-        description: "Task or project ID",
-      },
-    },
-    required: ["progress", "message"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const progress = params.progress as number;
-    const message = params.message as string;
-    const taskId = (params.task_id as string) ?? null;
-
-    log.info(`Progress: ${progress}% - ${message}`);
-
-    // Update task progress if task_id provided
-    if (taskId) {
-      const db = getDb();
-      db.query(`UPDATE tasks SET progress = ?, updated_at = unixepoch() WHERE id = ?`).run(progress, taskId);
-    }
-
-    return {
-      ok: true,
-      progress,
-      message,
-      task_id: taskId,
-    };
-  },
-};
-
-export function createTools(): Tool[] {
-  return [searchKnowledgeTool, notifyTool, saveNoteTool, reportProgressTool];
-}

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

@@ -1,373 +0,0 @@
-/**
- * Cron Tools - 4 tools
- * 
- * @category cron
- */
-
-import type { Tool } from "../types.ts";
-import { getDb } from "../../storage/sqlite.ts";
-import { logger } from "../../utils/logger.ts";
-import { Cron } from "croner";
-
-const log = logger.child("cron");
-
-// ─── cron_add ────────────────────────────────────────────────────────────────
-
-export const cronAddTool: Tool = {
-  name: "cron_add",
-  description: "Schedule a recurring or one-time job using a cron expression. Spanish: programar tarea, recordatorio, alarma, automatizar horario",
-  parameters: {
-    type: "object",
-    properties: {
-      name: { type: "string", description: "Nombre de la tarea programada" },
-      cronExpression: { type: "string", description: "Expresión cron (5 campos: minuto hora día mes weekday)" },
-      taskType: { type: "string", description: "Tipo de tarea (message, project, etc.)" },
-      taskConfig: { type: "object", description: "Configuración de la tarea" },
-      maxRuns: { type: "number", description: "Máximo de ejecuciones. Usa 1 para tareas de una sola vez (one-shot). Omitir para recurrentes." },
-    },
-    required: ["name", "cronExpression"],
-  },
-  execute: async (params: Record<string, unknown>, config?: any) => {
-    const db = getDb();
-    const userId = config?.configurable?.user_id;
-    const name = (params.name || params.taskName || params.title || params.task) as string | undefined;
-    const cronExpression = (params.cronExpression || params.cron_expression || params.expression) as string | undefined;
-    const taskType = (params.taskType as string) ?? "message";
-    const taskConfig = params.taskConfig as Record<string, unknown> | undefined;
-    const maxRuns = params.maxRuns as number | undefined;
-
-    if (!name) {
-      return { ok: false, error: "Missing required field: name (job name)" };
-    }
-    if (!cronExpression) {
-      return { ok: false, error: "Missing required field: cronExpression (e.g. '0 9 * * *')" };
-    }
-
-    try {
-      // Validate and calculate next run
-      const cronInstance = new Cron(cronExpression);
-      const nextDate = cronInstance.nextRun();
-      cronInstance.stop(); // Solo era para calcular, el scheduler real lo relanzará
-      const nextRun = nextDate ? Math.floor(nextDate.getTime() / 1000) : null;
-
-      const jobId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
-
-      db.query(`
-        INSERT INTO cron_jobs (id, user_id, name, cron_expression, task_type, task_config, max_runs, enabled, next_run, created_at)
-        VALUES (?, ?, ?, ?, ?, ?, ?, 1, ?, unixepoch())
-      `).run(jobId, userId, name, cronExpression, taskType, JSON.stringify(taskConfig ?? {}), maxRuns ?? null, nextRun);
-
-      return {
-        ok: true,
-        jobId,
-        nextRun: nextDate?.toISOString() ?? null,
-        message: `Cron job "${name}" scheduled. Next run: ${nextDate?.toLocaleString() ?? "unknown"}`,
-      };
-    } catch (error) {
-      log.error(`Failed to add cron: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Invalid cron expression or database error: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-// ─── cron_list ───────────────────────────────────────────────────────────────
-
-export const cronListTool: Tool = {
-  name: "cron_list",
-  description: "List all scheduled cron jobs and next execution times. Spanish: ver tareas programadas, cronograma, próximos eventos",
-  parameters: {
-    type: "object",
-    properties: {
-      enabled: { type: "boolean", description: "Filter by enabled status" },
-    },
-  },
-  execute: async (params: Record<string, unknown>, config?: any) => {
-    const db = getDb();
-    const userId = config?.configurable?.user_id;
-    const enabledFilter = params.enabled as boolean | undefined;
-
-    try {
-      let query = "SELECT * FROM cron_jobs WHERE user_id = ?";
-      const args: any[] = [userId];
-
-      if (enabledFilter !== undefined) {
-        query += " AND enabled = ?";
-        args.push(enabledFilter ? 1 : 0);
-      }
-
-      query += " ORDER BY next_run ASC";
-
-      const jobs = db.query(query).all(...args) as any[];
-
-      return {
-        ok: true,
-        jobs: jobs.map((j) => ({
-          id: j.id,
-          name: j.name,
-          cronExpression: j.cron_expression,
-          taskType: j.task_type,
-          enabled: j.enabled === 1,
-          runCount: j.run_count,
-          nextRun: j.next_run ? new Date(j.next_run * 1000).toISOString() : null,
-        })),
-        count: jobs.length,
-      };
-    } catch (error) {
-      log.error(`Failed to list crons: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Failed to list cron jobs: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-// ─── cron_edit ───────────────────────────────────────────────────────────────
-
-export const cronEditTool: Tool = {
-  name: "cron_edit",
-  description: "Edit an existing cron job expression or config. Spanish: modificar horario, cambiar programación, editar cron",
-  parameters: {
-    type: "object",
-    properties: {
-      jobId: { type: "string", description: "ID del cron job" },
-      cronExpression: { type: "string", description: "Nueva expresión cron" },
-      taskConfig: { type: "object", description: "Nueva configuración" },
-    },
-    required: ["jobId"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const db = getDb();
-    const jobId = params.jobId as string;
-    const cronExpression = params.cronExpression as string | undefined;
-    const taskConfig = params.taskConfig as Record<string, unknown> | undefined;
-
-    try {
-      const updates: string[] = [];
-      const values: any[] = [];
-
-      if (cronExpression) {
-        new Cron(cronExpression); // Validate
-        updates.push("cron_expression = ?");
-        values.push(cronExpression);
-      }
-
-      if (taskConfig !== undefined) {
-        updates.push("task_config = ?");
-        values.push(JSON.stringify(taskConfig));
-      }
-
-      if (updates.length === 0) {
-        return { ok: false, error: "No changes provided" };
-      }
-
-      values.push(jobId);
-
-      const result = db.query(`UPDATE cron_jobs SET ${updates.join(", ")} WHERE id = ?`).run(...values);
-
-      if (result.changes === 0) {
-        return { ok: false, error: `Cron job not found: ${jobId}` };
-      }
-
-      return { ok: true, jobId, message: "Cron job updated." };
-    } catch (error) {
-      log.error(`Failed to edit cron: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Failed to edit cron job: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-// ─── cron_remove ─────────────────────────────────────────────────────────────
-
-export const cronRemoveTool: Tool = {
-  name: "cron_remove",
-  description: "Remove a scheduled cron job. Spanish: eliminar cron, cancelar recordatorio, borrar programación",
-  parameters: {
-    type: "object",
-    properties: {
-      jobId: { type: "string", description: "ID del cron job a eliminar" },
-    },
-    required: ["jobId"],
-  },
-  execute: async (params: Record<string, unknown>) => {
-    const db = getDb();
-    const jobId = params.jobId as string;
-
-    try {
-      const result = db.query("DELETE FROM cron_jobs WHERE id = ?").run(jobId);
-
-      if (result.changes === 0) {
-        return { ok: false, error: `Cron job not found: ${jobId}` };
-      }
-
-      return { ok: true, jobId, message: "Cron job removed." };
-    } catch (error) {
-      log.error(`Failed to remove cron: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Failed to remove cron job: ${(error as Error).message}`,
-      };
-    }
-  },
-};
-
-import crypto from "crypto";
-
-export function createTools(): Tool[] {
-  return [cronAddTool, cronListTool, cronEditTool, cronRemoveTool];
-}
-
-// Mapa de instancias Cron activas: jobId → Cron instance
-const activeJobs = new Map<string, InstanceType<typeof Cron>>();
-
-type CronCallback = (sessionId: string, task: string, jobId: string, context: { fecha_usuario: string; hora_usuario: string }) => void;
-
-function scheduleJob(
-  job: { id: string; user_id: string; name: string; cron_expression: string; max_runs: number | null; run_count: number; expires_at: number | null },
-  callback: CronCallback
-): void {
-  // Si ya hay una instancia activa para este job, la saltamos
-  if (activeJobs.has(job.id)) return;
-
-  try {
-    const instance = new Cron(job.cron_expression, { protect: true }, () => {
-      const db = getDb();
-      const now = Math.floor(Date.now() / 1000);
-
-      // Verificar expiración
-      if (job.expires_at && now > job.expires_at) {
-        log.info(`[cron] Job "${job.name}" (${job.id}) expired, stopping`);
-        instance.stop();
-        activeJobs.delete(job.id);
-        db.query("UPDATE cron_jobs SET enabled = 0 WHERE id = ?").run(job.id);
-        return;
-      }
-
-      // Actualizar run_count, last_run, next_run
-      const newRunCount = (job.run_count ?? 0) + 1;
-      const nextDate = instance.nextRun();
-      const nextRunTs = nextDate ? Math.floor(nextDate.getTime() / 1000) : null;
-
-      db.query(
-        "UPDATE cron_jobs SET run_count = ?, last_run = ?, next_run = ? WHERE id = ?"
-      ).run(newRunCount, now, nextRunTs, job.id);
-      job.run_count = newRunCount;
-
-      // Verificar max_runs
-      if (job.max_runs !== null && newRunCount >= job.max_runs) {
-        log.info(`[cron] Job "${job.name}" (${job.id}) reached max_runs=${job.max_runs}, stopping`);
-        instance.stop();
-        activeJobs.delete(job.id);
-        db.query("UPDATE cron_jobs SET enabled = 0 WHERE id = ?").run(job.id);
-        return;
-      }
-
-      // Auto-desactivar si no hay próxima ejecución en los próximos 366 días
-      // (detecta expresiones one-shot como "0 19 9 3 *" que croner reprograma al año siguiente)
-      if (!nextDate || nextDate.getTime() - Date.now() > 366 * 24 * 60 * 60 * 1000) {
-        log.info(`[cron] Job "${job.name}" (${job.id}) has no near future run (next=${nextDate?.toISOString() ?? "null"}), disabling`);
-        instance.stop();
-        activeJobs.delete(job.id);
-        db.query("UPDATE cron_jobs SET enabled = 0 WHERE id = ?").run(job.id);
-        return;
-      }
-
-      // Contexto de fecha/hora local
-      const now_date = new Date();
-      const context = {
-        fecha_usuario: now_date.toLocaleDateString("es-ES"),
-        hora_usuario: now_date.toLocaleTimeString("es-ES"),
-      };
-
-      log.info(`[cron] Firing job "${job.name}" (${job.id}) run #${newRunCount}`);
-      callback(job.user_id, job.name, job.id, context);
-    });
-
-    activeJobs.set(job.id, instance);
-
-    // Actualizar next_run inicial en BD
-    const nextDate = instance.nextRun();
-    if (nextDate) {
-      getDb()
-        .query("UPDATE cron_jobs SET next_run = ? WHERE id = ?")
-        .run(Math.floor(nextDate.getTime() / 1000), job.id);
-    }
-
-    log.info(`[cron] Scheduled job "${job.name}" (${job.id}) — next: ${instance.nextRun()?.toISOString() ?? "unknown"}`);
-  } catch (err) {
-    log.error(`[cron] Failed to schedule job "${job.name}" (${job.id}): ${(err as Error).message}`);
-  }
-}
-
-/**
- * Initialize the cron scheduler.
- * Loads all enabled jobs from the DB and schedules them.
- * Polls every 30s for new jobs added after startup.
- */
-export function initCronScheduler(callback: CronCallback): void {
-  const db = getDb();
-
-  const loadAndSchedule = () => {
-    const jobs = db.query(`
-      SELECT id, user_id, name, cron_expression, max_runs, run_count, expires_at
-      FROM cron_jobs
-      WHERE enabled = 1
-    `).all() as { id: string; user_id: string; name: string; cron_expression: string; max_runs: number | null; run_count: number; expires_at: number | null }[];
-
-    for (const job of jobs) {
-      scheduleJob(job, callback);
-    }
-
-    // Detener jobs que ya no están en BD o están deshabilitados
-    const activeIds = new Set(jobs.map((j) => j.id));
-    for (const [jobId, instance] of activeJobs) {
-      if (!activeIds.has(jobId)) {
-        log.info(`[cron] Stopping removed/disabled job ${jobId}`);
-        instance.stop();
-        activeJobs.delete(jobId);
-      }
-    }
-  };
-
-  // Carga inicial
-  loadAndSchedule();
-
-  // Poll cada 30s para detectar nuevos jobs o jobs eliminados
-  setInterval(loadAndSchedule, 30_000);
-
-  log.info(`[cron] Scheduler initialized with ${activeJobs.size} active jobs`);
-}
-
-/**
- * Resolve the best channel TYPE ("webchat", "telegram", etc.) for cron notifications.
- * Priority: explicit notify_channel_id → user_identities (first registered) → "webchat"
- */
-export function resolveBestChannel(userId: string, notifyChannelId?: string | null): string {
-  // 1. Explicit channel set on the job
-  if (notifyChannelId) return notifyChannelId;
-
-  // 2. Look up which channels the user has registered identities for
-  try {
-    const db = getDb();
-    const identities = db.query<{ channel: string }, [string]>(
-      "SELECT channel FROM user_identities WHERE user_id = ? ORDER BY channel ASC LIMIT 5"
-    ).all(userId);
-
-    // Prefer telegram if available (most reliable for async notifications)
-    const preferred = ["telegram", "discord", "slack", "whatsapp"];
-    for (const p of preferred) {
-      if (identities.some((i) => i.channel === p)) return p;
-    }
-  } catch {
-    // DB not ready or no identities — fall through
-  }
-
-  // 3. Default to webchat
-  return "webchat";
-}

package/packages/core/src/tools/filesystem/fs-delete.ts

@@ -1,78 +0,0 @@
-/**
- * fs_delete - Delete file or directory from workspace
- * 
- * @category filesystem
- * @seedId fs_delete
- * @spanish eliminar archivo, borrar archivo, borrar carpeta
- */
-
-import type { Tool } from "../types.ts";
-import { logger } from "../../utils/logger.ts";
-import { resolveInWorkspace, getWorkspace } from "./workspace-guard.ts";
-import * as fs from "node:fs";
-
-const log = logger.child("fs-delete");
-
-export const fsDeleteTool: Tool = {
-  name: "fs_delete",
-  description: "Delete file or directory from workspace. Spanish: eliminar archivo, borrar archivo, borrar carpeta",
-  parameters: {
-    type: "object",
-    properties: {
-      path: {
-        type: "string",
-        description: "Path to the file or directory to delete",
-      },
-      recursive: {
-        type: "boolean",
-        description: "Delete recursively for directories (default: false)",
-      },
-    },
-    required: ["path"],
-  },
-  execute: async (params: Record<string, unknown>, config?: any) => {
-    const workspace = getWorkspace(config);
-    let targetPath: string;
-    try {
-      targetPath = resolveInWorkspace(params.path as string, workspace);
-    } catch (e) {
-      return { ok: false, error: (e as Error).message };
-    }
-    const recursive = (params.recursive as boolean) ?? false;
-
-    log.debug(`Deleting: ${targetPath}`);
-
-    try {
-      if (!fs.existsSync(targetPath)) {
-        return {
-          ok: false,
-          error: `Path not found: ${targetPath}`,
-        };
-      }
-
-      const stats = fs.statSync(targetPath);
-
-      if (stats.isDirectory()) {
-        if (recursive) {
-          fs.rmSync(targetPath, { recursive: true });
-        } else {
-          fs.rmdirSync(targetPath);
-        }
-      } else {
-        fs.unlinkSync(targetPath);
-      }
-
-      return {
-        ok: true,
-        path: targetPath,
-        deleted: true,
-      };
-    } catch (error) {
-      log.error(`Error deleting: ${(error as Error).message}`);
-      return {
-        ok: false,
-        error: `Failed to delete: ${(error as Error).message}`,
-      };
-    }
-  },
-};