@johpaz/hive-sdk 0.0.14 → 0.0.15

package/packages/core/src/tools/projects/project-fail.ts

@@ -0,0 +1,66 @@
+/**
+ * project_fail - Mark project as failed
+ * 
+ * @category projects
+ * @seedId project_fail
+ * @spanish proyecto fallido, marcar fracaso, error
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("project-fail");
+
+export const projectFailTool: Tool = {
+  name: "project_fail",
+  description: "Mark project as failed and record reason. Spanish: proyecto fallido, marcar fracaso, error",
+  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: Record<string, unknown>) => {
+    const db = getDb();
+    const projectId = params.projectId as string;
+    const reason = params.reason as string;
+
+    try {
+      log.error(`Project ${projectId} failed: ${reason}`);
+
+      const result = db.query(`
+        UPDATE projects 
+        SET status = 'failed', updated_at = unixepoch(), context = ? 
+        WHERE id = ?
+      `).run(reason, projectId);
+
+      if (result.changes === 0) {
+        return {
+          ok: false,
+          error: `Project not found: ${projectId}`,
+        };
+      }
+
+      return {
+        ok: true,
+        projectId,
+        message: "Project marked as failed.",
+      };
+    } catch (error) {
+      log.error(`Failed to mark project as failed: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to mark project as failed: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/projects/project-list.ts

@@ -0,0 +1,96 @@
+/**
+ * project_list - List all projects with their status
+ * 
+ * @category projects
+ * @seedId project_list
+ * @spanish listar proyectos, ver proyectos, historial
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("project-list");
+
+export const projectListTool: Tool = {
+  name: "project_list",
+  description: "List all projects with their status. Spanish: listar proyectos, ver proyectos, historial",
+  parameters: {
+    type: "object",
+    properties: {
+      status: {
+        type: "string",
+        enum: ["active", "done", "failed", "all"],
+        description: "Filter by status (default: all)",
+      },
+      limit: {
+        type: "number",
+        description: "Maximum results (default: 20)",
+      },
+    },
+  },
+  execute: async (params: Record<string, unknown>, config?: any) => {
+    const db = getDb();
+    const userId = config?.configurable?.user_id;
+    const statusFilter = params.status as string | undefined;
+    const limit = (params.limit as number) ?? 20;
+
+    try {
+      let query = `
+        SELECT id, name, description, type, status, progress, created_at, updated_at
+        FROM projects
+        WHERE user_id = ?
+      `;
+      const args: any[] = [userId];
+
+      if (statusFilter && statusFilter !== "all") {
+        query += ` AND status = ?`;
+        args.push(statusFilter);
+      }
+
+      query += ` ORDER BY updated_at DESC LIMIT ?`;
+      args.push(limit);
+
+      const rows = db.query(query).all(...args) as any[];
+
+      const projects = rows.map((row) => {
+        const tasks = db.query(`
+          SELECT id, name, description, status, progress, agent_id, result
+          FROM tasks WHERE project_id = ? ORDER BY id ASC
+        `).all(row.id) as any[];
+
+        return {
+          id: row.id,
+          name: row.name,
+          description: row.description,
+          type: row.type,
+          status: row.status,
+          progress: row.progress,
+          createdAt: new Date(row.created_at * 1000).toISOString(),
+          updatedAt: new Date(row.updated_at * 1000).toISOString(),
+          tasks: tasks.map((t) => ({
+            id: t.id,
+            name: t.name,
+            description: t.description,
+            status: t.status,
+            progress: t.progress,
+            agentId: t.agent_id,
+            result: t.result,
+          })),
+        };
+      });
+
+      return {
+        ok: true,
+        projects,
+        count: projects.length,
+      };
+    } catch (error) {
+      log.error(`Failed to list projects: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to list projects: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/projects/project-update.ts

@@ -0,0 +1,72 @@
+/**
+ * project_update - Update project progress or metadata
+ * 
+ * @category projects
+ * @seedId project_update
+ * @spanish actualizar proyecto, avance, porcentaje, estado
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("project-update");
+
+export const projectUpdateTool: Tool = {
+  name: "project_update",
+  description: "Update project progress or metadata. Spanish: actualizar proyecto, avance, porcentaje, estado",
+  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: Record<string, unknown>) => {
+    const db = getDb();
+    const projectId = params.projectId as string;
+    const progress = params.progress as number;
+    const stepDescription = params.stepDescription as string;
+
+    try {
+      log.info(`Updating project ${projectId}: ${progress}%`);
+
+      const result = db.query(`
+        UPDATE projects 
+        SET progress = ?, context = ?, updated_at = unixepoch() 
+        WHERE id = ?
+      `).run(progress, stepDescription, projectId);
+
+      if (result.changes === 0) {
+        return {
+          ok: false,
+          error: `Project not found: ${projectId}`,
+        };
+      }
+
+      return {
+        ok: true,
+        projectId,
+        progress,
+        message: `Project updated: ${progress}%`,
+      };
+    } catch (error) {
+      log.error(`Failed to update project: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to update project: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/projects/task-create.ts

@@ -0,0 +1,68 @@
+/**
+ * task_create - Add a task or subtask to an existing project
+ * 
+ * @category projects
+ * @seedId task_create
+ * @spanish crear tarea, agregar tarea, subtarea, pendiente
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("task-create");
+
+export const taskCreateTool: Tool = {
+  name: "task_create",
+  description: "Add a task or subtask to an existing project. Spanish: crear tarea, agregar tarea, subtarea, pendiente",
+  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 db = getDb();
+    const projectId = params.project_id as string;
+    const name = params.name as string;
+    const description = (params.description as string) ?? null;
+    const agentId = (params.agent_id as string) ?? null;
+
+    try {
+      const result = db.query(`
+        INSERT INTO tasks (project_id, agent_id, name, description, status, created_at, updated_at)
+        VALUES (?, ?, ?, ?, 'pending', unixepoch(), unixepoch())
+      `).run(projectId, agentId, name, description);
+
+      const taskId = result.lastInsertRowid as number;
+
+      return {
+        ok: true,
+        taskId,
+        message: `Task "${name}" created (ID: ${taskId}).`,
+      };
+    } catch (error) {
+      log.error(`Failed to create task: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to create task: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/projects/task-evaluate.ts

@@ -0,0 +1,93 @@
+/**
+ * task_evaluate - Evaluate task result against acceptance criteria
+ * 
+ * @category projects
+ * @seedId task_evaluate
+ * @spanish evaluar tarea, validar resultado, criterios de aceptación
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("task-evaluate");
+
+export const taskEvaluateTool: Tool = {
+  name: "task_evaluate",
+  description: "Evaluate task result against acceptance criteria. Spanish: evaluar tarea, validar resultado, criterios de aceptación",
+  parameters: {
+    type: "object",
+    properties: {
+      task_id: {
+        type: "number",
+        description: "ID numérico de la tarea a evaluar",
+      },
+      criteria: {
+        type: "array",
+        description: "Lista de criterios de aceptación",
+        items: { type: "string" },
+      },
+      auto_update: {
+        type: "boolean",
+        description: "Si pasa la evaluación, marca la tarea como completed (default: false)",
+      },
+    },
+    required: ["task_id", "criteria"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const db = getDb();
+    const taskId = params.task_id as number;
+    const criteria = params.criteria as string[];
+    const autoUpdate = (params.auto_update as boolean) ?? false;
+
+    try {
+      const task = db.query<any, [number]>(
+        "SELECT id, name, status, result FROM tasks WHERE id = ?"
+      ).get(taskId);
+
+      if (!task) {
+        return {
+          ok: false,
+          error: `Task not found: ${taskId}`,
+        };
+      }
+
+      if (!task.result) {
+        return {
+          ok: false,
+          error: `Task has no result to evaluate.`,
+        };
+      }
+
+      const evaluations = criteria.map((criterion) => {
+        const passed = task.result.toLowerCase().includes(criterion.toLowerCase());
+        return { criterion, passed };
+      });
+
+      const allPassed = evaluations.every((e) => e.passed);
+      const passedCount = evaluations.filter((e) => e.passed).length;
+
+      if (autoUpdate && allPassed) {
+        db.query(`
+          UPDATE tasks SET status = 'completed', completed_at = unixepoch() WHERE id = ?
+        `).run(taskId);
+      }
+
+      return {
+        ok: true,
+        taskId,
+        allPassed,
+        passedCount,
+        totalCriteria: criteria.length,
+        evaluations,
+        autoUpdated: autoUpdate && allPassed,
+      };
+    } catch (error) {
+      log.error(`Failed to evaluate task: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to evaluate task: ${(error as Error).message}`,
+      };
+    }
+  },
+};

package/packages/core/src/tools/projects/task-update.ts

@@ -0,0 +1,93 @@
+/**
+ * task_update - Update task status
+ * 
+ * @category projects
+ * @seedId task_update
+ * @spanish actualizar tarea, marcar completa, en progreso
+ */
+
+import type { Tool } from "../types.ts";
+import { getDb } from "../../storage/SQLiteStorage.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("task-update");
+
+export const taskUpdateTool: Tool = {
+  name: "task_update",
+  description: "Update task status (pending, in_progress, done). Spanish: actualizar tarea, marcar completa, en progreso",
+  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",
+      },
+    },
+    required: ["task_id"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const db = getDb();
+    const taskId = params.task_id as number;
+    const status = params.status as string | undefined;
+    const progress = params.progress as number | undefined;
+    const result = params.result as string | undefined;
+
+    try {
+      log.info(`Updating task ${taskId}`);
+
+      const updates: string[] = [];
+      const values: any[] = [];
+
+      if (status !== undefined) {
+        updates.push("status = ?");
+        values.push(status);
+      }
+      if (progress !== undefined) {
+        updates.push("progress = ?");
+        values.push(progress);
+      }
+      if (result !== undefined) {
+        updates.push("result = ?");
+        values.push(result);
+      }
+
+      updates.push("updated_at = unixepoch()");
+      values.push(taskId);
+
+      const query = `UPDATE tasks SET ${updates.join(", ")} WHERE id = ?`;
+      const updateResult = db.query(query).run(...values);
+
+      if (updateResult.changes === 0) {
+        return {
+          ok: false,
+          error: `Task not found: ${taskId}`,
+        };
+      }
+
+      return {
+        ok: true,
+        taskId,
+        message: `Task ${taskId} updated.`,
+      };
+    } catch (error) {
+      log.error(`Failed to update task: ${(error as Error).message}`);
+      return {
+        ok: false,
+        error: `Failed to update task: ${(error as Error).message}`,
+      };
+    }
+  },
+};

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

@@ -0,0 +1,39 @@
+/**
+ * Tool Type Definitions
+ * Shared across all tool categories
+ * 
+ * These types are used by all 52 native tools in Hive
+ */
+
+export interface Tool {
+  name: string;
+  description: string;
+  parameters: {
+    type: "object";
+    properties: Record<string, ToolParameter>;
+    required?: string[];
+  };
+  execute: (
+    params: Record<string, unknown>,
+    config?: any
+  ) => Promise<string | object>;
+}
+
+export interface ToolParameter {
+  type: string;
+  description?: string;
+  enum?: string[];
+  items?: ToolParameter;
+  properties?: Record<string, ToolParameter>;
+  required?: string[];
+  minimum?: number;
+  maximum?: number;
+  additionalProperties?: boolean | ToolParameter;
+}
+
+export interface ToolResult {
+  ok: boolean;
+  result?: any;
+  error?: string;
+  hint?: string;
+}

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

@@ -0,0 +1,104 @@
+/**
+ * Voice Tools - 2 tools
+ * 
+ * @category voice
+ */
+import type { Tool } from "../types.ts";
+import { logger } from "../../utils/logger.ts";
+
+const log = logger.child("voice");
+
+// ─── voice_transcribe ────────────────────────────────────────────────────────
+
+export const voiceTranscribeTool: Tool = {
+  name: "voice_transcribe",
+  description: "Transcribe audio input to text. Spanish: transcribir audio, voz a texto, reconocimiento de voz",
+  parameters: {
+    type: "object",
+    properties: {
+      audio: {
+        type: "string",
+        description: "Audio file path or base64 encoded audio",
+      },
+      language: {
+        type: "string",
+        description: "Language code (e.g., 'es', 'en'). Auto-detect if not specified.",
+      },
+    },
+    required: ["audio"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const audio = params.audio as string;
+    const language = (params.language as string) ?? "auto";
+
+    log.info(`Transcribing audio: ${audio.substring(0, 50)}...`);
+
+    try {
+      // Placeholder implementation - real transcription would call STT API
+      return {
+        ok: true,
+        transcription: "[Transcription requires STT provider configuration]",
+        language: language,
+        duration: 0,
+        confidence: 0,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to transcribe: ${(error as Error).message}`,
+      };
+    }
+  },
+};
+
+// ─── voice_speak ─────────────────────────────────────────────────────────────
+
+export const voiceSpeakTool: Tool = {
+  name: "voice_speak",
+  description: "Convert text to synthesized speech output. Spanish: texto a voz, sintetizar, hablar, leer en voz alta",
+  parameters: {
+    type: "object",
+    properties: {
+      text: {
+        type: "string",
+        description: "Text to convert to speech",
+      },
+      voice_id: {
+        type: "string",
+        description: "Voice ID to use (provider-specific)",
+      },
+      language: {
+        type: "string",
+        description: "Language code (e.g., 'es', 'en')",
+      },
+    },
+    required: ["text"],
+  },
+  execute: async (params: Record<string, unknown>) => {
+    const text = params.text as string;
+    const voiceId = (params.voice_id as string) ?? "default";
+    const language = (params.language as string) ?? "es";
+
+    log.info(`Synthesizing speech: ${text.substring(0, 50)}...`);
+
+    try {
+      // Placeholder implementation - real TTS would call TTS API
+      return {
+        ok: true,
+        audio_url: "[TTS requires provider configuration]",
+        voice_id: voiceId,
+        language: language,
+        duration: 0,
+      };
+    } catch (error) {
+      return {
+        ok: false,
+        error: `Failed to synthesize speech: ${(error as Error).message}`,
+      };
+    }
+  },
+};
+
+export function createTools(): Tool[] {
+  return [voiceTranscribeTool, voiceSpeakTool];
+}