@bike4mind/cli 0.2.38 → 0.2.39-feat-context-telemetry.20283

package/dist/{artifactExtractor-TFGLFT32.js → artifactExtractor-YETGVG5I.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   CurationArtifactType
-} from "./chunk-GVIBCLTG.js";
+} from "./chunk-JWPXPARA.js";
 
 // ../../b4m-core/packages/services/dist/src/notebookCurationService/artifactExtractor.js
 var ARTIFACT_TAG_REGEX = /<artifact\s+(.*?)>([\s\S]*?)<\/artifact>/gi;

package/dist/{chunk-JL37DZ2X.js → chunk-2P56HFA4.js}

@@ -1,7 +1,7 @@
 #!/usr/bin/env node
 import {
   ChatModels
-} from "./chunk-GVIBCLTG.js";
+} from "./chunk-JWPXPARA.js";
 import {
   DEFAULT_SANDBOX_CONFIG
 } from "./chunk-4BIBE3J7.js";

package/dist/{chunk-JHHNK6GW.js → chunk-AUHG2IGE.js}

@@ -7,11 +7,11 @@ import {
   getSettingsMap,
   getSettingsValue,
   secureParameters
-} from "./chunk-J3D6HTCL.js";
+} from "./chunk-IM7JYQUE.js";
 import {
   KnowledgeType,
   SupportedFabFileMimeTypes
-} from "./chunk-GVIBCLTG.js";
+} from "./chunk-JWPXPARA.js";
 
 // ../../b4m-core/packages/services/dist/src/fabFileService/create.js
 import { z } from "zod";

package/dist/{chunk-BH7TYL5V.js → chunk-B4QXHMVS.js}

@@ -3,7 +3,7 @@
 // package.json
 var package_default = {
   name: "@bike4mind/cli",
-  version: "0.2.38",
+  version: "0.2.39-feat-context-telemetry.20283+f0547ac8a",
   type: "module",
   description: "Interactive CLI tool for Bike4Mind with ReAct agents",
   license: "UNLICENSED",
@@ -117,10 +117,10 @@ var package_default = {
   },
   devDependencies: {
     "@bike4mind/agents": "0.1.0",
-    "@bike4mind/common": "2.59.0",
-    "@bike4mind/mcp": "1.33.0",
-    "@bike4mind/services": "2.55.0",
-    "@bike4mind/utils": "2.12.0",
+    "@bike4mind/common": "2.59.1-feat-context-telemetry.20283+f0547ac8a",
+    "@bike4mind/mcp": "1.33.1-feat-context-telemetry.20283+f0547ac8a",
+    "@bike4mind/services": "2.55.1-feat-context-telemetry.20283+f0547ac8a",
+    "@bike4mind/utils": "2.12.1-feat-context-telemetry.20283+f0547ac8a",
     "@types/better-sqlite3": "^7.6.13",
     "@types/diff": "^5.0.9",
     "@types/jsonwebtoken": "^9.0.4",
@@ -138,7 +138,7 @@ var package_default = {
   optionalDependencies: {
     "@vscode/ripgrep": "^1.17.0"
   },
-  gitHead: "eb4c0eb10388cadab99cad4ea5430c5efa1e9704"
+  gitHead: "f0547ac8ab4732c9c4744ad3ddeab195138c5389"
 };
 
 // src/utils/updateChecker.ts

package/dist/{chunk-5P336NUR.js → chunk-CU6E3IXM.js}

@@ -4,7 +4,7 @@ import {
   getOpenWeatherKey,
   getSerperKey,
   getWolframAlphaKey
-} from "./chunk-XCFULK7Q.js";
+} from "./chunk-WEGIYLXH.js";
 import {
   BFLImageService,
   BaseStorage,
@@ -16,15 +16,16 @@ import {
   OpenAIBackend,
   OpenAIImageService,
   XAIImageService
-} from "./chunk-J3D6HTCL.js";
+} from "./chunk-IM7JYQUE.js";
 import {
   Logger
 } from "./chunk-PFBYGCOW.js";
 import {
   ConfigStore,
   logger
-} from "./chunk-JL37DZ2X.js";
+} from "./chunk-2P56HFA4.js";
 import {
+  ALERT_THRESHOLDS,
   AiEvents,
   ApiKeyEvents,
   ApiKeyScope,
@@ -80,8 +81,9 @@ import {
   getDataLakeTags,
   getMcpProviderMetadata,
   getViewById,
-  resolveNavigationIntents
-} from "./chunk-GVIBCLTG.js";
+  resolveNavigationIntents,
+  sanitizeTelemetryError
+} from "./chunk-JWPXPARA.js";
 
 // src/utils/fileSearch.ts
 import * as fs from "fs";
@@ -13860,6 +13862,354 @@ var CombinedExtractor = class {
 };
 var combinedExtractor = new CombinedExtractor();
 
+// ../../b4m-core/packages/services/dist/src/telemetry/AnomalyAlertService.js
+var AnomalyAlertService = class _AnomalyAlertService {
+  constructor(loggerOrConfig, alertConfig) {
+    this.dedupCache = /* @__PURE__ */ new Map();
+    if (typeof loggerOrConfig.logger !== "undefined") {
+      const config = loggerOrConfig;
+      this.logger = config.logger;
+      this.config = config.alertConfig;
+      this.cacheRepository = config.cacheRepository;
+      this.slackSender = config.slackSender;
+    } else {
+      this.logger = loggerOrConfig;
+      this.config = alertConfig;
+    }
+  }
+  /**
+   * Check if Slack alerting is properly configured
+   */
+  isSlackConfigured() {
+    return !!(this.config.slackWorkspaceId && this.config.slackChannelId && this.slackSender);
+  }
+  /**
+   * Check if an alert should be sent and send it if appropriate
+   */
+  async checkAndAlert(telemetry) {
+    if (!this.config.enabled || !this.isSlackConfigured()) {
+      return false;
+    }
+    const { anomalies } = telemetry;
+    const threshold = this.config.alertThreshold ?? ALERT_THRESHOLDS.warning;
+    if (anomalies.anomalyScore < threshold) {
+      return false;
+    }
+    const isDup = await this.checkDeduplication(anomalies.dedupKey);
+    if (isDup) {
+      this.logger.info(`\u{1F4CA} [AnomalyAlert] Suppressed duplicate alert: ${anomalies.dedupKey}`);
+      return false;
+    }
+    try {
+      const message = this.formatSlackMessage(telemetry);
+      await this.sendSlackAlert(message);
+      this.logger.info(`\u{1F4CA} [AnomalyAlert] Alert sent for ${anomalies.primaryAnomaly} (score: ${anomalies.anomalyScore})`);
+      return true;
+    } catch (error) {
+      this.logger.error(`\u{1F4CA} [AnomalyAlert] Failed to send alert:`, error);
+      return false;
+    }
+  }
+  /**
+   * Check deduplication and claim the key atomically.
+   * Uses distributed MongoDB cache when available, falls back to in-memory.
+   *
+   * @returns true if this is a duplicate (should not send alert), false if we can proceed
+   */
+  async checkDeduplication(dedupKey) {
+    const windowMs = (this.config.dedupWindowMinutes ?? 5) * 60 * 1e3;
+    const cacheKey = `${_AnomalyAlertService.DEDUP_KEY_PREFIX}${dedupKey}`;
+    if (this.cacheRepository) {
+      try {
+        const result = await this.cacheRepository.claimDedup(cacheKey, { dedupKey, claimedAt: Date.now(), count: 1 }, windowMs);
+        return !result.claimed;
+      } catch (error) {
+        this.logger.warn(`\u{1F4CA} [AnomalyAlert] Distributed dedup failed, using in-memory:`, error);
+      }
+    }
+    return this.checkInMemoryDedup(dedupKey, windowMs);
+  }
+  /**
+   * In-memory deduplication check and record (fallback)
+   */
+  checkInMemoryDedup(dedupKey, windowMs) {
+    const entry = this.dedupCache.get(dedupKey);
+    if (entry) {
+      const timeSinceLastAlert = Date.now() - entry.lastAlertTime;
+      if (timeSinceLastAlert < windowMs) {
+        return true;
+      }
+    }
+    this.recordInMemoryAlert(dedupKey);
+    return false;
+  }
+  /**
+   * Record an alert in the in-memory cache
+   */
+  recordInMemoryAlert(dedupKey) {
+    const existing = this.dedupCache.get(dedupKey);
+    this.dedupCache.set(dedupKey, {
+      dedupKey,
+      lastAlertTime: Date.now(),
+      count: (existing?.count ?? 0) + 1
+    });
+    const oneHourAgo = Date.now() - 60 * 60 * 1e3;
+    for (const [key, entry] of this.dedupCache.entries()) {
+      if (entry.lastAlertTime < oneHourAgo) {
+        this.dedupCache.delete(key);
+      }
+    }
+    if (this.dedupCache.size > _AnomalyAlertService.MAX_CACHE_ENTRIES) {
+      const entries = Array.from(this.dedupCache.entries()).sort((a, b) => a[1].lastAlertTime - b[1].lastAlertTime);
+      const toRemove = entries.slice(0, this.dedupCache.size - _AnomalyAlertService.MAX_CACHE_ENTRIES);
+      for (const [key] of toRemove) {
+        this.dedupCache.delete(key);
+      }
+    }
+  }
+  /**
+   * Format telemetry into a Slack Block Kit message
+   */
+  formatSlackMessage(telemetry) {
+    const { anomalies, model, contextWindow, performance: performance2, tools, subagents } = telemetry;
+    const isCritical = anomalies.anomalyScore >= (this.config.criticalThreshold ?? ALERT_THRESHOLDS.critical);
+    const emoji = this.getSeverityEmoji(anomalies.severity);
+    const severityText = anomalies.severity.toUpperCase();
+    const title = `${emoji} Context Telemetry Alert: ${this.formatAnomalyType(anomalies.primaryAnomaly)}`;
+    const summaryText = `${severityText} anomaly detected (score: ${anomalies.anomalyScore}) - ${anomalies.primaryAnomaly}`;
+    const blocks = [
+      // Header
+      {
+        type: "header",
+        text: {
+          type: "plain_text",
+          text: title,
+          emoji: true
+        }
+      },
+      // Severity and score
+      {
+        type: "section",
+        fields: [
+          {
+            type: "mrkdwn",
+            text: `*Severity:*
+${emoji} ${severityText}`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Anomaly Score:*
+${anomalies.anomalyScore}/100`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Model:*
+${model.modelId}`
+          },
+          {
+            type: "mrkdwn",
+            text: `*Provider:*
+${model.provider}`
+          }
+        ]
+      },
+      // Divider
+      { type: "divider" }
+    ];
+    const anomalyDetails = this.buildAnomalyDetails(anomalies);
+    if (anomalyDetails.length > 0) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*Detected Anomalies:*
+${anomalyDetails.join("\n")}`
+        }
+      });
+    }
+    blocks.push({
+      type: "section",
+      fields: [
+        {
+          type: "mrkdwn",
+          text: `*Input Tokens:*
+${contextWindow.inputTokens.toLocaleString()}`
+        },
+        {
+          type: "mrkdwn",
+          text: `*Utilization:*
+${contextWindow.utilizationPercentage.toFixed(1)}%`
+        },
+        {
+          type: "mrkdwn",
+          text: `*Response Time:*
+${performance2.totalResponseTimeMs.toLocaleString()}ms`
+        },
+        {
+          type: "mrkdwn",
+          text: `*First Token:*
+${performance2.firstTokenTimeMs?.toLocaleString() ?? "N/A"}ms`
+        }
+      ]
+    });
+    const failedTools = tools?.filter((t) => t.failureCount > 0) ?? [];
+    if (failedTools.length > 0) {
+      const toolDetails = failedTools.map((t) => `\u2022 \`${t.toolName}\`: ${t.failureCount} failures${t.lastError ? ` - ${sanitizeTelemetryError(t.lastError, 50)}` : ""}`).join("\n");
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*Tool Failures:*
+${toolDetails}`
+        }
+      });
+    }
+    const timedOutAgents = subagents?.filter((s) => s.timeoutCount > 0) ?? [];
+    if (timedOutAgents.length > 0) {
+      const agentDetails = timedOutAgents.map((s) => `\u2022 \`${s.agentName}\`: ${s.timeoutCount} timeouts, ${s.totalDurationMs.toLocaleString()}ms total`).join("\n");
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*Subagent Timeouts:*
+${agentDetails}`
+        }
+      });
+    }
+    if (model.fallbackUsed) {
+      blocks.push({
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: `*Fallback Used:*
+${model.originalModelId} \u2192 ${model.modelId}
+Reason: ${model.fallbackReason ?? "Unknown"}`
+        }
+      });
+    }
+    blocks.push({ type: "divider" }, {
+      type: "context",
+      elements: [
+        {
+          type: "mrkdwn",
+          text: `Timestamp: ${telemetry.timestamp} | Dedup Key: \`${anomalies.dedupKey}\``
+        }
+      ]
+    });
+    if (isCritical) {
+      blocks.splice(1, 0, {
+        type: "section",
+        text: {
+          type: "mrkdwn",
+          text: "<!here> Critical anomaly requires attention!"
+        }
+      });
+    }
+    return {
+      text: summaryText,
+      blocks
+    };
+  }
+  /**
+   * Build list of detected anomaly details
+   */
+  buildAnomalyDetails(anomalies) {
+    const details = [];
+    if (anomalies.contextOverflow) {
+      details.push("\u{1F6A8} Context window overflow detected");
+    }
+    if (anomalies.criticalUtilization) {
+      details.push("\u26A0\uFE0F Critical context utilization (\u226595%)");
+    } else if (anomalies.highUtilization) {
+      details.push("\u26A0\uFE0F High context utilization (\u226590%)");
+    }
+    if (anomalies.criticalTruncation) {
+      details.push("\u26A0\uFE0F Critical message truncation (\u226575%)");
+    } else if (anomalies.highTruncation) {
+      details.push("\u26A0\uFE0F High message truncation (\u226550%)");
+    }
+    if (anomalies.toolFailureSpike) {
+      details.push("\u{1F527} Tool failure spike (\u22653 failures)");
+    }
+    if (anomalies.toolTimeout) {
+      details.push("\u23F1\uFE0F Tool timeout detected (>30s)");
+    }
+    if (anomalies.subagentTimeout) {
+      details.push("\u{1F916} Subagent timeout detected (>5min)");
+    }
+    if (anomalies.slowTotalResponse) {
+      details.push("\u{1F40C} Slow total response time (>60s)");
+    }
+    if (anomalies.slowFirstToken) {
+      details.push("\u{1F40C} Slow first token time (>10s)");
+    }
+    return details;
+  }
+  /**
+   * Get emoji for severity level
+   */
+  getSeverityEmoji(severity) {
+    switch (severity) {
+      case "critical":
+        return "\u{1F534}";
+      case "high":
+        return "\u{1F7E0}";
+      case "medium":
+        return "\u{1F7E1}";
+      case "low":
+        return "\u{1F7E2}";
+      default:
+        return "\u26AA";
+    }
+  }
+  /**
+   * Format anomaly type for display
+   */
+  formatAnomalyType(type) {
+    switch (type) {
+      case "context_overflow":
+        return "Context Overflow";
+      case "high_truncation":
+        return "High Truncation";
+      case "tool_failure":
+        return "Tool Failure";
+      case "subagent_timeout":
+        return "Subagent Timeout";
+      case "slow_response":
+        return "Slow Response";
+      case "multiple":
+        return "Multiple Anomalies";
+      case "none":
+        return "Unknown";
+      default:
+        return type;
+    }
+  }
+  /**
+   * Send the formatted message to Slack using the configured sender
+   */
+  async sendSlackAlert(message) {
+    if (!this.slackSender || !this.config.slackWorkspaceId || !this.config.slackChannelId) {
+      throw new Error("Slack integration not configured");
+    }
+    await this.slackSender.sendMessage(this.config.slackWorkspaceId, this.config.slackChannelId, message);
+  }
+  /**
+   * Get deduplication statistics for monitoring
+   */
+  getDedupStats() {
+    const fiveMinutesAgo = Date.now() - 5 * 60 * 1e3;
+    const recentAlerts = Array.from(this.dedupCache.values()).filter((e) => e.lastAlertTime >= fiveMinutesAgo).length;
+    return {
+      totalEntries: this.dedupCache.size,
+      recentAlerts,
+      distributedDedupEnabled: !!this.cacheRepository
+    };
+  }
+};
+AnomalyAlertService.MAX_CACHE_ENTRIES = 1e3;
+AnomalyAlertService.DEDUP_KEY_PREFIX = "anomaly-alert-dedup:";
+
 // ../../b4m-core/packages/services/dist/src/llm/ChatCompletionProcess.js
 var DISABLE_SERVER_THROTTLING = process.env.DISABLE_SERVER_THROTTLING === "true";
 var questSaveMutex = new Mutex();

package/dist/{chunk-J3D6HTCL.js → chunk-IM7JYQUE.js}

@@ -19,7 +19,7 @@ import {
   dayjsConfig_default,
   extractSnippetMeta,
   settingsMap
-} from "./chunk-GVIBCLTG.js";
+} from "./chunk-JWPXPARA.js";
 
 // ../../b4m-core/packages/utils/dist/src/storage/S3Storage.js
 import { S3Client, PutObjectCommand, DeleteObjectCommand, GetObjectCommand, HeadObjectCommand } from "@aws-sdk/client-s3";