opencode-swarm 7.82.2 → 7.84.0

package/dist/cli/index-p0ye10nd.js

@@ -0,0 +1,222 @@
+// @bun
+// src/telemetry.ts
+import * as fs from "fs";
+import { createWriteStream } from "fs";
+import * as os from "os";
+import * as path from "path";
+var _writeStream = null;
+var _projectDirectory = null;
+var _listeners = [];
+var _disabled = false;
+function resetTelemetryForTesting() {
+  _disabled = false;
+  _projectDirectory = null;
+  _listeners.length = 0;
+  if (_writeStream !== null) {
+    _writeStream.end();
+    _writeStream = null;
+  }
+}
+function initTelemetry(projectDirectory) {
+  if (_writeStream !== null || _disabled) {
+    return;
+  }
+  try {
+    _projectDirectory = projectDirectory;
+    const swarmDir = path.join(projectDirectory, ".swarm");
+    if (!fs.existsSync(swarmDir)) {
+      fs.mkdirSync(swarmDir, { recursive: true });
+    }
+    const telemetryPath = path.join(swarmDir, "telemetry.jsonl");
+    _writeStream = createWriteStream(telemetryPath, { flags: "a" });
+    _writeStream.on("error", () => {
+      _disabled = true;
+      _writeStream = null;
+    });
+  } catch {
+    _disabled = true;
+    _writeStream = null;
+  }
+}
+function emit(event, data) {
+  try {
+    if (_disabled || _writeStream === null) {
+      return;
+    }
+    const line = JSON.stringify({
+      timestamp: new Date().toISOString(),
+      event,
+      ...data
+    }) + os.EOL;
+    _writeStream.write(line, (err) => {
+      if (err) {
+        _disabled = true;
+        _writeStream = null;
+      }
+    });
+    for (const listener of _listeners) {
+      try {
+        listener(event, data);
+      } catch {}
+    }
+  } catch {}
+}
+function addTelemetryListener(callback) {
+  _listeners.push(callback);
+}
+function rotateTelemetryIfNeeded(maxBytes = 10 * 1024 * 1024) {
+  try {
+    if (_projectDirectory === null) {
+      return;
+    }
+    const telemetryPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl");
+    if (!fs.existsSync(telemetryPath)) {
+      return;
+    }
+    const stats = fs.statSync(telemetryPath);
+    if (stats.size < maxBytes) {
+      return;
+    }
+    const rotatedPath = path.join(_projectDirectory, ".swarm", "telemetry.jsonl.1");
+    fs.renameSync(telemetryPath, rotatedPath);
+    if (_writeStream !== null) {
+      _writeStream.end();
+      _writeStream = createWriteStream(telemetryPath, { flags: "a" });
+      _writeStream.on("error", () => {
+        _disabled = true;
+        _writeStream = null;
+      });
+    }
+  } catch {}
+}
+var telemetry = {
+  sessionStarted(sessionId, agentName) {
+    _internals.emit("session_started", { sessionId, agentName });
+  },
+  sessionEnded(sessionId, reason) {
+    _internals.emit("session_ended", { sessionId, reason });
+  },
+  agentActivated(sessionId, agentName, oldName) {
+    _internals.emit("agent_activated", { sessionId, agentName, oldName });
+  },
+  delegationBegin(sessionId, agentName, taskId) {
+    _internals.emit("delegation_begin", { sessionId, agentName, taskId });
+  },
+  delegationEnd(sessionId, agentName, taskId, result) {
+    _internals.emit("delegation_end", { sessionId, agentName, taskId, result });
+  },
+  taskStateChanged(sessionId, taskId, newState, oldState) {
+    _internals.emit("task_state_changed", {
+      sessionId,
+      taskId,
+      newState,
+      oldState
+    });
+  },
+  gatePassed(sessionId, gate, taskId) {
+    _internals.emit("gate_passed", { sessionId, gate, taskId });
+  },
+  gateParseError(taskId, error) {
+    _internals.emit("gate_parse_error", {
+      taskId,
+      errorName: error.name,
+      errorMessage: error.message.slice(0, 200)
+    });
+  },
+  gateFailed(sessionId, gate, taskId, reason) {
+    _internals.emit("gate_failed", { sessionId, gate, taskId, reason });
+  },
+  phaseChanged(sessionId, oldPhase, newPhase) {
+    _internals.emit("phase_changed", { sessionId, oldPhase, newPhase });
+  },
+  budgetUpdated(sessionId, budgetPct, agentName) {
+    _internals.emit("budget_updated", { sessionId, budgetPct, agentName });
+  },
+  modelFallback(sessionId, agentName, fromModel, toModel, reason) {
+    _internals.emit("model_fallback", {
+      sessionId,
+      agentName,
+      fromModel,
+      toModel,
+      reason
+    });
+  },
+  hardLimitHit(sessionId, agentName, limitType, value) {
+    _internals.emit("hard_limit_hit", {
+      sessionId,
+      agentName,
+      limitType,
+      value
+    });
+  },
+  revisionLimitHit(sessionId, agentName) {
+    _internals.emit("revision_limit_hit", { sessionId, agentName });
+  },
+  loopDetected(sessionId, agentName, loopType) {
+    _internals.emit("loop_detected", { sessionId, agentName, loopType });
+  },
+  scopeViolation(sessionId, agentName, file, reason) {
+    _internals.emit("scope_violation", { sessionId, agentName, file, reason });
+  },
+  qaSkipViolation(sessionId, agentName, skipCount) {
+    _internals.emit("qa_skip_violation", { sessionId, agentName, skipCount });
+  },
+  heartbeat(sessionId) {
+    _internals.emit("heartbeat", { sessionId });
+  },
+  turboModeChanged(sessionId, enabled, agentName) {
+    _internals.emit("turbo_mode_changed", { sessionId, enabled, agentName });
+  },
+  autoOversightEscalation(sessionId, reason, interactionCount, deadlockCount, phase) {
+    _internals.emit("auto_oversight_escalation", {
+      sessionId,
+      reason,
+      interactionCount,
+      deadlockCount,
+      phase
+    });
+  },
+  environmentDetected(sessionId, hostOS, shellFamily, executionMode) {
+    _internals.emit("environment_detected", {
+      sessionId,
+      hostOS,
+      shellFamily,
+      executionMode
+    });
+  },
+  prmPatternDetected(sessionId, pattern, severity, category, stepRange) {
+    _internals.emit("prm_pattern_detected", {
+      sessionId,
+      pattern,
+      severity,
+      category,
+      stepRange
+    });
+  },
+  prmCourseCorrectionInjected(sessionId, pattern, level) {
+    _internals.emit("prm_course_correction_injected", {
+      sessionId,
+      pattern,
+      level
+    });
+  },
+  prmEscalationTriggered(sessionId, pattern, level, occurrenceCount) {
+    _internals.emit("prm_escalation_triggered", {
+      sessionId,
+      pattern,
+      level,
+      occurrenceCount
+    });
+  },
+  prmHardStop(sessionId, pattern, level, occurrenceCount) {
+    _internals.emit("prm_hard_stop", {
+      sessionId,
+      pattern,
+      level,
+      occurrenceCount
+    });
+  }
+};
+var _internals = { telemetry, emit };
+
+export { resetTelemetryForTesting, initTelemetry, emit, addTelemetryListener, rotateTelemetryIfNeeded, telemetry, _internals };