@johpaz/hive 1.1.0

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

@@ -0,0 +1,113 @@
+import type { Tool } from "../agent/native-tools.ts";
+import { logger } from "../utils/logger.ts";
+
+export function createReportProgressTool(): Tool {
+  const log = logger.child("report-progress");
+
+  return {
+    name: "report_progress",
+    description: "Report progress to the user while processing tasks in background. Use this to keep the user informed about what you're doing.",
+    parameters: {
+      type: "object",
+      properties: {
+        status: {
+          type: "string",
+          enum: ["started", "thinking", "searching", "processing", "writing", "completed", "error", "info"],
+          description: "Current status of the task",
+        },
+        message: {
+          type: "string",
+          description: "Progress message to show the user (keep it short and clear)",
+        },
+        progress: {
+          type: "number",
+          description: "Optional progress percentage (0-100)",
+        },
+      },
+      required: ["status", "message"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const status = params.status as string;
+      const message = params.message as string;
+      const progress = params.progress as number | undefined;
+
+      log.debug(`Progress: [${status}] ${message}`);
+
+      // Return the progress info - it will be sent to the user by the framework
+      return {
+        success: true,
+        status,
+        message,
+        progress,
+        _sendToUser: true, // Flag to indicate this should be sent to the user
+      };
+    },
+  };
+}
+
+export function createNotifyTool(): Tool {
+  const log = logger.child("notify");
+
+  return {
+    name: "notify",
+    description: "Send a system notification or report progress to user",
+    parameters: {
+      type: "object",
+      properties: {
+        title: {
+          type: "string",
+          description: "Notification title or status (info, searching, processing, completed, error)",
+        },
+        message: {
+          type: "string",
+          description: "Message to show the user",
+        },
+        urgency: {
+          type: "string",
+          enum: ["low", "normal", "critical"],
+          description: "Notification urgency level (for system notifications)",
+        },
+        type: {
+          type: "string",
+          enum: ["progress", "notification"],
+          description: "Type of notification (progress shows to user, notification shows system popup)",
+        },
+      },
+      required: ["title", "message"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+      const title = params.title as string;
+      const message = params.message as string;
+      const urgency = (params.urgency as string) ?? "normal";
+      const type = (params.type as string) ?? "progress";
+
+      log.debug(`Notify: [${type}] ${title} - ${message}`);
+
+      // Si es tipo progress, retornar con flag para enviar al usuario
+      if (type === "progress") {
+        return {
+          success: true,
+          status: title,
+          message,
+          _sendToUser: true,
+        };
+      }
+
+      // Para notificaciones del sistema
+      if (process.platform === "darwin") {
+        const cmd = `osascript -e 'display notification "${message}" with title "${title}"'`;
+        await Bun.$`${{ raw: cmd }}`.quiet();
+      } else if (process.platform === "linux") {
+        const urgencyFlag = urgency === "critical" ? "-u critical" : urgency === "low" ? "-u low" : "";
+        const cmd = `notify-send ${urgencyFlag} "${title}" "${message}"`;
+        await Bun.$`${{ raw: cmd }}`.quiet().catch(() => {
+          log.warn("notify-send not available");
+        });
+      } else {
+        log.warn(`Notifications not supported on ${process.platform}`);
+      }
+
+      return { success: true, title, message };
+    },
+  };
+}

package/packages/core/src/tools/project-management.ts

@@ -0,0 +1,376 @@
+import { getDb } from "../storage/sqlite";
+import { dbService } from "../storage/sqlite";
+import type { Tool } from "../agent/native-tools";
+import { logger } from "../utils/logger";
+import { getUserDate, getUserTime } from "../utils/date";
+import { emitCanvas } from "../canvas/emitter";
+
+const log = logger.child("project-tools");
+
+// ── project_create ────────────────────────────────────────────────────────────
+// Crea un proyecto completo con sus tareas iniciales en una sola llamada.
+// Emite nodos canvas para el proyecto y cada tarea.
+export const projectCreateTool: Tool = {
+    name: "project_create",
+    description: "Crea un proyecto con sus tareas. Úsalo al inicio de cualquier tarea compleja (más de 2 pasos, código, investigación, etc.). Permite definir el tipo de proyecto y las tareas atómicas que lo componen.",
+    parameters: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Nombre descriptivo del proyecto" },
+            description: { type: "string", description: "Descripción detallada del objetivo del proyecto" },
+            type: {
+                type: "string",
+                enum: ["general", "code", "research", "content", "data"],
+                description: "Tipo de proyecto: code (desarrollo), research (investigación), content (escritura/docs), data (análisis), general (otro)"
+            },
+            tasks: {
+                type: "array",
+                description: "Lista de tareas atómicas que componen el proyecto",
+                items: {
+                    type: "object",
+                    properties: {
+                        name: { type: "string", description: "Nombre corto de la tarea" },
+                        description: { type: "string", description: "Qué debe hacer esta tarea" },
+                        agent_id: { type: "string", description: "ID del agente asignado (opcional)" },
+                    },
+                    required: ["name"],
+                },
+            },
+        },
+        required: ["name", "type"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+        const name = params.name as string;
+        const description = (params.description as string) ?? "";
+        const type = (params.type as string) ?? "general";
+        const tasks = (params.tasks as any[]) ?? [];
+
+        const db = getDb();
+        const userId = config?.configurable?.user_id || process.env.HIVE_USER_ID;
+        if (!userId) throw new Error("User ID requerido.");
+
+        const agentId = config?.configurable?.agent_id ?? null;
+
+        const userRow = db.query<any, [string]>("SELECT timezone FROM users WHERE id = ?").get(userId);
+        const userTimezone = userRow?.timezone || "UTC";
+        const fecha = getUserDate(userTimezone);
+        const hora = getUserTime(userTimezone);
+
+        const projectId = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+        log.info(`Creating project: ${name} (${type}) ID: ${projectId} [${fecha} ${hora}]`);
+
+        db.query(`
+            INSERT INTO projects (id, user_id, agent_id, name, description, type, task, status, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, ?, 'active', unixepoch(), unixepoch())
+        `).run(projectId, userId, agentId, name, description, type, description);
+
+        // Emitir nodo de proyecto al canvas
+        emitCanvas("canvas:node_add", {
+            id: `project_${projectId}`,
+            type: "project",
+            label: name,
+            data: { status: "active", progress: 0, projectType: type, taskCount: tasks.length, agentId },
+        });
+
+        // Crear tareas
+        const taskIds: number[] = [];
+        for (const t of tasks) {
+            const taskId = dbService.createTask({
+                project_id: projectId,
+                agent_id: t.agent_id ?? agentId,
+                name: t.name,
+                description: t.description ?? null,
+            });
+            taskIds.push(taskId);
+
+            emitCanvas("canvas:node_add", {
+                id: `task_${taskId}`,
+                type: "task",
+                label: t.name,
+                data: { status: "pending", progress: 0, projectId, agentId: t.agent_id ?? agentId },
+            });
+            emitCanvas("canvas:edge_add", {
+                id: `edge_proj_task_${taskId}`,
+                source: `project_${projectId}`,
+                target: `task_${taskId}`,
+                edgeType: "contains",
+            });
+
+            // Si hay agente asignado, conectar tarea → agente
+            if (t.agent_id || agentId) {
+                emitCanvas("canvas:edge_add", {
+                    id: `edge_task_agent_${taskId}`,
+                    source: `task_${taskId}`,
+                    target: t.agent_id ?? agentId,
+                    edgeType: "assigned_to",
+                });
+            }
+        }
+
+        return {
+            success: true,
+            projectId,
+            taskIds,
+            message: `Proyecto "${name}" creado con ${tasks.length} tarea(s).`,
+        };
+    },
+};
+
+// ── project_start (legacy, mantiene compatibilidad) ───────────────────────────
+export const projectStartTool: Tool = {
+    name: "project_start",
+    description: "Crea un nuevo proyecto para tareas que requieren más de dos pasos. Proporciona un nombre descriptivo y la tarea general.",
+    parameters: {
+        type: "object",
+        properties: {
+            name: { type: "string", description: "Nombre descriptivo del proyecto" },
+            task: { type: "string", description: "Descripción de la tarea general" },
+            parentId: { type: "string", description: "ID del proyecto padre (opcional, para subproyectos)" },
+        },
+        required: ["name", "task"],
+    },
+    execute: async (params: Record<string, unknown>, config?: any) => {
+        const name = params.name as string;
+        const task = params.task as string;
+        const parentId = params.parentId as string | undefined;
+        const db = getDb();
+        const id = crypto.randomUUID().replace(/-/g, "").slice(0, 16);
+        const userId = config?.configurable?.user_id || process.env.HIVE_USER_ID;
+        if (!userId) throw new Error("User ID is required to create a project.");
+        const agentId = config?.configurable?.agent_id || "main";
+
+        const userRow = db.query<any, [string]>("SELECT timezone FROM users WHERE id = ?").get(userId);
+        const userTimezone = userRow?.timezone || "UTC";
+        const fecha_usuario = getUserDate(userTimezone);
+        const hora_usuario = getUserTime(userTimezone);
+
+        log.info(`Creating project: ${name} (ID: ${id}) [${fecha_usuario} ${hora_usuario}]`);
+
+        db.query(`
+            INSERT INTO projects (id, user_id, agent_id, name, task, parent_id, status, created_at, updated_at)
+            VALUES (?, ?, ?, ?, ?, ?, 'active', unixepoch(), unixepoch())
+        `).run(id, userId, agentId, name, task, parentId ?? null);
+
+        emitCanvas("canvas:node_add", {
+            id: `project_${id}`,
+            type: "project",
+            label: name,
+            data: { status: "active", progress: 0, projectType: "general", agentId },
+        });
+
+        return { success: true, projectId: id, message: `Proyecto "${name}" iniciado.` };
+    },
+};
+
+// ── project_update ────────────────────────────────────────────────────────────
+export const projectUpdateTool: Tool = {
+    name: "project_update",
+    description: "Actualiza el progreso y describe el siguiente paso de un proyecto activo. Úsalo antes de cada paso importante.",
+    parameters: {
+        type: "object",
+        properties: {
+            projectId: { type: "string", description: "ID del proyecto a actualizar" },
+            progress: { type: "number", description: "Progreso actual (0-100)" },
+            stepDescription: { type: "string", description: "Descripción del paso actual o siguiente" },
+        },
+        required: ["projectId", "progress", "stepDescription"],
+    },
+    execute: async (params: { projectId: string; progress: number; stepDescription: string }) => {
+        const db = getDb();
+        log.info(`Updating project ${params.projectId}: ${params.progress}% - ${params.stepDescription}`);
+
+        const result = db.query(`
+            UPDATE projects SET progress = ?, context = ?, updated_at = unixepoch() WHERE id = ?
+        `).run(params.progress, params.stepDescription, params.projectId);
+
+        if (result.changes === 0) throw new Error(`Proyecto con ID ${params.projectId} no encontrado.`);
+
+        emitCanvas("canvas:node_update", {
+            id: `project_${params.projectId}`,
+            data: { progress: params.progress, lastStep: params.stepDescription },
+        });
+
+        return { success: true, message: `Proyecto actualizado: ${params.progress}% - ${params.stepDescription}` };
+    },
+};
+
+// ── project_done ──────────────────────────────────────────────────────────────
+export const projectDoneTool: Tool = {
+    name: "project_done",
+    description: "Marca un proyecto como completado exitosamente cuando la tarea ha terminado.",
+    parameters: {
+        type: "object",
+        properties: {
+            projectId: { type: "string", description: "ID del proyecto completado" },
+            summary: { type: "string", description: "Resumen final de lo logrado" },
+        },
+        required: ["projectId"],
+    },
+    execute: async (params: { projectId: string; summary?: string }) => {
+        const db = getDb();
+        log.info(`Completing project ${params.projectId}`);
+
+        const result = db.query(`
+            UPDATE projects SET status = 'done', progress = 100, updated_at = unixepoch(), completed_at = unixepoch(), context = ?
+            WHERE id = ?
+        `).run(params.summary ?? "Tarea completada exitosamente.", params.projectId);
+
+        if (result.changes === 0) throw new Error(`Proyecto con ID ${params.projectId} no encontrado.`);
+
+        emitCanvas("canvas:node_update", {
+            id: `project_${params.projectId}`,
+            data: { status: "done", progress: 100 },
+        });
+
+        return { success: true, message: "Proyecto marcado como completado." };
+    },
+};
+
+// ── project_fail ──────────────────────────────────────────────────────────────
+export const projectFailTool: Tool = {
+    name: "project_fail",
+    description: "Marca un proyecto como fallido cuando ocurre un error irrecuperable.",
+    parameters: {
+        type: "object",
+        properties: {
+            projectId: { type: "string", description: "ID del proyecto fallido" },
+            reason: { type: "string", description: "Razón del fallo" },
+        },
+        required: ["projectId", "reason"],
+    },
+    execute: async (params: { projectId: string; reason: string }) => {
+        const db = getDb();
+        log.error(`Project ${params.projectId} failed: ${params.reason}`);
+
+        const result = db.query(`
+            UPDATE projects SET status = 'failed', updated_at = unixepoch(), context = ? WHERE id = ?
+        `).run(params.reason, params.projectId);
+
+        if (result.changes === 0) throw new Error(`Proyecto con ID ${params.projectId} no encontrado.`);
+
+        emitCanvas("canvas:node_update", {
+            id: `project_${params.projectId}`,
+            data: { status: "failed" },
+        });
+
+        return { success: true, message: "Proyecto marcado como fallido." };
+    },
+};
+
+// ── task_create ───────────────────────────────────────────────────────────────
+export const taskCreateTool: Tool = {
+    name: "task_create",
+    description: "Agrega una nueva tarea a un proyecto existente. Opcionalmente asigna un agente responsable.",
+    parameters: {
+        type: "object",
+        properties: {
+            project_id: { type: "string", description: "ID del proyecto al que pertenece la tarea" },
+            name: { type: "string", description: "Nombre corto de la tarea" },
+            description: { type: "string", description: "Qué debe realizar esta tarea" },
+            agent_id: { type: "string", description: "ID del agente responsable (opcional)" },
+        },
+        required: ["project_id", "name"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+        const taskId = dbService.createTask({
+            project_id: params.project_id as string,
+            agent_id: (params.agent_id as string) ?? null,
+            name: params.name as string,
+            description: (params.description as string) ?? null,
+        });
+
+        emitCanvas("canvas:node_add", {
+            id: `task_${taskId}`,
+            type: "task",
+            label: params.name,
+            data: { status: "pending", progress: 0, projectId: params.project_id, agentId: params.agent_id ?? null },
+        });
+        emitCanvas("canvas:edge_add", {
+            id: `edge_proj_task_${taskId}`,
+            source: `project_${params.project_id}`,
+            target: `task_${taskId}`,
+            edgeType: "contains",
+        });
+
+        if (params.agent_id) {
+            emitCanvas("canvas:edge_add", {
+                id: `edge_task_agent_${taskId}`,
+                source: `task_${taskId}`,
+                target: params.agent_id as string,
+                edgeType: "assigned_to",
+            });
+        }
+
+        return { success: true, taskId, message: `Tarea "${params.name}" creada (ID: ${taskId}).` };
+    },
+};
+
+// ── task_update ───────────────────────────────────────────────────────────────
+export const taskUpdateTool: Tool = {
+    name: "task_update",
+    description: "Actualiza el estado y progreso de una tarea. Recalcula automáticamente el progreso del proyecto padre.",
+    parameters: {
+        type: "object",
+        properties: {
+            task_id: { type: "number", description: "ID numérico de la tarea" },
+            status: {
+                type: "string",
+                enum: ["pending", "in_progress", "completed", "failed", "blocked"],
+                description: "Nuevo estado de la tarea"
+            },
+            progress: { type: "number", description: "Progreso de la tarea (0-100)" },
+            result: { type: "string", description: "Resultado o output de la tarea (al completarla)" },
+            agent_id: { type: "string", description: "Reasignar a otro agente (opcional)" },
+        },
+        required: ["task_id"],
+    },
+    execute: async (params: Record<string, unknown>) => {
+        const taskId = params.task_id as number;
+        const db = getDb();
+
+        const updated = dbService.updateTask(taskId, {
+            status: params.status as string | undefined,
+            progress: params.progress as number | undefined,
+            result: params.result as string | undefined,
+            agent_id: params.agent_id as string | undefined,
+        });
+        if (!updated) throw new Error(`Tarea con ID ${taskId} no encontrada.`);
+
+        // Obtener project_id para recalcular progreso del proyecto
+        const taskRow = db.query<any, [number]>("SELECT project_id FROM tasks WHERE id = ?").get(taskId);
+        let projectProgress = 0;
+        if (taskRow?.project_id) {
+            projectProgress = dbService.recalcProjectProgress(taskRow.project_id);
+            emitCanvas("canvas:node_update", {
+                id: `project_${taskRow.project_id}`,
+                data: { progress: projectProgress },
+            });
+        }
+
+        // Si hay nuevo agente asignado, agregar edge canvas
+        if (params.agent_id && taskRow?.project_id) {
+            emitCanvas("canvas:edge_add", {
+                id: `edge_task_agent_${taskId}`,
+                source: `task_${taskId}`,
+                target: params.agent_id as string,
+                edgeType: "assigned_to",
+            });
+        }
+
+        emitCanvas("canvas:node_update", {
+            id: `task_${taskId}`,
+            data: {
+                status: params.status,
+                progress: params.progress,
+                agentId: params.agent_id,
+            },
+        });
+
+        return {
+            success: true,
+            taskId,
+            projectProgress,
+            message: `Tarea ${taskId} actualizada: ${params.status ?? ""}${params.progress !== undefined ? ` ${params.progress}%` : ""}`,
+        };
+    },
+};