opencode-swarm 7.83.0 → 7.84.0

package/dist/cli/index-j710h2ge.js

@@ -0,0 +1,412 @@
+// @bun
+import {
+  handleGuardrailExplain
+} from "./index-xw0bcy0v.js";
+import {
+  handleGuardrailLog
+} from "./index-jfgr5gye.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-8ra2qpk8.js";
+import"./index-pv2xmc9k.js";
+import"./index-yhsmmv2z.js";
+import"./index-d9fbxaqd.js";
+import"./index-e8pk68cc.js";
+import"./index-a82d6d87.js";
+import {
+  AGENT_TOOL_MAP,
+  ORCHESTRATOR_NAME,
+  stripKnownSwarmPrefix
+} from "./index-wg3r6acj.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
+};

package/dist/cli/index-jfgr5gye.js

@@ -0,0 +1,110 @@
+// @bun
+import {
+  redactPath,
+  redactShellCommand
+} from "./index-pv2xmc9k.js";
+
+// src/services/guardrail-log-service.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var BLOCK_TYPES = new Set([
+  "file_write",
+  "scope_violation",
+  "destructive_block"
+]);
+function isBlockEntry(entry) {
+  if (entry.type === null || entry.type === undefined)
+    return false;
+  return BLOCK_TYPES.has(entry.type);
+}
+function redactSummary(entry) {
+  if (entry.type === "file_write" || entry.type === "scope_violation") {
+    const raw = entry.path ?? "";
+    return redactPath(raw);
+  }
+  if (entry.type === "destructive_block" || entry.type === "sandbox_wrap" || entry.type === "sandbox_skip" || entry.type === "shell" || entry.type === null || entry.type === undefined) {
+    const raw = entry.command ?? "";
+    return redactShellCommand(raw);
+  }
+  return "";
+}
+function formatEntry(entry) {
+  const decisionType = entry.type ?? "shell";
+  const summary = redactSummary(entry);
+  return `- [${entry.ts}] ${decisionType} | agent: ${entry.agent} | ${summary}`;
+}
+async function handleGuardrailLog(directory, args) {
+  const auditPath = path.join(directory, ".swarm", "session", "shell-audit.jsonl");
+  let raw;
+  try {
+    raw = await fs.readFile(auditPath, "utf-8");
+  } catch (error) {
+    if (typeof error === "object" && error !== null && "code" in error && error.code === "ENOENT") {
+      return "No guardrail decisions recorded yet.";
+    }
+    throw error;
+  }
+  const lines = raw.split(/\r?\n/);
+  const entries = [];
+  for (const line of lines) {
+    if (line.trim().length === 0)
+      continue;
+    let parsed;
+    try {
+      parsed = JSON.parse(line);
+    } catch {
+      continue;
+    }
+    if (!isPlainObject(parsed))
+      continue;
+    if (typeof parsed.ts !== "string")
+      continue;
+    if (typeof parsed.sessionID !== "string")
+      continue;
+    if (typeof parsed.agent !== "string")
+      continue;
+    if (typeof parsed.tool !== "string")
+      continue;
+    const entry = {
+      ts: parsed.ts,
+      sessionID: parsed.sessionID,
+      agent: parsed.agent,
+      tool: parsed.tool
+    };
+    if (typeof parsed.type === "string") {
+      entry.type = parsed.type;
+    }
+    if (typeof parsed.command === "string") {
+      entry.command = parsed.command;
+    }
+    if (typeof parsed.path === "string") {
+      entry.path = parsed.path;
+    }
+    entries.push(entry);
+  }
+  if (entries.length === 0) {
+    return "No guardrail decisions recorded yet.";
+  }
+  const blocksOnly = args.includes("--blocks-only");
+  const filtered = blocksOnly ? entries.filter(isBlockEntry) : entries;
+  if (filtered.length === 0) {
+    if (blocksOnly) {
+      return "No guardrail block decisions recorded yet.";
+    }
+    return "No guardrail decisions recorded yet.";
+  }
+  filtered.sort((a, b) => {
+    const diff = b.ts.localeCompare(a.ts);
+    return diff === 0 ? 0 : diff;
+  });
+  const header = blocksOnly ? "# Guardrail Block Log (most-recent-first)" : "# Guardrail Decision Log (most-recent-first)";
+  const body = filtered.map(formatEntry).join(`
+`);
+  return `${header}
+
+${body}`;
+}
+function isPlainObject(value) {
+  return typeof value === "object" && value !== null && (value.constructor === Object || Object.getPrototypeOf(value) === null);
+}
+export { handleGuardrailLog };

package/dist/cli/index-jtqkh8jf.js

@@ -0,0 +1,119 @@
+// @bun
+// src/utils/swarm-artifact-cache.ts
+import * as fs from "fs/promises";
+import * as path from "path";
+var MAX_CACHE_ENTRIES = 128;
+var textCache = new Map;
+var parsedCache = new Map;
+var stats = {
+  textReadCount: 0,
+  textCacheHitCount: 0,
+  textCacheMissCount: 0,
+  parsedReadCount: 0,
+  parseCount: 0,
+  parsedCacheHitCount: 0,
+  parsedCacheMissCount: 0,
+  statFailureCount: 0,
+  evictionCount: 0,
+  textEvictionCount: 0,
+  parsedEvictionCount: 0,
+  cloneFallbackCount: 0,
+  textEntryCount: 0,
+  parsedEntryCount: 0
+};
+function sameStamp(a, b) {
+  return a.mtimeMs === b.mtimeMs && a.ctimeMs === b.ctimeMs && a.size === b.size;
+}
+async function getStamp(filePath) {
+  try {
+    const stat2 = await fs.stat(filePath);
+    if (!stat2.isFile())
+      return null;
+    return { mtimeMs: stat2.mtimeMs, ctimeMs: stat2.ctimeMs, size: stat2.size };
+  } catch {
+    stats.statFailureCount++;
+    return null;
+  }
+}
+function canStoreRead(before, after) {
+  return after !== null && sameStamp(before, after);
+}
+function setBounded(cache, key, value, cacheKind) {
+  cache.set(key, value);
+  while (cache.size > MAX_CACHE_ENTRIES) {
+    const oldest = cache.keys().next().value;
+    if (oldest === undefined)
+      break;
+    cache.delete(oldest);
+    stats.evictionCount++;
+    if (cacheKind === "text") {
+      stats.textEvictionCount++;
+    } else {
+      stats.parsedEvictionCount++;
+    }
+  }
+  stats.textEntryCount = textCache.size;
+  stats.parsedEntryCount = parsedCache.size;
+}
+function cloneCachedValue(value) {
+  if (value === null || typeof value !== "object")
+    return value;
+  if (typeof structuredClone === "function") {
+    return structuredClone(value);
+  }
+  stats.cloneFallbackCount++;
+  return JSON.parse(JSON.stringify(value));
+}
+async function readCachedTextFile(filePath, directRead) {
+  const cacheKey = path.resolve(filePath);
+  const stamp = await getStamp(cacheKey);
+  if (!stamp) {
+    stats.textReadCount++;
+    return directRead();
+  }
+  const cached = textCache.get(cacheKey);
+  if (cached && sameStamp(cached, stamp)) {
+    stats.textCacheHitCount++;
+    return cached.value;
+  }
+  stats.textCacheMissCount++;
+  stats.textReadCount++;
+  const value = await directRead();
+  const afterReadStamp = await getStamp(cacheKey);
+  if (value !== null && canStoreRead(stamp, afterReadStamp)) {
+    setBounded(textCache, cacheKey, { ...afterReadStamp, value }, "text");
+  }
+  return value;
+}
+async function readCachedParsedFile(filePath, namespace, readText, parse) {
+  const resolvedPath = path.resolve(filePath);
+  const cacheKey = `${resolvedPath}\x00${namespace}`;
+  const stamp = await getStamp(resolvedPath);
+  if (!stamp) {
+    stats.parsedReadCount++;
+    const content2 = await readText();
+    if (content2 === null)
+      return null;
+    stats.parseCount++;
+    return parse(content2);
+  }
+  const cached = parsedCache.get(cacheKey);
+  if (cached && sameStamp(cached, stamp)) {
+    stats.parsedCacheHitCount++;
+    return cloneCachedValue(cached.value);
+  }
+  stats.parsedCacheMissCount++;
+  stats.parsedReadCount++;
+  const content = await readText();
+  if (content === null)
+    return null;
+  stats.parseCount++;
+  const value = parse(content);
+  const afterReadStamp = await getStamp(resolvedPath);
+  if (canStoreRead(stamp, afterReadStamp)) {
+    setBounded(parsedCache, cacheKey, { ...afterReadStamp, value }, "parsed");
+  }
+  return cloneCachedValue(value);
+}
+
+export { readCachedTextFile, readCachedParsedFile };

package/dist/cli/index-p0arc26j.js

@@ -0,0 +1,28 @@
+// @bun
+// src/utils/merge.ts
+var MAX_MERGE_DEPTH = 10;
+function deepMergeInternal(base, override, depth) {
+  if (depth >= MAX_MERGE_DEPTH) {
+    throw new Error(`deepMerge exceeded maximum depth of ${MAX_MERGE_DEPTH}`);
+  }
+  const result = { ...base };
+  for (const key of Object.keys(override)) {
+    const baseVal = base[key];
+    const overrideVal = override[key];
+    if (typeof baseVal === "object" && baseVal !== null && typeof overrideVal === "object" && overrideVal !== null && !Array.isArray(baseVal) && !Array.isArray(overrideVal)) {
+      result[key] = deepMergeInternal(baseVal, overrideVal, depth + 1);
+    } else {
+      result[key] = overrideVal;
+    }
+  }
+  return result;
+}
+function deepMerge(base, override) {
+  if (!base)
+    return override;
+  if (!override)
+    return base;
+  return deepMergeInternal(base, override, 0);
+}
+
+export { deepMerge };