@agentforge/core 0.11.8 → 0.12.0

package/dist/index.js

@@ -2515,14 +2515,14 @@ var withLogging = (options) => {
     onComplete,
     onError
   } = options;
-  const logger4 = providedLogger || createLogger(name, { level });
+  const logger5 = providedLogger || createLogger(name, { level });
   return (node) => {
     return async (state) => {
       const startTime = Date.now();
       try {
         if (logInput) {
           const data = extractData ? extractData(state) : { state };
-          logger4.info("Node execution started", data);
+          logger5.info("Node execution started", data);
         }
         if (onStart) {
           onStart(state);
@@ -2532,9 +2532,9 @@ var withLogging = (options) => {
         if (logOutput) {
           const data = extractData ? extractData(result) : { result };
           if (logDuration) {
-            logger4.info(`Node execution completed (${duration}ms)`, data);
+            logger5.info(`Node execution completed (${duration}ms)`, data);
           } else {
-            logger4.info("Node execution completed", data);
+            logger5.info("Node execution completed", data);
           }
         }
         if (onComplete) {
@@ -2545,7 +2545,7 @@ var withLogging = (options) => {
         const duration = Date.now() - startTime;
         const err = error instanceof Error ? error : new Error(String(error));
         if (logErrors) {
-          logger4.error(`Node execution failed (${duration}ms)`, {
+          logger5.error(`Node execution failed (${duration}ms)`, {
             error: err.message,
             stack: err.stack
           });
@@ -2581,7 +2581,7 @@ function withLogging2(options) {
 function production(node, options) {
   const {
     nodeName,
-    logger: logger4,
+    logger: logger5,
     enableMetrics = true,
     enableTracing = true,
     enableRetry = true,
@@ -2589,7 +2589,7 @@ function production(node, options) {
     retryOptions = {},
     errorOptions = {}
   } = options;
-  const actualLogger = logger4 || createLogger(nodeName, { level: "info" /* INFO */ });
+  const actualLogger = logger5 || createLogger(nodeName, { level: "info" /* INFO */ });
   const middleware = [];
   middleware.push(
     withLogging2({
@@ -2653,9 +2653,9 @@ function development(node, options) {
   const {
     nodeName,
     verbose = true,
-    logger: logger4
+    logger: logger5
   } = options;
-  const actualLogger = logger4 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
+  const actualLogger = logger5 || createLogger(nodeName, { level: "debug" /* DEBUG */ });
   return withLogging2({
     logger: actualLogger,
     name: nodeName,
@@ -4767,6 +4767,485 @@ function createCircuitBreaker(options) {
   return new CircuitBreaker(options);
 }
 
+// src/monitoring/health.ts
+var HealthChecker = class {
+  constructor(options) {
+    this.options = options;
+  }
+  checkTimer;
+  lastReport;
+  startTime = Date.now();
+  running = false;
+  start() {
+    if (this.running) {
+      return;
+    }
+    this.running = true;
+    const interval = this.options.interval || 3e4;
+    this.runChecks().catch((error) => {
+      console.error("Initial health check failed:", error);
+    });
+    this.checkTimer = setInterval(() => {
+      this.runChecks().catch((error) => {
+        console.error("Health check failed:", error);
+      });
+    }, interval);
+  }
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    if (this.checkTimer) {
+      clearInterval(this.checkTimer);
+      this.checkTimer = void 0;
+    }
+  }
+  async getHealth() {
+    if (!this.lastReport) {
+      return this.runChecks();
+    }
+    return this.lastReport;
+  }
+  async getLiveness() {
+    return {
+      healthy: true,
+      status: "healthy",
+      message: "Application is running",
+      timestamp: Date.now()
+    };
+  }
+  async getReadiness() {
+    return this.getHealth();
+  }
+  async runChecks() {
+    const timeout2 = this.options.timeout || 5e3;
+    const results = {};
+    const checkPromises = Object.entries(this.options.checks).map(async ([name, check]) => {
+      const startTime = Date.now();
+      try {
+        const result = await Promise.race([
+          check(),
+          new Promise(
+            (_, reject) => setTimeout(() => reject(new Error("Health check timeout")), timeout2)
+          )
+        ]);
+        results[name] = {
+          ...result,
+          timestamp: Date.now(),
+          duration: Date.now() - startTime
+        };
+      } catch (error) {
+        const errorMessage = error.message;
+        results[name] = {
+          healthy: false,
+          status: "unhealthy",
+          error: errorMessage,
+          timestamp: Date.now(),
+          duration: Date.now() - startTime
+        };
+        this.options.onCheckFail?.(name, error);
+      }
+    });
+    await Promise.all(checkPromises);
+    const allHealthy = Object.values(results).every((r) => r.healthy);
+    const anyUnhealthy = Object.values(results).some((r) => r.status === "unhealthy");
+    const status = allHealthy ? "healthy" : anyUnhealthy ? "unhealthy" : "degraded";
+    const report = {
+      healthy: allHealthy,
+      status,
+      timestamp: Date.now(),
+      checks: results,
+      uptime: Date.now() - this.startTime
+    };
+    if (this.lastReport && this.lastReport.healthy !== report.healthy) {
+      this.options.onHealthChange?.(report);
+    }
+    this.lastReport = report;
+    return report;
+  }
+};
+function createHealthChecker(options) {
+  return new HealthChecker(options);
+}
+
+// src/monitoring/profiler.ts
+var Profiler = class {
+  profiles = /* @__PURE__ */ new Map();
+  enabled;
+  sampleRate;
+  includeMemory;
+  includeStack;
+  maxSamples;
+  constructor(options = {}) {
+    this.enabled = options.enabled ?? true;
+    this.sampleRate = options.sampleRate ?? 1;
+    this.includeMemory = options.includeMemory ?? false;
+    this.includeStack = options.includeStack ?? false;
+    this.maxSamples = options.maxSamples ?? 1e3;
+  }
+  profile(name, fn) {
+    return async (...args) => {
+      if (!this.enabled || Math.random() > this.sampleRate) {
+        return fn(...args);
+      }
+      const startTime = Date.now();
+      const startMemory = this.includeMemory ? process.memoryUsage() : void 0;
+      const stack = this.includeStack ? new Error().stack : void 0;
+      try {
+        const result = await fn(...args);
+        this.recordSample(name, startTime, startMemory, stack);
+        return result;
+      } catch (error) {
+        this.recordSample(name, startTime, startMemory, stack);
+        throw error;
+      }
+    };
+  }
+  wrap(name, promise) {
+    if (!this.enabled || Math.random() > this.sampleRate) {
+      return promise;
+    }
+    const startTime = Date.now();
+    const startMemory = this.includeMemory ? process.memoryUsage() : void 0;
+    const stack = this.includeStack ? new Error().stack : void 0;
+    return promise.finally(() => {
+      this.recordSample(name, startTime, startMemory, stack);
+    });
+  }
+  recordSample(name, startTime, startMemory, stack) {
+    const duration = Date.now() - startTime;
+    const sample = {
+      timestamp: startTime,
+      duration
+    };
+    if (this.includeMemory && startMemory) {
+      const currentMemory = process.memoryUsage();
+      sample.memory = {
+        heapUsed: currentMemory.heapUsed - startMemory.heapUsed,
+        heapTotal: currentMemory.heapTotal,
+        external: currentMemory.external
+      };
+    }
+    if (this.includeStack && stack) {
+      sample.stack = stack;
+    }
+    if (!this.profiles.has(name)) {
+      this.profiles.set(name, []);
+    }
+    const samples = this.profiles.get(name);
+    samples.push(sample);
+    if (samples.length > this.maxSamples) {
+      samples.shift();
+    }
+  }
+  getReport() {
+    const report = {};
+    for (const [name, samples] of this.profiles.entries()) {
+      if (samples.length === 0) {
+        continue;
+      }
+      const durations = samples.map((s) => s.duration).sort((a, b) => a - b);
+      const totalTime = durations.reduce((sum, d) => sum + d, 0);
+      const stats = {
+        calls: samples.length,
+        totalTime,
+        avgTime: totalTime / samples.length,
+        minTime: durations[0],
+        maxTime: durations[durations.length - 1],
+        p50: this.percentile(durations, 0.5),
+        p95: this.percentile(durations, 0.95),
+        p99: this.percentile(durations, 0.99),
+        samples
+      };
+      if (this.includeMemory) {
+        const memorySamples = samples.filter((s) => s.memory).map((s) => s.memory.heapUsed);
+        if (memorySamples.length > 0) {
+          stats.memory = {
+            avgHeapUsed: memorySamples.reduce((sum, m) => sum + m, 0) / memorySamples.length,
+            maxHeapUsed: Math.max(...memorySamples),
+            minHeapUsed: Math.min(...memorySamples)
+          };
+        }
+      }
+      report[name] = stats;
+    }
+    return report;
+  }
+  percentile(sorted, p) {
+    const index = Math.ceil(sorted.length * p) - 1;
+    return sorted[Math.max(0, index)];
+  }
+  reset(name) {
+    if (name) {
+      this.profiles.delete(name);
+    } else {
+      this.profiles.clear();
+    }
+  }
+  export(path) {
+    const report = this.getReport();
+    console.log("Exporting profile report to:", path);
+    console.log(JSON.stringify(report, null, 2));
+  }
+};
+function createProfiler(options) {
+  return new Profiler(options);
+}
+
+// src/monitoring/alerts.ts
+var logger4 = createLogger("agentforge:core:monitoring:alerts", { level: "info" /* INFO */ });
+var AlertManager = class {
+  constructor(options) {
+    this.options = options;
+  }
+  lastAlertTime = /* @__PURE__ */ new Map();
+  monitorTimer;
+  running = false;
+  start(metrics, interval = 6e4) {
+    if (this.running || !metrics) {
+      return;
+    }
+    this.running = true;
+    this.monitorTimer = setInterval(() => {
+      const currentMetrics = metrics();
+      this.checkRules(currentMetrics);
+    }, interval);
+  }
+  stop() {
+    if (!this.running) {
+      return;
+    }
+    this.running = false;
+    if (this.monitorTimer) {
+      clearInterval(this.monitorTimer);
+      this.monitorTimer = void 0;
+    }
+  }
+  async alert(alert) {
+    const fullAlert = {
+      ...alert,
+      timestamp: alert.timestamp || Date.now()
+    };
+    if (this.isThrottled(alert.name)) {
+      return;
+    }
+    this.lastAlertTime.set(alert.name, Date.now());
+    this.options.onAlert?.(fullAlert);
+    logger4.warn("Alert triggered", {
+      name: alert.name,
+      severity: alert.severity,
+      message: alert.message,
+      data: alert.data
+    });
+  }
+  checkRules(metrics) {
+    if (!this.options.rules) {
+      return;
+    }
+    for (const rule of this.options.rules) {
+      try {
+        if (rule.condition(metrics)) {
+          this.alert({
+            name: rule.name,
+            severity: rule.severity,
+            message: rule.message || `Alert triggered: ${rule.name}`,
+            data: { metrics }
+          });
+        }
+      } catch (error) {
+        logger4.error("Rule check failed", {
+          ruleName: rule.name,
+          error: error instanceof Error ? error.message : String(error),
+          stack: error instanceof Error ? error.stack : void 0
+        });
+      }
+    }
+  }
+  isThrottled(name) {
+    const rule = this.options.rules?.find((r) => r.name === name);
+    if (!rule?.throttle) {
+      return false;
+    }
+    const lastTime = this.lastAlertTime.get(name);
+    if (!lastTime) {
+      return false;
+    }
+    return Date.now() - lastTime < rule.throttle;
+  }
+  async sendToChannel(channelName, alert) {
+    const channel = this.options.channels[channelName];
+    if (!channel) {
+      throw new Error(`Channel not found: ${channelName}`);
+    }
+    switch (channel.type) {
+      case "email":
+        logger4.info("Alert sent to email", {
+          channel: channelName,
+          to: channel.config.to,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+        break;
+      case "slack":
+        logger4.info("Alert sent to Slack", {
+          channel: channelName,
+          webhookUrl: channel.config.webhookUrl,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+        break;
+      case "webhook":
+        logger4.info("Alert sent to webhook", {
+          channel: channelName,
+          url: channel.config.url,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+        break;
+      default:
+        logger4.info("Alert sent", {
+          channel: channelName,
+          channelType: channel.type,
+          alert: { name: alert.name, severity: alert.severity, message: alert.message }
+        });
+    }
+  }
+  getAlertHistory(name, limit = 100) {
+    return [];
+  }
+  clearAlertHistory(name) {
+    if (name) {
+      this.lastAlertTime.delete(name);
+    } else {
+      this.lastAlertTime.clear();
+    }
+  }
+};
+function createAlertManager(options) {
+  return new AlertManager(options);
+}
+
+// src/monitoring/audit.ts
+var AuditLogger = class {
+  constructor(options = {}) {
+    this.options = options;
+    if (options.retention?.autoCleanup) {
+      this.startCleanup();
+    }
+  }
+  logs = [];
+  cleanupTimer;
+  async log(entry) {
+    const fullEntry = {
+      ...entry,
+      id: this.generateId(),
+      timestamp: entry.timestamp || Date.now(),
+      success: entry.success ?? true
+    };
+    const fields = this.options.fields || {};
+    const filteredEntry = {
+      id: fullEntry.id,
+      userId: fields.userId !== false ? fullEntry.userId : "",
+      action: fields.action !== false ? fullEntry.action : "",
+      resource: fields.resource !== false ? fullEntry.resource : "",
+      timestamp: fields.timestamp !== false ? fullEntry.timestamp : void 0
+    };
+    if (fields.input !== false && fullEntry.input) {
+      filteredEntry.input = fullEntry.input;
+    }
+    if (fields.output !== false && fullEntry.output) {
+      filteredEntry.output = fullEntry.output;
+    }
+    if (fullEntry.metadata) {
+      filteredEntry.metadata = fullEntry.metadata;
+    }
+    if (fullEntry.error) {
+      filteredEntry.error = fullEntry.error;
+      filteredEntry.success = false;
+    }
+    this.logs.push(filteredEntry);
+    this.options.onLog?.(filteredEntry);
+  }
+  async query(query = {}) {
+    let results = [...this.logs];
+    if (query.userId) {
+      results = results.filter((log) => log.userId === query.userId);
+    }
+    if (query.action) {
+      results = results.filter((log) => log.action === query.action);
+    }
+    if (query.resource) {
+      results = results.filter((log) => log.resource === query.resource);
+    }
+    if (query.startDate) {
+      const startTime = query.startDate.getTime();
+      results = results.filter((log) => (log.timestamp || 0) >= startTime);
+    }
+    if (query.endDate) {
+      const endTime = query.endDate.getTime();
+      results = results.filter((log) => (log.timestamp || 0) <= endTime);
+    }
+    const offset = query.offset || 0;
+    const limit = query.limit || 100;
+    results = results.slice(offset, offset + limit);
+    return results;
+  }
+  async export(path, options = {}) {
+    const logs = await this.query({
+      startDate: options.startDate,
+      endDate: options.endDate
+    });
+    const format = options.format || "json";
+    if (format === "json") {
+      console.log(`Exporting ${logs.length} audit logs to ${path} (JSON)`);
+      console.log(JSON.stringify(logs, null, 2));
+    } else if (format === "csv") {
+      console.log(`Exporting ${logs.length} audit logs to ${path} (CSV)`);
+      const csv = this.convertToCSV(logs);
+      console.log(csv);
+    }
+  }
+  convertToCSV(logs) {
+    if (logs.length === 0) {
+      return "";
+    }
+    const headers = ["id", "userId", "action", "resource", "timestamp", "success"];
+    const rows = logs.map((log) => [
+      log.id,
+      log.userId,
+      log.action,
+      log.resource,
+      log.timestamp,
+      log.success
+    ]);
+    return [headers.join(","), ...rows.map((row) => row.join(","))].join("\n");
+  }
+  startCleanup() {
+    const interval = 24 * 60 * 60 * 1e3;
+    this.cleanupTimer = setInterval(() => {
+      this.cleanup();
+    }, interval);
+  }
+  cleanup() {
+    if (!this.options.retention) {
+      return;
+    }
+    const retentionMs = this.options.retention.days * 24 * 60 * 60 * 1e3;
+    const cutoffTime = Date.now() - retentionMs;
+    this.logs = this.logs.filter((log) => (log.timestamp || 0) >= cutoffTime);
+  }
+  generateId() {
+    return `${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+  }
+  stop() {
+    if (this.cleanupTimer) {
+      clearInterval(this.cleanupTimer);
+      this.cleanupTimer = void 0;
+    }
+  }
+};
+function createAuditLogger(options) {
+  return new AuditLogger(options);
+}
+
 // src/prompt-loader/index.ts
 import { readFileSync } from "fs";
 import { join } from "path";
@@ -4830,10 +5309,13 @@ function loadPrompt(promptName, options = {}, promptsDir) {
 }
 export {
   AgentError,
+  AlertManager,
+  AuditLogger,
   BatchProcessor,
   CircuitBreaker,
   ConnectionPool,
   DatabasePool,
+  HealthChecker,
   HttpPool,
   LogLevel,
   ManagedTool,
@@ -4841,6 +5323,7 @@ export {
   MetricType,
   MiddlewareChain,
   MissingDescriptionError,
+  Profiler,
   RegistryEvent,
   TimeoutError,
   ToolBuilder,
@@ -4864,7 +5347,9 @@ export {
   composeWithOptions,
   conditional,
   configureLangSmith,
+  createAlertManager,
   createApprovalRequiredInterrupt,
+  createAuditLogger,
   createBatchProcessor,
   createBinaryRouter,
   createCircuitBreaker,
@@ -4874,6 +5359,7 @@ export {
   createCustomInterrupt,
   createDatabasePool,
   createErrorReporter,
+  createHealthChecker,
   createHeartbeat,
   createHttpPool,
   createHumanRequestInterrupt,
@@ -4887,6 +5373,7 @@ export {
   createMockTool,
   createMultiRouter,
   createParallelWorkflow,
+  createProfiler,
   createProgressTracker,
   createSSEFormatter,
   createSequentialWorkflow,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@agentforge/core",
-  "version": "0.11.8",
+  "version": "0.12.0",
   "description": "Core abstractions for AgentForge - production-ready deep agents framework",
   "type": "module",
   "main": "./dist/index.cjs",