@johpaz/hive 1.1.0

package/packages/cli/src/commands/cron.ts

@@ -0,0 +1,161 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import { getHiveDir } from "@johpaz/hive-core/config/loader";
+
+const getHiveDirConst = () => getHiveDir();
+const getCronDir = () => path.join(getHiveDirConst(), "cron");
+const CRON_DB = path.join(getCronDir(), "jobs.json");
+
+interface CronJob {
+  id: string;
+  schedule: string;
+  command: string;
+  enabled: boolean;
+  lastRun?: string;
+  nextRun?: string;
+}
+
+function loadJobs(): CronJob[] {
+  if (!fs.existsSync(CRON_DB)) return [];
+  try {
+    return JSON.parse(fs.readFileSync(CRON_DB, "utf-8"));
+  } catch {
+    return [];
+  }
+}
+
+function saveJobs(jobs: CronJob[]): void {
+  if (!fs.existsSync(getCronDir())) {
+    fs.mkdirSync(getCronDir(), { recursive: true });
+  }
+  fs.writeFileSync(CRON_DB, JSON.stringify(jobs, null, 2));
+}
+
+export async function cron(subcommand: string | undefined, args: string[]): Promise<void> {
+  switch (subcommand) {
+    case "list":
+      await listCron();
+      break;
+    case "add":
+      await addCron();
+      break;
+    case "remove":
+      await removeCron(args[0]);
+      break;
+    case "logs":
+      await cronLogs();
+      break;
+    default:
+      console.log(`
+Usage: hive cron <command>
+
+Commands:
+  list        Listar cron jobs
+  add         Añadir cron job
+  remove <id> Eliminar cron job
+  logs        Ver logs de cron
+`);
+  }
+}
+
+async function listCron(): Promise<void> {
+  const jobs = loadJobs();
+
+  if (jobs.length === 0) {
+    console.log("No hay cron jobs configurados");
+    return;
+  }
+
+  console.log("\n⏰ Cron Jobs:\n");
+
+  for (const job of jobs) {
+    const status = job.enabled ? "✅ Activo" : "⏸️  Pausado";
+    console.log(`  ${job.id}`);
+    console.log(`    Estado:    ${status}`);
+    console.log(`    Schedule:  ${job.schedule}`);
+    console.log(`    Comando:   ${job.command}`);
+    if (job.lastRun) {
+      console.log(`    Última:    ${job.lastRun}`);
+    }
+    console.log();
+  }
+}
+
+async function addCron(): Promise<void> {
+  const idValue = await p.text({
+    message: "ID del cron job:",
+    placeholder: "daily-report",
+    validate: (v) => (!v ? "El ID es requerido" : undefined),
+  });
+
+  if (p.isCancel(idValue)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const scheduleValue = await p.text({
+    message: "Schedule (cron expression):",
+    placeholder: "0 9 * * *",
+    validate: (v) => (!v ? "El schedule es requerido" : undefined),
+  });
+
+  if (p.isCancel(scheduleValue)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const commandValue = await p.text({
+    message: "Comando a ejecutar:",
+    placeholder: "hive chat --agent work 'Genera el reporte diario'",
+    validate: (v) => (!v ? "El comando es requerido" : undefined),
+  });
+
+  if (p.isCancel(commandValue)) {
+    p.cancel("Cancelado");
+    return;
+  }
+
+  const jobs = loadJobs();
+  jobs.push({
+    id: idValue as string,
+    schedule: scheduleValue as string,
+    command: commandValue as string,
+    enabled: true,
+  });
+  saveJobs(jobs);
+
+  console.log(`✅ Cron job "${idValue}" creado`);
+}
+
+async function removeCron(id: string | undefined): Promise<void> {
+  if (!id) {
+    console.log("❌ Especifica el ID: hive cron remove <id>");
+    return;
+  }
+
+  const jobs = loadJobs();
+  const index = jobs.findIndex((j) => j.id === id);
+
+  if (index === -1) {
+    console.log(`❌ Cron job no encontrado: ${id}`);
+    return;
+  }
+
+  jobs.splice(index, 1);
+  saveJobs(jobs);
+
+  console.log(`✅ Cron job "${id}" eliminado`);
+}
+
+async function cronLogs(): Promise<void> {
+  const logFile = path.join(getCronDir(), "cron.log");
+
+  if (!fs.existsSync(logFile)) {
+    console.log("No hay logs de cron");
+    return;
+  }
+
+  const content = fs.readFileSync(logFile, "utf-8");
+  console.log(content);
+}

package/packages/cli/src/commands/dev.ts

@@ -0,0 +1,95 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import { getHiveDir } from "../../../core/src/config/loader";
+
+function showDevBanner(): void {
+  const hiveDir = getHiveDir();
+  console.log(`
+╔══════════════════════════════════════════════════╗
+║  🔧  HIVE DEV MODE                               ║
+║  Configuración en: ${hiveDir}
+║  Tu configuración real en ~/.hive/ no será modificada.    ║
+╚══════════════════════════════════════════════════╝
+`);
+}
+
+export async function dev(): Promise<void> {
+  const hiveDir = getHiveDir();
+  const dbPath = path.join(hiveDir, "data", "hive.db");
+
+  // Create hiveDir if it doesn't exist
+  if (!fs.existsSync(hiveDir)) {
+    fs.mkdirSync(hiveDir, { recursive: true });
+  }
+
+  // ── Step 1: Si existe sesión anterior, preguntar si limpiar ──
+  if (fs.readdirSync(hiveDir).length > 0) {
+    const stats = fs.statSync(hiveDir);
+    const hoursAgo = Math.floor((Date.now() - stats.mtime.getTime()) / (1000 * 60 * 60));
+    const timeAgo = hoursAgo < 1 ? "hace unos minutos" : `hace ${hoursAgo} hora${hoursAgo > 1 ? "s" : ""}`;
+
+    console.log(`\n⚠️  Se encontró una sesión de dev anterior en ${hiveDir}\n    Última configuración: ${timeAgo}\n`);
+
+    const shouldClean = await p.confirm({
+      message: "¿Limpiar y empezar de nuevo?",
+      initialValue: true,
+    });
+
+    if (p.isCancel(shouldClean)) {
+      p.cancel("Operación cancelada.");
+      process.exit(0);
+    }
+
+    if (shouldClean) {
+      console.log("🧹 Limpiando entorno de dev anterior...");
+      fs.rmSync(hiveDir, { recursive: true, force: true });
+      fs.mkdirSync(hiveDir, { recursive: true });
+    }
+  }
+
+  showDevBanner();
+
+  // ── Step 2: Verificar si ya hay un agente configurado ──
+  let hasCompletedAgent = false;
+
+  if (fs.existsSync(dbPath)) {
+    try {
+      const { initializeDatabase, getDb } = await import("../../../core/src/storage/sqlite");
+      initializeDatabase();
+      const db = getDb();
+      const agent = db.query("SELECT id FROM agents WHERE is_coordinator = 1 AND status = 'idle' LIMIT 1").get();
+      hasCompletedAgent = !!agent;
+    } catch {
+      hasCompletedAgent = false;
+    }
+  }
+
+  // ── Step 3: Si no hay agente, ejecutar onboarding (él crea dir + BD) ──
+  if (!hasCompletedAgent) {
+    console.log("🚀 Ejecutando onboarding interactivo...\n");
+    const { onboard } = await import("./onboard");
+    await onboard();
+
+    // Verificar que onboarding creó el agente
+    try {
+      const { getDb } = await import("../../../core/src/storage/sqlite");
+      const db = getDb();
+      const agent = db.query("SELECT id FROM agents WHERE is_coordinator = 1 AND status = 'idle' LIMIT 1").get();
+      if (!agent) {
+        console.error("❌ Onboard no creó la configuración en BD");
+        process.exit(1);
+      }
+    } catch (e) {
+      console.error("❌ Error verificando configuración:", (e as Error).message);
+      process.exit(1);
+    }
+    console.log("\n✅ Onboarding completado. Arrancando el servidor...\n");
+  } else {
+    console.log("🚀 Arrancando gateway con configuración existente...\n");
+  }
+
+  // ── Step 4: Arrancar gateway ──
+  const { start } = await import("./gateway");
+  await start(["--skip-check"]);
+}

package/packages/cli/src/commands/doctor.ts

@@ -0,0 +1,133 @@
+import * as p from "@clack/prompts";
+import * as fs from "fs";
+import * as path from "path";
+import { execSync } from "child_process";
+import { loadConfig, getHiveDir } from "@johpaz/hive-core/config/loader";
+
+const getHiveDirConst = () => getHiveDir();
+const getWorkspace = () => path.join(getHiveDirConst(), "workspace");
+const getPidFile = () => path.join(getHiveDirConst(), "hive.pid");
+const getDbFile = () => path.join(getHiveDirConst(), "hive.db");
+
+function checkBun(): { ok: boolean; version: string } {
+  try {
+    const version = execSync("bun --version", { encoding: "utf-8" }).trim();
+    return { ok: true, version };
+  } catch {
+    return { ok: false, version: "no instalado" };
+  }
+}
+
+function checkNode(): { ok: boolean; version: string } {
+  try {
+    const version = execSync("node --version", { encoding: "utf-8" }).trim();
+    return { ok: true, version };
+  } catch {
+    return { ok: false, version: "no instalado" };
+  }
+}
+
+function isGatewayRunning(): boolean {
+  if (!fs.existsSync(getPidFile())) return false;
+  const pid = parseInt(fs.readFileSync(getPidFile(), "utf-8").trim(), 10);
+  if (isNaN(pid)) return false;
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export async function doctor(): Promise<void> {
+  console.log("\n🐝 Hive Doctor — Diagnóstico del sistema\n");
+
+  const checks: Array<{ category: string; name: string; status: "ok" | "warn" | "error"; message: string; hint?: string }> = [];
+
+  // Runtime
+  const bun = checkBun();
+  checks.push({ category: "Runtime", name: "Bun", status: bun.ok ? "ok" : "error", message: `v${bun.version}` });
+
+  const node = checkNode();
+  checks.push({ category: "Runtime", name: "Node.js", status: node.ok ? "ok" : "warn", message: `${node.version} (para MCP servers)` });
+
+  // Directorio Base
+  if (fs.existsSync(getHiveDirConst())) {
+    checks.push({ category: "Sistema", name: "Directorio Hive", status: "ok", message: getHiveDirConst() });
+  } else {
+    checks.push({ category: "Sistema", name: "Directorio Hive", status: "error", message: "no existe", hint: "Ejecuta 'hive onboard'" });
+  }
+
+  // Base de Datos
+  if (fs.existsSync(getDbFile())) {
+    checks.push({ category: "Sistema", name: "Base de Datos", status: "ok", message: "hive.db presente" });
+  } else {
+    checks.push({ category: "Sistema", name: "Base de Datos", status: "warn", message: "hive.db no existe" });
+  }
+
+  // Configuración (In-memory/Env)
+  try {
+    const config = loadConfig();
+    const gateway = config.gateway;
+    if (gateway) {
+      checks.push({ category: "Configuración", name: "Gateway Config", status: "ok", message: "cargada" });
+    } else {
+      checks.push({ category: "Configuración", name: "Gateway Config", status: "warn", message: "usando valores por defecto" });
+    }
+
+    const models = config.models;
+    const provider = models?.defaultProvider;
+    if (provider) {
+      checks.push({ category: "Configuración", name: "Proveedor LLM", status: "ok", message: provider });
+    } else {
+      checks.push({ category: "Configuración", name: "Proveedor LLM", status: "warn", message: "no configurado" });
+    }
+  } catch (e) {
+    checks.push({ category: "Configuración", name: "Carga", status: "error", message: `Error: ${(e as Error).message}` });
+  }
+
+  // Workspace
+  checks.push({ category: "Workspace", name: "Directorio", status: fs.existsSync(getWorkspace()) ? "ok" : "warn", message: fs.existsSync(getWorkspace()) ? "existe" : "no existe" });
+
+  // Gateway
+  const running = isGatewayRunning();
+  checks.push({ category: "Gateway", name: "Estado", status: running ? "ok" : "warn", message: running ? "corriendo" : "detenido" });
+
+  // Mostrar resultados
+  const categories = [...new Set(checks.map((c) => c.category))];
+
+  for (const category of categories) {
+    console.log(`${category}`);
+    const categoryChecks = checks.filter((c) => c.category === category);
+    for (const check of categoryChecks) {
+      const icon = check.status === "ok" ? "✅" : check.status === "warn" ? "⚠️ " : "❌";
+      console.log(`  ${icon} ${check.name}: ${check.message}`);
+      if (check.hint) {
+        console.log(`     💡 ${check.hint}`);
+      }
+    }
+    console.log();
+  }
+
+  // Resumen
+  const errors = checks.filter((c) => c.status === "error");
+  const warns = checks.filter((c) => c.status === "warn");
+
+  if (errors.length > 0) {
+    console.log(`❌ ${errors.length} error(es) encontrado(s)`);
+
+    const fix = await p.confirm({
+      message: "¿Deseas ejecutar el onboarding para reparar?",
+      initialValue: false,
+    });
+
+    if (fix) {
+      const { onboard } = await import("./onboard");
+      await onboard();
+    }
+  } else if (warns.length > 0) {
+    console.log(`⚠️  ${warns.length} advertencia(s)`);
+  } else {
+    console.log("✅ Todo en orden");
+  }
+}