opencode-swarm 7.83.0 → 7.85.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 };

package/dist/cli/index-qqabjns2.js

@@ -0,0 +1,412 @@
+// @bun
+import {
+  handleGuardrailExplain
+} from "./index-x7qck34v.js";
+import {
+  handleGuardrailLog
+} from "./index-5cb86007.js";
+import {
+  COMMAND_REGISTRY,
+  SWARM_COMMAND_TOOL_ALLOWLIST,
+  SWARM_COMMAND_TOOL_COMMANDS,
+  VALID_COMMANDS,
+  _internals,
+  canonicalCommandKey,
+  classifySwarmCommandChatFallbackUse,
+  classifySwarmCommandToolUse,
+  executeSwarmCommand,
+  formatCommandNotFound,
+  handleAcknowledgeSpecDriftCommand,
+  handleAgentsCommand,
+  handleAnalyzeCommand,
+  handleArchiveCommand,
+  handleAutoProceedCommand,
+  handleBenchmarkCommand,
+  handleBrainstormCommand,
+  handleCheckpointCommand,
+  handleClarifyCommand,
+  handleCloseCommand,
+  handleCodebaseReviewCommand,
+  handleConcurrencyCommand,
+  handleConfigCommand,
+  handleConsolidateCommand,
+  handleCouncilCommand,
+  handleCurateCommand,
+  handleDarkMatterCommand,
+  handleDeepDiveCommand,
+  handleDeepResearchCommand,
+  handleDiagnoseCommand,
+  handleDoctorCommand,
+  handleEvidenceCommand,
+  handleEvidenceSummaryCommand,
+  handleExportCommand,
+  handleFullAutoCommand,
+  handleHandoffCommand,
+  handleHelpCommand,
+  handleHistoryCommand,
+  handleKnowledgeListCommand,
+  handleKnowledgeMigrateCommand,
+  handleKnowledgeQuarantineCommand,
+  handleKnowledgeRestoreCommand,
+  handleKnowledgeRetryHardeningCommand,
+  handleKnowledgeUnactionableCommand,
+  handleLearningCommand,
+  handleMemoryCommand,
+  handleMemoryExportCommand,
+  handleMemoryImportCommand,
+  handleMemoryMigrateCommand,
+  handleMemoryStatusCommand,
+  handlePlanCommand,
+  handlePreflightCommand,
+  handlePromoteCommand,
+  handleQaGatesCommand,
+  handleResetCommand,
+  handleResetSessionCommand,
+  handleRetrieveCommand,
+  handleRollbackCommand,
+  handleSddCommand,
+  handleSddProjectCommand,
+  handleSddStatusCommand,
+  handleSddValidateCommand,
+  handleSimulateCommand,
+  handleSpecifyCommand,
+  handleStatusCommand,
+  handleSyncPlanCommand,
+  handleTurboCommand,
+  handleWriteRetroCommand,
+  normalizeSwarmCommandInput,
+  resolveCommand
+} from "./index-yhqt45de.js";
+import"./index-vq2321gg.js";
+import"./index-yhsmmv2z.js";
+import"./index-d9fbxaqd.js";
+import"./index-e8pk68cc.js";
+import"./index-0sxvwjt0.js";
+import {
+  AGENT_TOOL_MAP,
+  ORCHESTRATOR_NAME,
+  stripKnownSwarmPrefix
+} from "./index-hw9b2xng.js";
+import"./index-red8fm8p.js";
+import"./index-f8r50m3h.js";
+import"./index-hz59hg4h.js";
+import"./index-e7h9bb6v.js";
+import"./index-fjwwrwr5.js";
+import"./index-eb85wtx9.js";
+import"./index-ckntc5gf.js";
+import"./index-jtqkh8jf.js";
+import"./index-zfsbaaqh.js";
+import"./index-p0arc26j.js";
+import"./index-yx44zd0p.js";
+import"./index-bcp79s17.js";
+import"./index-293f68mj.js";
+import"./index-b9v501fr.js";
+import"./index-p0ye10nd.js";
+import"./index-a76rekgs.js";
+// src/commands/command-names.ts
+var COMMAND_NAMES = Object.freeze(Object.keys(COMMAND_REGISTRY));
+var COMMAND_NAME_SET = new Set(COMMAND_NAMES);
+
+// src/commands/index.ts
+function buildHelpText() {
+  const lines = [
+    "## Swarm Commands",
+    "",
+    "**Chat routing note**: supported read-only `/swarm` commands are routed through the `swarm_command` tool when the active agent has that tool. Unsupported or state-changing commands remain chat-mediated; use `bunx opencode-swarm run <subcommand>` when you need canonical output.",
+    ""
+  ];
+  const CATEGORIES = [
+    "core",
+    "agent",
+    "config",
+    "diagnostics",
+    "utility"
+  ];
+  const byCategory = new Map;
+  for (const cat of CATEGORIES) {
+    byCategory.set(cat, []);
+  }
+  const deprecatedAliases = [];
+  for (const cmd of VALID_COMMANDS) {
+    const entry = COMMAND_REGISTRY[cmd];
+    if (entry.aliasOf) {
+      deprecatedAliases.push({ name: cmd, aliasOf: entry.aliasOf });
+      continue;
+    }
+    if (entry.subcommandOf) {
+      continue;
+    }
+    if (cmd.includes(" ")) {
+      continue;
+    }
+    const category = entry.category || "utility";
+    const catLines = byCategory.get(category) || [];
+    catLines.push(cmd);
+    byCategory.set(category, catLines);
+  }
+  const shownAsSubcommand = new Set;
+  for (const cat of CATEGORIES) {
+    const catLines = byCategory.get(cat);
+    if (!catLines || catLines.length === 0)
+      continue;
+    const catTitle = cat.charAt(0).toUpperCase() + cat.slice(1);
+    lines.push(`### ${catTitle}`, "");
+    for (const cmd of catLines) {
+      const entry = COMMAND_REGISTRY[cmd];
+      lines.push(`- \`/swarm ${cmd}\` \u2014 ${entry.description}`);
+      if (entry.clashesWithNativeCcCommand) {
+        lines.push(`  \u26A0\uFE0F Name conflicts with CC built-in \`${entry.clashesWithNativeCcCommand}\` \u2014 always use \`/swarm ${cmd}\``);
+      }
+      if (entry.args) {
+        lines.push(`  Args: \`${entry.args}\``);
+      }
+      if (entry.details) {
+        lines.push(`  ${entry.details}`);
+      }
+      const subcommands = VALID_COMMANDS.filter((sub) => sub.startsWith(`${cmd} `) && sub !== cmd);
+      for (const sub of subcommands) {
+        shownAsSubcommand.add(sub);
+        const subEntry = COMMAND_REGISTRY[sub];
+        const subName = sub.slice(cmd.length + 1);
+        lines.push(`  - \`${subName}\` \u2014 ${subEntry.description}`);
+        if (subEntry.args) {
+          lines.push(`    Args: \`${subEntry.args}\``);
+        }
+        if (subEntry.details) {
+          lines.push(`    ${subEntry.details}`);
+        }
+      }
+    }
+    lines.push("");
+  }
+  for (const cmd of VALID_COMMANDS) {
+    if (!cmd.includes(" ") || shownAsSubcommand.has(cmd))
+      continue;
+    const entry = COMMAND_REGISTRY[cmd];
+    if (entry.aliasOf || entry.subcommandOf)
+      continue;
+    lines.push(`- \`/swarm ${cmd}\` \u2014 ${entry.description}`);
+    if (entry.clashesWithNativeCcCommand) {
+      lines.push(`  \u26A0\uFE0F Name conflicts with CC built-in \`${entry.clashesWithNativeCcCommand}\` \u2014 always use \`/swarm ${cmd}\``);
+    }
+    if (entry.args) {
+      lines.push(`  Args: \`${entry.args}\``);
+    }
+    if (entry.details) {
+      lines.push(`  ${entry.details}`);
+    }
+  }
+  if (deprecatedAliases.length > 0) {
+    lines.push("### Deprecated Commands", "");
+    for (const { name, aliasOf } of deprecatedAliases) {
+      lines.push(`- \`/swarm ${name}\` \u2192 Use \`/swarm ${aliasOf}\``);
+      const aliasEntry = COMMAND_REGISTRY[name];
+      if (aliasEntry?.clashesWithNativeCcCommand) {
+        lines.push(`  \u26A0\uFE0F Name conflicts with CC built-in \`${aliasEntry.clashesWithNativeCcCommand}\` \u2014 always use \`/swarm ${aliasOf}\``);
+      }
+    }
+  }
+  return lines.join(`
+`);
+}
+function createSwarmCommandHandler(directory, agents, options = {}) {
+  return async (input, output) => {
+    const normalized = normalizeSwarmCommandInput(input.command, input.arguments);
+    if (!normalized.isSwarmCommand) {
+      return;
+    }
+    output.parts.splice(0, output.parts.length, {
+      type: "text",
+      text: await buildSwarmCommandPrompt({
+        directory,
+        agents,
+        sessionID: input.sessionID,
+        tokens: normalized.tokens,
+        activeAgentName: options.getActiveAgentName?.(input.sessionID),
+        packageRoot: options.packageRoot,
+        registeredAgents: options.registeredAgents
+      })
+    });
+    return;
+  };
+}
+async function buildSwarmCommandPrompt(args) {
+  const {
+    directory,
+    agents,
+    sessionID,
+    tokens,
+    activeAgentName,
+    packageRoot,
+    registeredAgents
+  } = args;
+  const resolved = _internals.resolveCommand(tokens);
+  if (!resolved) {
+    if (tokens.length === 0) {
+      return buildHelpText();
+    }
+    return formatCommandNotFound(tokens);
+  }
+  const typedResolved = resolved;
+  const canonicalKey = canonicalCommandKey(typedResolved);
+  const policy = classifySwarmCommandToolUse(typedResolved);
+  const isV1ToolCommand = SWARM_COMMAND_TOOL_ALLOWLIST.has(canonicalKey);
+  const canUseTool = agentHasSwarmCommandTool(activeAgentName, agents, registeredAgents);
+  if (canUseTool && policy.allowed && isV1ToolCommand) {
+    return routeToSwarmCommandTool({
+      command: canonicalKey,
+      args: resolved.remainingArgs,
+      original: `/swarm ${tokens.join(" ")}`.trim()
+    });
+  }
+  if (canUseTool && isV1ToolCommand && !policy.allowed) {
+    return [
+      `The user typed \`/swarm ${tokens.join(" ")}\`.`,
+      policy.message,
+      "Do not invent command output. Explain the limitation and recommend the canonical CLI path above."
+    ].join(`
+`);
+  }
+  const chatFallbackPolicy = classifySwarmCommandChatFallbackUse(typedResolved);
+  if (!chatFallbackPolicy.allowed) {
+    return [
+      `The user typed \`/swarm ${tokens.join(" ")}\`.`,
+      chatFallbackPolicy.message,
+      "Do not execute this command through chat and do not invent command output."
+    ].join(`
+`);
+  }
+  const result = await executeSwarmCommand({
+    directory,
+    agents,
+    sessionID,
+    tokens,
+    packageRoot
+  });
+  return formatCanonicalPromptFallback({
+    original: `/swarm ${tokens.join(" ")}`.trim(),
+    text: result.text
+  });
+}
+function agentHasSwarmCommandTool(activeAgentName, agents, registeredAgents) {
+  const name = activeAgentName ?? ORCHESTRATOR_NAME;
+  const registeredTools = registeredAgents?.[name]?.tools;
+  if (registeredTools) {
+    return registeredTools.swarm_command === true;
+  }
+  const explicitTools = agents[name]?.config?.tools;
+  if (explicitTools) {
+    return explicitTools.swarm_command === true;
+  }
+  const baseName = stripKnownSwarmPrefix(name);
+  return AGENT_TOOL_MAP[baseName]?.includes("swarm_command") === true;
+}
+function formatCanonicalPromptFallback(args) {
+  if (/^\s*\[MODE:/.test(args.text)) {
+    return [
+      `The user typed \`${args.original}\`.`,
+      "The line below is a swarm MODE-activation signal, NOT output to display.",
+      "Enter the mode named in its `[MODE: X ...]` header now: follow your",
+      'prompt\u2019s "### MODE: X" section, load the SKILL.md it references, and',
+      "follow that protocol exactly. Treat any text after the closing bracket as",
+      "additional instructions. Do NOT echo this signal verbatim.",
+      "",
+      args.text
+    ].join(`
+`);
+  }
+  return [
+    `The user typed \`${args.original}\`.`,
+    "Canonical opencode-swarm command output follows.",
+    "Show this output verbatim and add no extra swarm state.",
+    "",
+    args.text
+  ].join(`
+`);
+}
+function routeToSwarmCommandTool(args) {
+  return [
+    `The user typed \`${args.original}\`.`,
+    "Call the `swarm_command` tool exactly once with:",
+    JSON.stringify({ command: args.command, args: args.args }, null, 2),
+    "After the tool returns, show the tool output verbatim and add no extra swarm state."
+  ].join(`
+`);
+}
+export {
+  resolveCommand,
+  normalizeSwarmCommandInput,
+  handleWriteRetroCommand,
+  handleTurboCommand,
+  handleSyncPlanCommand,
+  handleStatusCommand,
+  handleSpecifyCommand,
+  handleSimulateCommand,
+  handleSddValidateCommand,
+  handleSddStatusCommand,
+  handleSddProjectCommand,
+  handleSddCommand,
+  handleRollbackCommand,
+  handleRetrieveCommand,
+  handleResetSessionCommand,
+  handleResetCommand,
+  handleQaGatesCommand,
+  handlePromoteCommand,
+  handlePreflightCommand,
+  handlePlanCommand,
+  handleMemoryStatusCommand,
+  handleMemoryMigrateCommand,
+  handleMemoryImportCommand,
+  handleMemoryExportCommand,
+  handleMemoryCommand,
+  handleLearningCommand,
+  handleKnowledgeUnactionableCommand,
+  handleKnowledgeRetryHardeningCommand,
+  handleKnowledgeRestoreCommand,
+  handleKnowledgeQuarantineCommand,
+  handleKnowledgeMigrateCommand,
+  handleKnowledgeListCommand,
+  handleHistoryCommand,
+  handleHelpCommand,
+  handleHandoffCommand,
+  handleGuardrailLog,
+  handleGuardrailExplain,
+  handleFullAutoCommand,
+  handleExportCommand,
+  handleEvidenceSummaryCommand,
+  handleEvidenceCommand,
+  handleDoctorCommand,
+  handleDiagnoseCommand,
+  handleDeepResearchCommand,
+  handleDeepDiveCommand,
+  handleDarkMatterCommand,
+  handleCurateCommand,
+  handleCouncilCommand,
+  handleConsolidateCommand,
+  handleConfigCommand,
+  handleConcurrencyCommand,
+  handleCodebaseReviewCommand,
+  handleCloseCommand,
+  handleClarifyCommand,
+  handleCheckpointCommand,
+  handleBrainstormCommand,
+  handleBenchmarkCommand,
+  handleAutoProceedCommand,
+  handleArchiveCommand,
+  handleAnalyzeCommand,
+  handleAgentsCommand,
+  handleAcknowledgeSpecDriftCommand,
+  formatCommandNotFound,
+  executeSwarmCommand,
+  createSwarmCommandHandler,
+  classifySwarmCommandToolUse,
+  classifySwarmCommandChatFallbackUse,
+  buildHelpText,
+  agentHasSwarmCommandTool,
+  VALID_COMMANDS,
+  SWARM_COMMAND_TOOL_COMMANDS,
+  SWARM_COMMAND_TOOL_ALLOWLIST,
+  COMMAND_REGISTRY,
+  COMMAND_NAME_SET,
+  COMMAND_NAMES
+};