@backendkit-labs/auto-learning 0.1.0

package/dist/nestjs/index.cjs

@@ -0,0 +1,837 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var __decorateClass = (decorators, target, key, kind) => {
+  var result = kind > 1 ? void 0 : kind ? __getOwnPropDesc(target, key) : target;
+  for (var i = decorators.length - 1, decorator; i >= 0; i--)
+    if (decorator = decorators[i])
+      result = (kind ? decorator(target, key, result) : decorator(result)) || result;
+  if (kind && result) __defProp(target, key, result);
+  return result;
+};
+var __decorateParam = (index, decorator) => (target, key) => decorator(target, key, index);
+
+// src/nestjs/index.ts
+var nestjs_exports = {};
+__export(nestjs_exports, {
+  AUTO_LEARNING_INSTANCE: () => AUTO_LEARNING_INSTANCE,
+  AUTO_LEARNING_OPTIONS: () => AUTO_LEARNING_OPTIONS,
+  AUTO_LEARN_METADATA: () => AUTO_LEARN_METADATA,
+  AutoLearn: () => AutoLearn,
+  AutoLearningModule: () => AutoLearningModule
+});
+module.exports = __toCommonJS(nestjs_exports);
+
+// src/nestjs/auto-learning.module.ts
+var import_common2 = require("@nestjs/common");
+var import_core = require("@nestjs/core");
+
+// src/core/pattern-registry/pattern-registry.ts
+var import_result = require("@backendkit-labs/result");
+
+// src/core/errors.ts
+var storageError = (message, cause) => ({ tag: "STORAGE_ERROR", message, cause });
+var anomalyDetectionFailed = (message) => ({ tag: "ANOMALY_DETECTION_FAILED", message });
+
+// src/core/pattern-registry/pattern-registry.ts
+var PatternRegistry = class {
+  constructor(storage, observability) {
+    this.storage = storage;
+    this.observability = observability;
+  }
+  storage;
+  observability;
+  record(pattern) {
+    const result = this.storage.savePattern(pattern);
+    if (!result.ok) {
+      this.observability.error("Failed to record pattern", {
+        error: result.error,
+        pattern: { method: pattern.method, path: pattern.path }
+      });
+      return (0, import_result.fail)(storageError("Failed to save pattern", result.error));
+    }
+    this.observability.incrementMetric("patterns.recorded", 1, {
+      method: pattern.method,
+      path: pattern.path
+    });
+    this.observability.histogramMetric("patterns.duration_ms", pattern.durationMs, {
+      method: pattern.method,
+      path: pattern.path
+    });
+    return (0, import_result.ok)(void 0);
+  }
+  getAggregates(windowMinutes) {
+    const result = this.storage.getAggregates(windowMinutes);
+    if (!result.ok) {
+      this.observability.error("Failed to get aggregates", { error: result.error });
+      return (0, import_result.fail)(storageError("Failed to get aggregates", result.error));
+    }
+    return (0, import_result.ok)(result.value);
+  }
+  getHistory(endpoint, method, limit) {
+    const now = /* @__PURE__ */ new Date();
+    const past = new Date(now.getTime() - 24 * 60 * 60 * 1e3);
+    const patterns = this.storage.getPatterns(past, now);
+    if (!patterns.ok) {
+      return (0, import_result.fail)(storageError("Failed to get history", patterns.error));
+    }
+    const filtered = patterns.value.filter((p) => p.path === endpoint && p.method === method).slice(-limit);
+    return (0, import_result.ok)(filtered);
+  }
+  getStats() {
+    const now = /* @__PURE__ */ new Date();
+    const past = /* @__PURE__ */ new Date(0);
+    const patterns = this.storage.getPatterns(past, now);
+    if (!patterns.ok) {
+      return (0, import_result.fail)(storageError("Failed to get stats", patterns.error));
+    }
+    const all = patterns.value;
+    if (all.length === 0) {
+      return (0, import_result.ok)({
+        totalPatterns: 0,
+        uniqueEndpoints: 0,
+        oldestPattern: now,
+        newestPattern: now
+      });
+    }
+    const uniqueEndpoints = new Set(all.map((p) => `${p.method}:${p.path}`));
+    const timestamps = all.map((p) => p.timestamp.getTime());
+    return (0, import_result.ok)({
+      totalPatterns: all.length,
+      uniqueEndpoints: uniqueEndpoints.size,
+      oldestPattern: new Date(Math.min(...timestamps)),
+      newestPattern: new Date(Math.max(...timestamps))
+    });
+  }
+};
+
+// src/core/anomaly-detector/types.ts
+var DEFAULT_ANOMALY_CONFIG = {
+  latencyStdDevThreshold: 2.5,
+  errorRateThreshold: 0.05,
+  frequencyDeviationThreshold: 3,
+  enableUnknownEndpointDetection: true
+};
+
+// src/core/anomaly-detector/anomaly-detector.ts
+var import_result2 = require("@backendkit-labs/result");
+var import_uuid = require("uuid");
+var AnomalyDetector = class {
+  config;
+  constructor(config) {
+    this.config = { ...DEFAULT_ANOMALY_CONFIG, ...config };
+  }
+  analyze(current, baseline) {
+    try {
+      const reports = [];
+      if (baseline.count > 0) {
+        const latencyDeviation = Math.abs(current.durationMs - baseline.avgDurationMs) / Math.max(this.stdDev(baseline), 1);
+        if (latencyDeviation > this.config.latencyStdDevThreshold) {
+          reports.push({
+            id: (0, import_uuid.v4)(),
+            endpoint: current.path,
+            method: current.method,
+            severity: this.calculateSeverity(latencyDeviation),
+            metric: "latency",
+            expectedValue: baseline.avgDurationMs,
+            actualValue: current.durationMs,
+            deviation: latencyDeviation,
+            detectedAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      if (current.statusCode >= 500 && baseline.errorCount >= 3) {
+        const currentErrorRate = 1;
+        if (currentErrorRate > baseline.errorRate * 2 && currentErrorRate > this.config.errorRateThreshold) {
+          reports.push({
+            id: (0, import_uuid.v4)(),
+            endpoint: current.path,
+            method: current.method,
+            severity: "high",
+            metric: "error_rate",
+            expectedValue: baseline.errorRate,
+            actualValue: currentErrorRate,
+            deviation: currentErrorRate / Math.max(baseline.errorRate, 1e-3),
+            detectedAt: /* @__PURE__ */ new Date()
+          });
+        }
+      }
+      return (0, import_result2.ok)(reports.length > 0 ? reports[0] : null);
+    } catch (e) {
+      return (0, import_result2.fail)(
+        anomalyDetectionFailed(
+          e instanceof Error ? e.message : "Unknown anomaly detection error"
+        )
+      );
+    }
+  }
+  batchAnalyze(windowPatterns, baselines) {
+    try {
+      const baselineMap = /* @__PURE__ */ new Map();
+      for (const b of baselines) {
+        baselineMap.set(`${b.method}:${b.path}`, b);
+      }
+      const reports = [];
+      for (const pattern of windowPatterns) {
+        const key = `${pattern.method}:${pattern.path}`;
+        const baseline = baselineMap.get(key);
+        if (!baseline) {
+          if (this.config.enableUnknownEndpointDetection) {
+            reports.push({
+              id: (0, import_uuid.v4)(),
+              endpoint: pattern.path,
+              method: pattern.method,
+              severity: "low",
+              metric: "unknown_endpoint",
+              expectedValue: 0,
+              actualValue: 1,
+              deviation: 1,
+              detectedAt: /* @__PURE__ */ new Date()
+            });
+          }
+          continue;
+        }
+        const result = this.analyze(pattern, baseline);
+        if (result.ok && result.value) {
+          reports.push(result.value);
+        }
+      }
+      return (0, import_result2.ok)(reports);
+    } catch (e) {
+      return (0, import_result2.fail)(
+        anomalyDetectionFailed(
+          e instanceof Error ? e.message : "Unknown batch analysis error"
+        )
+      );
+    }
+  }
+  calculateSeverity(deviation) {
+    if (deviation > 5) return "critical";
+    if (deviation > 4) return "high";
+    if (deviation > 3) return "medium";
+    return "low";
+  }
+  stdDev(baseline) {
+    return (baseline.p95Ms - baseline.p50Ms) / 2;
+  }
+};
+
+// src/core/config-tuner/types.ts
+var DEFAULT_TUNER_CONFIG = {
+  minTimeoutMs: 1e3,
+  maxTimeoutMs: 3e4,
+  smoothingFactor: 0.3,
+  adjustmentStepMs: 500
+};
+
+// src/core/config-tuner/config-tuner.ts
+var import_result3 = require("@backendkit-labs/result");
+var DEFAULT_CONFIG = {
+  timeoutMs: 1e4,
+  maxRetries: 3,
+  circuitBreakerThreshold: 0.5,
+  circuitBreakerHalfOpenAfterMs: 3e4,
+  bulkheadMaxConcurrent: 10
+};
+var ConfigTuner = class {
+  constructor(storage, observability, tunerConfig) {
+    this.storage = storage;
+    this.observability = observability;
+    this.config = { ...DEFAULT_TUNER_CONFIG, ...tunerConfig };
+    const loaded = this.storage.loadConfig();
+    this.currentConfig = loaded.ok && loaded.value ? loaded.value : { ...DEFAULT_CONFIG };
+  }
+  storage;
+  observability;
+  currentConfig;
+  config;
+  listeners = [];
+  lastChangeAt = 0;
+  getCurrentConfig() {
+    return { ...this.currentConfig };
+  }
+  tune(aggregates, anomalies) {
+    if (aggregates.length === 0) {
+      return (0, import_result3.ok)(this.getCurrentConfig());
+    }
+    const newConfig = { ...this.currentConfig };
+    const changes = {};
+    const maxP95 = Math.max(...aggregates.map((a) => a.p95Ms));
+    const targetTimeout = Math.min(
+      Math.max(maxP95 * 2, this.config.minTimeoutMs),
+      this.config.maxTimeoutMs
+    );
+    if (Math.abs(targetTimeout - newConfig.timeoutMs) > this.config.adjustmentStepMs) {
+      newConfig.timeoutMs = this.smoothValue(
+        newConfig.timeoutMs,
+        targetTimeout
+      );
+      changes.timeoutMs = newConfig.timeoutMs;
+    }
+    const avgErrorRate = aggregates.reduce((sum, a) => sum + a.errorRate, 0) / aggregates.length;
+    if (avgErrorRate > 0.1) {
+      newConfig.maxRetries = Math.min(newConfig.maxRetries + 1, 5);
+      changes.maxRetries = newConfig.maxRetries;
+    } else if (avgErrorRate < 0.01 && newConfig.maxRetries > 1) {
+      newConfig.maxRetries = Math.max(newConfig.maxRetries - 1, 0);
+      changes.maxRetries = newConfig.maxRetries;
+    }
+    const criticalAnomalies = anomalies.filter(
+      (a) => a.severity === "critical" || a.severity === "high"
+    ).length;
+    if (criticalAnomalies > 0) {
+      newConfig.circuitBreakerThreshold = Math.max(
+        this.currentConfig.circuitBreakerThreshold - 0.1 * criticalAnomalies,
+        0.1
+      );
+      changes.circuitBreakerThreshold = newConfig.circuitBreakerThreshold;
+    } else if (anomalies.length === 0) {
+      newConfig.circuitBreakerThreshold = Math.min(
+        this.currentConfig.circuitBreakerThreshold + 0.05,
+        0.8
+      );
+      changes.circuitBreakerThreshold = newConfig.circuitBreakerThreshold;
+    }
+    if (Object.keys(changes).length > 0) {
+      const now = Date.now();
+      if (now - this.lastChangeAt > 6e4) {
+        this.currentConfig = newConfig;
+        this.lastChangeAt = now;
+        const saveResult = this.storage.saveConfig(newConfig);
+        if (!saveResult.ok) {
+          return (0, import_result3.fail)(storageError("Failed to save config", saveResult.error));
+        }
+        this.observability.info("Config tuned", { changes });
+        this.observability.incrementMetric("config.changes", 1);
+        for (const listener of this.listeners) {
+          listener(this.getCurrentConfig());
+        }
+      }
+    }
+    return (0, import_result3.ok)(this.getCurrentConfig());
+  }
+  reset() {
+    this.currentConfig = { ...DEFAULT_CONFIG };
+    const saveResult = this.storage.saveConfig(this.currentConfig);
+    if (!saveResult.ok) {
+      return (0, import_result3.fail)(storageError("Failed to reset config", saveResult.error));
+    }
+    this.observability.info("Config reset to defaults");
+    for (const listener of this.listeners) {
+      listener(this.getCurrentConfig());
+    }
+    return (0, import_result3.ok)(this.getCurrentConfig());
+  }
+  onConfigChange(callback) {
+    this.listeners.push(callback);
+  }
+  smoothValue(current, target) {
+    return current + (target - current) * this.config.smoothingFactor;
+  }
+};
+
+// src/core/feedback-loop/types.ts
+var DEFAULT_LOOP_CONFIG = {
+  defaultIntervalMs: 6e4,
+  windowSizeMinutes: 5,
+  minSamplesBeforeTuning: 10,
+  cooldownBetweenChangesMs: 12e4
+};
+
+// src/core/feedback-loop/feedback-loop.ts
+var import_result4 = require("@backendkit-labs/result");
+var import_uuid2 = require("uuid");
+var FeedbackLoop = class {
+  constructor(patternRegistry, anomalyDetector, configTuner, storage, observability, loopConfig) {
+    this.patternRegistry = patternRegistry;
+    this.anomalyDetector = anomalyDetector;
+    this.configTuner = configTuner;
+    this.storage = storage;
+    this.observability = observability;
+    this.config = { ...DEFAULT_LOOP_CONFIG, ...loopConfig };
+  }
+  patternRegistry;
+  anomalyDetector;
+  configTuner;
+  storage;
+  observability;
+  timerId = null;
+  config;
+  cycleListeners = [];
+  start(intervalMs) {
+    if (this.timerId !== null) {
+      this.observability.warn("Feedback loop already running, ignoring start");
+      return;
+    }
+    const interval = intervalMs ?? this.config.defaultIntervalMs;
+    this.observability.info("Feedback loop started", { intervalMs: interval });
+    this.timerId = setInterval(() => {
+      this.runOnce().then((result) => {
+        if (!result.ok) {
+          this.observability.error("Feedback loop cycle failed", {
+            error: result.error
+          });
+        }
+      });
+    }, interval);
+  }
+  stop() {
+    if (this.timerId === null) {
+      this.observability.warn("Feedback loop not running, ignoring stop");
+      return;
+    }
+    clearInterval(this.timerId);
+    this.timerId = null;
+    this.observability.info("Feedback loop stopped");
+  }
+  isRunning() {
+    return this.timerId !== null;
+  }
+  async runOnce() {
+    const cycleId = (0, import_uuid2.v4)();
+    const startTime = Date.now();
+    this.observability.debug("Feedback cycle started", { cycleId });
+    const patternsResult = this.storage.getPatterns(
+      new Date(Date.now() - this.config.windowSizeMinutes * 6e4),
+      /* @__PURE__ */ new Date()
+    );
+    if (!patternsResult.ok) {
+      return (0, import_result4.fail)(storageError("Failed to collect patterns", patternsResult.error));
+    }
+    const patterns = patternsResult.value;
+    if (patterns.length < this.config.minSamplesBeforeTuning) {
+      this.observability.debug("Skipping cycle: insufficient samples", {
+        actual: patterns.length,
+        required: this.config.minSamplesBeforeTuning
+      });
+      const skippedEvent = {
+        cycleId,
+        timestamp: /* @__PURE__ */ new Date(),
+        patternsProcessed: patterns.length,
+        anomaliesFound: 0,
+        configChanges: {},
+        durationMs: Date.now() - startTime
+      };
+      return (0, import_result4.ok)(skippedEvent);
+    }
+    const aggregatesResult = this.patternRegistry.getAggregates(
+      this.config.windowSizeMinutes
+    );
+    if (!aggregatesResult.ok) {
+      return (0, import_result4.fail)(aggregatesResult.error);
+    }
+    const aggregates = aggregatesResult.value;
+    const anomaliesResult = this.anomalyDetector.batchAnalyze(patterns, aggregates);
+    if (!anomaliesResult.ok) {
+      return (0, import_result4.fail)(anomaliesResult.error);
+    }
+    const anomalies = anomaliesResult.value;
+    for (const anomaly of anomalies) {
+      this.storage.saveAnomaly(anomaly);
+    }
+    if (anomalies.length > 0) {
+      this.observability.warn("Anomalies detected", {
+        count: anomalies.length,
+        severities: anomalies.map((a) => a.severity)
+      });
+      this.observability.incrementMetric("anomalies.detected", anomalies.length);
+    }
+    const tuneResult = this.configTuner.tune(aggregates, anomalies);
+    if (!tuneResult.ok) {
+      return (0, import_result4.fail)(tuneResult.error);
+    }
+    const newConfig = tuneResult.value;
+    const previousConfig = this.configTuner.getCurrentConfig();
+    const configChanges = {};
+    const configKeys = Object.keys(newConfig);
+    for (const key of configKeys) {
+      if (newConfig[key] !== previousConfig[key]) {
+        configChanges[key] = newConfig[key];
+      }
+    }
+    const cycleEvent = {
+      cycleId,
+      timestamp: /* @__PURE__ */ new Date(),
+      patternsProcessed: patterns.length,
+      anomaliesFound: anomalies.length,
+      configChanges,
+      durationMs: Date.now() - startTime
+    };
+    const saveResult = this.storage.saveCycleEvent(cycleEvent);
+    if (!saveResult.ok) {
+      this.observability.error("Failed to save cycle event", { error: saveResult.error });
+      return (0, import_result4.fail)(saveResult.error);
+    }
+    for (const listener of this.cycleListeners) {
+      listener(cycleEvent);
+    }
+    this.observability.info("Feedback cycle completed", {
+      cycleId,
+      patternsProcessed: cycleEvent.patternsProcessed,
+      anomaliesFound: cycleEvent.anomaliesFound,
+      durationMs: cycleEvent.durationMs
+    });
+    this.observability.histogramMetric("cycle.duration_ms", cycleEvent.durationMs);
+    this.observability.gaugeMetric("cycle.patterns_count", cycleEvent.patternsProcessed);
+    return (0, import_result4.ok)(cycleEvent);
+  }
+  onCycle(callback) {
+    this.cycleListeners.push(callback);
+  }
+};
+
+// src/core/persistence/in-memory-storage.ts
+var import_result5 = require("@backendkit-labs/result");
+var DEFAULT_CONFIG2 = {
+  timeoutMs: 1e4,
+  maxRetries: 3,
+  circuitBreakerThreshold: 0.5,
+  circuitBreakerHalfOpenAfterMs: 3e4,
+  bulkheadMaxConcurrent: 10
+};
+function percentile(sorted, p) {
+  if (sorted.length === 0) return 0;
+  const index = Math.ceil(p / 100 * sorted.length) - 1;
+  return sorted[Math.max(0, index)];
+}
+var InMemoryStorage = class {
+  patterns = [];
+  anomalies = [];
+  config = { ...DEFAULT_CONFIG2 };
+  cycles = [];
+  savePattern(pattern) {
+    try {
+      this.patterns.push(pattern);
+      return (0, import_result5.ok)(void 0);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to save pattern", e));
+    }
+  }
+  getPatterns(windowStart, windowEnd) {
+    try {
+      return (0, import_result5.ok)(
+        this.patterns.filter(
+          (p) => p.timestamp >= windowStart && p.timestamp <= windowEnd
+        )
+      );
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to get patterns", e));
+    }
+  }
+  getAggregates(windowMinutes) {
+    try {
+      const cutoff = new Date(Date.now() - windowMinutes * 6e4);
+      const recent = this.patterns.filter((p) => p.timestamp >= cutoff);
+      const groups = /* @__PURE__ */ new Map();
+      for (const p of recent) {
+        const key = `${p.method}:${p.path}`;
+        if (!groups.has(key)) groups.set(key, []);
+        groups.get(key).push(p);
+      }
+      const aggregates = [];
+      for (const [key, items] of groups) {
+        const [method, path] = key.split(":");
+        const durations = items.map((i) => i.durationMs).sort((a, b) => a - b);
+        const errors = items.filter((i) => i.statusCode >= 500).length;
+        aggregates.push({
+          method,
+          path,
+          windowStart: cutoff,
+          windowEnd: /* @__PURE__ */ new Date(),
+          count: items.length,
+          avgDurationMs: durations.reduce((a, b) => a + b, 0) / durations.length,
+          p50Ms: percentile(durations, 50),
+          p95Ms: percentile(durations, 95),
+          p99Ms: percentile(durations, 99),
+          errorCount: errors,
+          errorRate: errors / items.length
+        });
+      }
+      return (0, import_result5.ok)(aggregates);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to get aggregates", e));
+    }
+  }
+  saveAnomaly(report) {
+    try {
+      this.anomalies.push(report);
+      return (0, import_result5.ok)(void 0);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to save anomaly", e));
+    }
+  }
+  getRecentAnomalies(limit) {
+    try {
+      return (0, import_result5.ok)(this.anomalies.slice(-limit).reverse());
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to get recent anomalies", e));
+    }
+  }
+  saveConfig(config) {
+    try {
+      this.config = { ...config };
+      return (0, import_result5.ok)(void 0);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to save config", e));
+    }
+  }
+  loadConfig() {
+    try {
+      return (0, import_result5.ok)(this.config);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to load config", e));
+    }
+  }
+  saveCycleEvent(event) {
+    try {
+      this.cycles.push(event);
+      return (0, import_result5.ok)(void 0);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to save cycle event", e));
+    }
+  }
+  getLastCycleTime() {
+    try {
+      if (this.cycles.length === 0) return (0, import_result5.ok)(null);
+      return (0, import_result5.ok)(this.cycles[this.cycles.length - 1].timestamp);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to get last cycle time", e));
+    }
+  }
+  prune(before) {
+    try {
+      const beforeLen = this.patterns.length + this.anomalies.length;
+      this.patterns = this.patterns.filter((p) => p.timestamp >= before);
+      this.anomalies = this.anomalies.filter((a) => a.detectedAt >= before);
+      const pruned = beforeLen - (this.patterns.length + this.anomalies.length);
+      return (0, import_result5.ok)(pruned);
+    } catch (e) {
+      return (0, import_result5.fail)(storageError("Failed to prune", e));
+    }
+  }
+};
+
+// src/core/observability/noop-observability-adapter.ts
+var NoopObservabilityAdapter = class {
+  info(_msg, _meta) {
+  }
+  warn(_msg, _meta) {
+  }
+  error(_msg, _meta) {
+  }
+  debug(_msg, _meta) {
+  }
+  incrementMetric(_name, _value, _tags) {
+  }
+  gaugeMetric(_name, _value, _tags) {
+  }
+  histogramMetric(_name, _value, _tags) {
+  }
+};
+
+// src/core/auto-learning-core.ts
+var AutoLearningCore = class _AutoLearningCore {
+  constructor(patternRegistry, anomalyDetector, configTuner, feedbackLoop, storage, observability) {
+    this.patternRegistry = patternRegistry;
+    this.anomalyDetector = anomalyDetector;
+    this.configTuner = configTuner;
+    this.feedbackLoop = feedbackLoop;
+    this.storage = storage;
+    this.observability = observability;
+  }
+  patternRegistry;
+  anomalyDetector;
+  configTuner;
+  feedbackLoop;
+  storage;
+  observability;
+  static create(options) {
+    const storage = options?.storage ?? new InMemoryStorage();
+    const obs = options?.observability ?? new NoopObservabilityAdapter();
+    const registry = new PatternRegistry(storage, obs);
+    const detector = new AnomalyDetector(options?.anomalyConfig);
+    const tuner = new ConfigTuner(storage, obs, options?.tunerConfig);
+    const loop = new FeedbackLoop(registry, detector, tuner, storage, obs, options?.loopConfig);
+    return new _AutoLearningCore(registry, detector, tuner, loop, storage, obs);
+  }
+  recordPattern(pattern) {
+    return this.patternRegistry.record(pattern);
+  }
+  getCurrentConfig() {
+    return this.configTuner.getCurrentConfig();
+  }
+  startFeedbackLoop(intervalMs) {
+    this.feedbackLoop.start(intervalMs);
+  }
+  stopFeedbackLoop() {
+    this.feedbackLoop.stop();
+  }
+  isFeedbackLoopRunning() {
+    return this.feedbackLoop.isRunning();
+  }
+  async runOnce() {
+    return this.feedbackLoop.runOnce();
+  }
+  onConfigChange(callback) {
+    this.configTuner.onConfigChange(callback);
+  }
+  onCycle(callback) {
+    this.feedbackLoop.onCycle(callback);
+  }
+};
+
+// src/nestjs/auto-learning.interceptor.ts
+var import_common = require("@nestjs/common");
+var import_rxjs = require("rxjs");
+
+// src/nestjs/auto-learning.constants.ts
+var AUTO_LEARNING_OPTIONS = /* @__PURE__ */ Symbol("AUTO_LEARNING_OPTIONS");
+var AUTO_LEARNING_INSTANCE = /* @__PURE__ */ Symbol("AUTO_LEARNING_INSTANCE");
+var AUTO_LEARN_METADATA = "auto_learn_metadata";
+
+// src/nestjs/auto-learning.interceptor.ts
+var AutoLearningInterceptor = class {
+  constructor(reflector, core) {
+    this.reflector = reflector;
+    this.core = core;
+  }
+  reflector;
+  core;
+  intercept(context, next) {
+    const options = this.reflector.get(
+      AUTO_LEARN_METADATA,
+      context.getHandler()
+    );
+    if (!options) {
+      return next.handle();
+    }
+    const start = Date.now();
+    const req = context.switchToHttp().getRequest();
+    const { method, path } = this.extractRequestInfo(req);
+    return next.handle().pipe(
+      (0, import_rxjs.tap)(() => {
+        const duration = Date.now() - start;
+        const status = context.switchToHttp().getResponse().statusCode;
+        this.core.recordPattern({
+          method,
+          path,
+          statusCode: status,
+          durationMs: duration,
+          timestamp: /* @__PURE__ */ new Date(),
+          metadata: options.customMetadata ? options.customMetadata(req) : void 0
+        });
+      })
+    );
+  }
+  extractRequestInfo(req) {
+    const method = req.method ?? "UNKNOWN";
+    const path = req.route?.path ?? req.path ?? req.url ?? "/";
+    return { method, path };
+  }
+};
+AutoLearningInterceptor = __decorateClass([
+  (0, import_common.Injectable)(),
+  __decorateParam(1, (0, import_common.Inject)(AUTO_LEARNING_INSTANCE))
+], AutoLearningInterceptor);
+
+// src/nestjs/backend-kit-observability-adapter.ts
+var BackendKitObservabilityAdapter = class {
+  constructor(logger, metrics) {
+    this.logger = logger;
+    this.metrics = metrics;
+  }
+  logger;
+  metrics;
+  prefix = "auto_learning";
+  info(msg, meta) {
+    this.logger.log?.(`[AutoLearn] ${msg}`, meta);
+  }
+  warn(msg, meta) {
+    this.logger.warn?.(`[AutoLearn] ${msg}`, meta);
+  }
+  error(msg, meta) {
+    this.logger.error?.(`[AutoLearn] ${msg}`, meta);
+  }
+  debug(msg, meta) {
+    this.logger.debug?.(`[AutoLearn] ${msg}`, meta);
+  }
+  incrementMetric(name, value = 1, tags) {
+    this.metrics?.increment?.(`${this.prefix}.${name}`, value, tags);
+  }
+  gaugeMetric(name, value, tags) {
+    this.metrics?.gauge?.(`${this.prefix}.${name}`, value, tags);
+  }
+  histogramMetric(name, value, tags) {
+    this.metrics?.histogram?.(`${this.prefix}.${name}`, value, tags);
+  }
+};
+
+// src/nestjs/auto-learning.module.ts
+var AutoLearningModule = class {
+  static forRoot(options = {}) {
+    const providers = [
+      {
+        provide: AUTO_LEARNING_OPTIONS,
+        useValue: options
+      },
+      {
+        provide: AUTO_LEARNING_INSTANCE,
+        useFactory: (opts) => {
+          let observability;
+          if (opts.observability?.logger) {
+            observability = new BackendKitObservabilityAdapter(
+              opts.observability.logger,
+              opts.observability.metrics
+            );
+          }
+          return AutoLearningCore.create({
+            ...opts.coreOptions,
+            observability
+          });
+        },
+        inject: [AUTO_LEARNING_OPTIONS]
+      },
+      {
+        provide: import_core.APP_INTERCEPTOR,
+        useClass: AutoLearningInterceptor
+      }
+    ];
+    return {
+      module: AutoLearningModule,
+      providers,
+      exports: [AUTO_LEARNING_INSTANCE],
+      global: true
+    };
+  }
+};
+AutoLearningModule = __decorateClass([
+  (0, import_common2.Module)({})
+], AutoLearningModule);
+
+// src/nestjs/auto-learning.decorator.ts
+var import_common3 = require("@nestjs/common");
+var AutoLearn = (options) => (0, import_common3.SetMetadata)(AUTO_LEARN_METADATA, options ?? {});
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AUTO_LEARNING_INSTANCE,
+  AUTO_LEARNING_OPTIONS,
+  AUTO_LEARN_METADATA,
+  AutoLearn,
+  AutoLearningModule
+});
+//# sourceMappingURL=index.cjs.map