@johpaz/hive 1.1.4 → 1.1.5

package/packages/core/src/utils/logger.js

@@ -0,0 +1,352 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.logger = exports.ChildLogger = exports.Logger = void 0;
+exports.onLogEntry = onLogEntry;
+exports.removeLogListener = removeLogListener;
+exports.getLogger = getLogger;
+const node_fs_1 = require("node:fs");
+const path = __importStar(require("node:path"));
+const loader_ts_1 = require("../config/loader.ts");
+const _logListeners = new Set();
+/** Subscribe to real-time log entries */
+function onLogEntry(cb) {
+    _logListeners.add(cb);
+}
+/** Unsubscribe from real-time log entries */
+function removeLogListener(cb) {
+    _logListeners.delete(cb);
+}
+function emitLogEntry(entry) {
+    for (const cb of _logListeners) {
+        try {
+            cb(entry);
+        }
+        catch { /* listener error should not crash logger */ }
+    }
+}
+const LOG_LEVELS = {
+    debug: 0,
+    info: 1,
+    warn: 2,
+    error: 3,
+};
+const SENSITIVE_PATTERNS = [
+    /api[_-]?key/i,
+    /token/i,
+    /secret/i,
+    /password/i,
+    /credential/i,
+    /auth/i,
+];
+const COLORS = {
+    debug: "\x1b[36m",
+    info: "\x1b[32m",
+    warn: "\x1b[33m",
+    error: "\x1b[31m",
+    reset: "\x1b[0m",
+    dim: "\x1b[2m",
+    bright: "\x1b[1m",
+};
+function expandPath(p) {
+    if (p.startsWith("~")) {
+        return path.join(process.env.HOME || "", p.slice(1));
+    }
+    return p;
+}
+function redact(obj, seen = new WeakSet()) {
+    if (obj === null || typeof obj !== "object") {
+        return obj;
+    }
+    if (seen.has(obj)) {
+        return "[Circular]";
+    }
+    seen.add(obj);
+    if (Array.isArray(obj)) {
+        return obj.map((item) => redact(item, seen));
+    }
+    const result = {};
+    for (const [key, value] of Object.entries(obj)) {
+        const isSensitive = SENSITIVE_PATTERNS.some((p) => p.test(key));
+        if (isSensitive) {
+            result[key] = "[REDACTED]";
+        }
+        else if (typeof value === "object" && value !== null) {
+            result[key] = redact(value, seen);
+        }
+        else {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+function formatTimestamp() {
+    return new Date().toISOString();
+}
+function formatMessage(level, message, meta, correlationId) {
+    const timestamp = formatTimestamp();
+    const corrStr = correlationId ? ` [${correlationId.slice(0, 8)}]` : "";
+    const metaStr = meta ? ` ${JSON.stringify(meta)}` : "";
+    return `[${timestamp}]${corrStr} [${level.toUpperCase()}] ${message}${metaStr}`;
+}
+class Logger {
+    constructor(config = {}) {
+        this.logFile = null;
+        this.currentSize = 0;
+        this.correlationContext = {};
+        this.config = {
+            level: config.level ?? "info",
+            dir: config.dir ?? path.join((0, loader_ts_1.getHiveDir)(), "logs"),
+            maxSizeMB: config.maxSizeMB ?? 10,
+            maxFiles: config.maxFiles ?? 5,
+            redactSensitive: config.redactSensitive ?? true,
+            console: config.console ?? true,
+        };
+    }
+    setCorrelationContext(context) {
+        this.correlationContext = { ...this.correlationContext, ...context };
+    }
+    clearCorrelationContext() {
+        this.correlationContext = {};
+    }
+    getCorrelationId() {
+        return this.correlationContext.correlationId;
+    }
+    withCorrelationId(id) {
+        this.correlationContext.correlationId = id;
+        return this;
+    }
+    initLogFile() {
+        const logDir = expandPath(this.config.dir);
+        try {
+            if (!(0, node_fs_1.existsSync)(logDir)) {
+                (0, node_fs_1.mkdirSync)(logDir, { recursive: true });
+            }
+            this.logFile = path.join(logDir, `hive-${new Date().toISOString().split("T")[0]}.log`);
+            const file = Bun.file(this.logFile);
+            this.currentSize = file.size ?? 0;
+        }
+        catch {
+            this.logFile = null;
+        }
+    }
+    shouldLog(level) {
+        return LOG_LEVELS[level] >= LOG_LEVELS[this.config.level];
+    }
+    writeToConsole(level, message, meta) {
+        if (!this.config.console)
+            return;
+        const color = COLORS[level];
+        const mergedMeta = this.mergeMeta(meta);
+        const displayMeta = this.config.redactSensitive && mergedMeta ? redact(mergedMeta) : mergedMeta;
+        const metaStr = displayMeta && Object.keys(displayMeta).length > 0
+            ? ` ${JSON.stringify(displayMeta)}`
+            : "";
+        const prefix = `${COLORS.dim}${formatTimestamp()}${COLORS.reset}`;
+        const corrStr = this.correlationContext.correlationId
+            ? ` ${COLORS.dim}[${this.correlationContext.correlationId.slice(0, 8)}]${COLORS.reset}`
+            : "";
+        const levelStr = `${color}${COLORS.bright}[${level.toUpperCase().padEnd(5)}]${COLORS.reset}`;
+        console.log(`${prefix}${corrStr} ${levelStr} ${message}${metaStr}`);
+    }
+    mergeMeta(meta) {
+        if (!meta && Object.keys(this.correlationContext).length === 0)
+            return undefined;
+        const contextWithoutCorrId = { ...this.correlationContext };
+        delete contextWithoutCorrId.correlationId;
+        if (!meta)
+            return contextWithoutCorrId;
+        if (typeof meta !== "object")
+            return meta;
+        return { ...contextWithoutCorrId, ...meta };
+    }
+    writeToFile(message) {
+        if (!this.logFile) {
+            this.initLogFile();
+        }
+        if (!this.logFile)
+            return;
+        try {
+            const line = message + "\n";
+            const bytes = Buffer.byteLength(line);
+            if (this.currentSize + bytes > this.config.maxSizeMB * 1024 * 1024) {
+                this.rotateLogs();
+            }
+            // Use sync append for logging reliability
+            const encoder = new TextEncoder();
+            const data = encoder.encode(line);
+            Bun.write(this.logFile, data).catch(() => { });
+            this.currentSize += bytes;
+        }
+        catch {
+            // Silently fail if we can't write to log file
+        }
+    }
+    rotateLogs() {
+        if (!this.logFile)
+            return;
+        const logDir = path.dirname(this.logFile);
+        const baseName = path.basename(this.logFile, ".log");
+        for (let i = this.config.maxFiles - 1; i >= 1; i--) {
+            const oldFile = path.join(logDir, `${baseName}.${i}.log`);
+            const newFile = path.join(logDir, `${baseName}.${i + 1}.log`);
+            try {
+                if ((0, node_fs_1.existsSync)(oldFile)) {
+                    if (i === this.config.maxFiles - 1) {
+                        (0, node_fs_1.unlinkSync)(oldFile);
+                    }
+                    else {
+                        (0, node_fs_1.renameSync)(oldFile, newFile);
+                    }
+                }
+            }
+            catch {
+                // Continue rotation even if one file fails
+            }
+        }
+        try {
+            (0, node_fs_1.renameSync)(this.logFile, path.join(logDir, `${baseName}.1.log`));
+            this.currentSize = 0;
+        }
+        catch {
+            // Continue even if rotation fails
+        }
+    }
+    debug(message, meta) {
+        if (!this.shouldLog("debug"))
+            return;
+        const mergedMeta = this.mergeMeta(meta);
+        const formatted = formatMessage("debug", message, mergedMeta, this.correlationContext.correlationId);
+        this.writeToConsole("debug", message, meta);
+        this.writeToFile(formatted);
+        emitLogEntry({ timestamp: formatTimestamp(), level: "debug", source: "core", message, meta: mergedMeta });
+    }
+    info(message, meta) {
+        if (!this.shouldLog("info"))
+            return;
+        const mergedMeta = this.mergeMeta(meta);
+        const formatted = formatMessage("info", message, mergedMeta, this.correlationContext.correlationId);
+        this.writeToConsole("info", message, meta);
+        this.writeToFile(formatted);
+        emitLogEntry({ timestamp: formatTimestamp(), level: "info", source: "core", message, meta: mergedMeta });
+    }
+    warn(message, meta) {
+        if (!this.shouldLog("warn"))
+            return;
+        const mergedMeta = this.mergeMeta(meta);
+        const formatted = formatMessage("warn", message, mergedMeta, this.correlationContext.correlationId);
+        this.writeToConsole("warn", message, meta);
+        this.writeToFile(formatted);
+        emitLogEntry({ timestamp: formatTimestamp(), level: "warn", source: "core", message, meta: mergedMeta });
+    }
+    error(message, meta) {
+        if (!this.shouldLog("error"))
+            return;
+        const mergedMeta = this.mergeMeta(meta);
+        const formatted = formatMessage("error", message, mergedMeta, this.correlationContext.correlationId);
+        this.writeToConsole("error", message, meta);
+        this.writeToFile(formatted);
+        emitLogEntry({ timestamp: formatTimestamp(), level: "error", source: "core", message, meta: mergedMeta });
+    }
+    child(context) {
+        return new ChildLogger(this, context, this.correlationContext);
+    }
+    setLevel(level) {
+        this.config.level = level;
+    }
+}
+exports.Logger = Logger;
+class ChildLogger {
+    constructor(parent, context, correlationContext = {}) {
+        this.parent = parent;
+        this.context = context;
+        this.correlationContext = correlationContext;
+    }
+    prefix(message) {
+        return `[${this.context}] ${message}`;
+    }
+    withCorrelationId(id) {
+        this.correlationContext.correlationId = id;
+        return this;
+    }
+    setContext(context) {
+        this.correlationContext = { ...this.correlationContext, ...context };
+    }
+    debug(message, meta) {
+        this.parent.debug(this.prefix(message), this.mergeMeta(meta));
+    }
+    info(message, meta) {
+        this.parent.info(this.prefix(message), this.mergeMeta(meta));
+    }
+    warn(message, meta) {
+        this.parent.warn(this.prefix(message), this.mergeMeta(meta));
+    }
+    error(message, meta) {
+        this.parent.error(this.prefix(message), this.mergeMeta(meta));
+    }
+    child(subContext) {
+        return new ChildLogger(this.parent, `${this.context}:${subContext}`, this.correlationContext);
+    }
+    mergeMeta(meta) {
+        if (!meta && Object.keys(this.correlationContext).length === 0)
+            return undefined;
+        if (!meta)
+            return { ...this.correlationContext };
+        if (typeof meta !== "object")
+            return meta;
+        return { ...this.correlationContext, ...meta };
+    }
+}
+exports.ChildLogger = ChildLogger;
+let _logger = null;
+function getLogger() {
+    if (!_logger) {
+        _logger = new Logger();
+    }
+    return _logger;
+}
+exports.logger = {
+    child: (opts) => getLogger().child(opts),
+    debug: (msg, meta) => getLogger().debug(msg, meta),
+    info: (msg, meta) => getLogger().info(msg, meta),
+    warn: (msg, meta) => getLogger().warn(msg, meta),
+    error: (msg, meta) => getLogger().error(msg, meta),
+    setCorrelationContext: (ctx) => getLogger().setCorrelationContext(ctx),
+    clearCorrelationContext: () => getLogger().clearCorrelationContext(),
+    getCorrelationId: () => getLogger().getCorrelationId(),
+    withCorrelationId: (id) => getLogger().withCorrelationId(id),
+    setLevel: (level) => getLogger().setLevel(level),
+    setHandler: (handler) => { },
+};

package/packages/cli/src/commands/agent-run.ts

@@ -1,168 +0,0 @@
-import * as p from "@clack/prompts";
-import { loadConfig } from "@johpaz/hive-core/config/loader";
-
-function getGatewayUrl(config: any): string {
-  const gateway = config?.gateway;
-  const host = gateway?.host ?? "localhost";
-  const port = gateway?.port ?? 3000;
-  return `http://${host}:${port}`;
-}
-
-export async function agent(subcommand: string | undefined, args: string[]): Promise<void> {
-  switch (subcommand) {
-    case "run":
-      await agentRun(args);
-      break;
-    default:
-      console.log(`
-Usage: hive agent <command>
-
-Commands:
-  run --message <text>     Ejecutar agente con mensaje
-  run --thinking <level>   Nivel de razonamiento (low/medium/high)
-  run --wait               Esperar respuesta completa
-`);
-  }
-}
-
-async function agentRun(args: string[]): Promise<void> {
-  const messageIndex = args.indexOf("--message");
-  const thinkingIndex = args.indexOf("--thinking");
-  const toolsIndex = args.indexOf("--tools");
-  const agentIndex = args.indexOf("--agent");
-  const waitIndex = args.indexOf("--wait");
-
-  if (messageIndex === -1) {
-    const msg = await p.text({
-      message: "Mensaje para el agente:",
-      placeholder: "Analiza el archivo README.md",
-      validate: (v) => (!v ? "El mensaje es requerido" : undefined),
-    });
-
-    if (p.isCancel(msg)) {
-      p.cancel("Cancelado");
-      return;
-    }
-
-    args.push("--message", msg as string);
-    return agentRun(args);
-  }
-
-  const message = args[messageIndex + 1];
-  const thinking = thinkingIndex !== -1 ? args[thinkingIndex + 1] : "medium";
-  const tools = toolsIndex !== -1 ? args[toolsIndex + 1] : "all";
-  const agentId = agentIndex !== -1 ? args[agentIndex + 1] : "main";
-  const wait = waitIndex !== -1;
-
-  if (!message) {
-    console.log("❌ Mensaje requerido");
-    return;
-  }
-
-  const config = loadConfig();
-  const gatewayUrl = getGatewayUrl(config);
-
-  const spinner = p.spinner();
-  spinner.start("Conectando con el agente...");
-
-  try {
-    if (wait) {
-      await executeWithStream(gatewayUrl, { message, thinking, tools, agentId }, spinner);
-    } else {
-      await executeAsync(gatewayUrl, { message, thinking, tools, agentId }, spinner);
-    }
-  } catch (error) {
-    spinner.stop("Error");
-    console.log(`❌ ${(error as Error).message}`);
-    console.log("   ¿Está corriendo el Gateway? Ejecuta: hive start");
-  }
-}
-
-async function executeWithStream(
-  gatewayUrl: string,
-  payload: { message: string; thinking: string; tools: string; agentId: string },
-  spinner: ReturnType<typeof p.spinner>
-): Promise<void> {
-  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ ...payload, stream: true }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Error: ${response.statusText}`);
-  }
-
-  spinner.stop("Conectado");
-
-  const reader = response.body?.getReader();
-  if (!reader) {
-    throw new Error("No se pudo obtener el stream");
-  }
-
-  const decoder = new TextDecoder();
-  let buffer = "";
-  let thinking = true;
-
-  process.stdout.write("\n");
-
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done) break;
-
-    buffer += decoder.decode(value, { stream: true });
-    const lines = buffer.split("\n");
-    buffer = lines.pop() ?? "";
-
-    for (const line of lines) {
-      if (!line.trim() || !line.startsWith("data: ")) continue;
-
-      try {
-        const data = JSON.parse(line.slice(6));
-
-        if (data.type === "thinking" && thinking) {
-          process.stdout.write(".");
-        } else if (data.type === "response") {
-          if (thinking) {
-            process.stdout.write("\n\n");
-            thinking = false;
-          }
-          process.stdout.write(data.content ?? "");
-        } else if (data.type === "tool_call") {
-          process.stdout.write(`\n[Tool: ${data.toolName}]`);
-        } else if (data.type === "complete") {
-          process.stdout.write("\n\n");
-        }
-      } catch {
-        // Ignore parse errors
-      }
-    }
-  }
-}
-
-async function executeAsync(
-  gatewayUrl: string,
-  payload: { message: string; thinking: string; tools: string; agentId: string },
-  spinner: ReturnType<typeof p.spinner>
-): Promise<void> {
-  const response = await fetch(`${gatewayUrl}/api/agent/execute`, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({ ...payload, stream: false }),
-  });
-
-  if (!response.ok) {
-    throw new Error(`Error: ${response.statusText}`);
-  }
-
-  const result = await response.json() as { taskId?: string; success: boolean };
-
-  spinner.stop("Enviado");
-
-  if (result.taskId) {
-    console.log(`✓ Tarea enviada: ${result.taskId}`);
-    console.log("  Usa `hive tasks list` para ver el estado");
-  } else {
-    console.log("✓ Tarea enviada");
-  }
-}