@triflux/remote 10.0.1 → 10.25.1

package/hub/team/swarm-planner.mjs

@@ -14,17 +14,18 @@
 //   - prompt: |
 //       multi-line prompt text
 
-import { readFileSync } from 'node:fs';
+import { readFileSync } from "node:fs";
+import { selectHostForCapability } from "@triflux/core/hub/lib/ssh-command.mjs";
 
 /** Shard schema defaults */
 const SHARD_DEFAULTS = Object.freeze({
-  agent: 'codex',
+  agent: "codex",
   files: [],
   mcp: [],
   depends: [],
   critical: false,
-  prompt: '',
-  host: '',
+  prompt: "",
+  host: "",
 });
 
 /**
@@ -41,7 +42,7 @@ export function parseShards(content) {
 
   function flushPrompt() {
     if (current && promptLines.length > 0) {
-      current.prompt = promptLines.join('\n').trim();
+      current.prompt = promptLines.join("\n").trim();
       promptLines = [];
     }
     inPrompt = false;
@@ -91,26 +92,38 @@ export function parseShards(content) {
     const value = rawValue.trim();
 
     switch (key.toLowerCase()) {
-      case 'agent':
+      case "agent":
         current.agent = value.toLowerCase();
         break;
-      case 'files':
-        current.files = value.split(/,\s*/).map((f) => f.trim()).filter(Boolean);
+      case "files":
+        current.files = value
+          .split(/,\s*/)
+          .map((f) => f.trim())
+          .filter(Boolean);
         break;
-      case 'mcp':
-        current.mcp = value.split(/,\s*/).map((s) => s.trim()).filter(Boolean);
+      case "mcp":
+        current.mcp = value
+          .split(/,\s*/)
+          .map((s) => s.trim())
+          .filter(Boolean);
         break;
-      case 'depends':
-        current.depends = value.split(/,\s*/).map((d) => d.trim()).filter(Boolean);
+      case "depends":
+        current.depends = value
+          .split(/,\s*/)
+          .map((d) => d.trim())
+          .filter(Boolean)
+          .filter(
+            (d) => !["none", "-", "—", "n/a", "없음"].includes(d.toLowerCase()),
+          );
         break;
-      case 'critical':
+      case "critical":
         current.critical = /^(true|yes|1)$/i.test(value);
         break;
-      case 'host':
+      case "host":
         current.host = value;
         break;
-      case 'prompt':
-        if (value && !value.startsWith('|')) {
+      case "prompt":
+        if (value && !value.startsWith("|")) {
           current.prompt = value;
         } else {
           inPrompt = true;
@@ -178,8 +191,8 @@ export function buildMcpManifest(shards) {
  */
 export function computeMergeOrder(shards) {
   const nameSet = new Set(shards.map((s) => s.name));
-  const adj = new Map();    // name → [dependents]
-  const inDeg = new Map();  // name → number
+  const adj = new Map(); // name → [dependents]
+  const inDeg = new Map(); // name → number
 
   for (const shard of shards) {
     adj.set(shard.name, []);
@@ -234,11 +247,25 @@ export function computeMergeOrder(shards) {
  * @returns {SwarmPlan}
  */
 export function planSwarm(prdPath, opts = {}) {
-  const content = opts.content || readFileSync(prdPath, 'utf8');
+  const content = opts.content || readFileSync(prdPath, "utf8");
   const shards = parseShards(content);
 
   if (shards.length === 0) {
-    throw new Error('No shards found in PRD. Expected "## Shard: <name>" sections.');
+    throw new Error(
+      'No shards found in PRD. Expected "## Shard: <name>" sections.',
+    );
+  }
+
+  const emptyPromptShards = shards.filter(
+    (s) => !s.prompt || s.prompt.trim() === "",
+  );
+  if (emptyPromptShards.length > 0) {
+    const names = emptyPromptShards.map((s) => s.name).join(", ");
+    throw new Error(
+      `Shard(s) with empty prompt: ${names}. ` +
+        `Each shard must include a non-empty "- prompt: |" block. ` +
+        `See docs/prd/_template.md for PRD format.`,
+    );
   }
 
   const { leaseMap, conflicts } = buildFileLeaseMap(shards);
@@ -246,9 +273,13 @@ export function planSwarm(prdPath, opts = {}) {
   const { order: mergeOrder, cycles } = computeMergeOrder(shards);
 
   if (cycles.length > 0) {
-    throw new Error(`Dependency cycle detected: ${cycles[0].join(' → ')}`);
+    throw new Error(`Dependency cycle detected: ${cycles[0].join(" → ")}`);
   }
 
+  // Auto-remote suggestion: PRD에 host 미지정 shard가 있고,
+  // hosts.json에 가용 원격 호스트가 있으면 제안 데이터를 생성한다.
+  const remoteSuggestion = buildRemoteSuggestion(shards, opts.repoRoot);
+
   return Object.freeze({
     shards: Object.freeze(shards.map((s) => Object.freeze({ ...s }))),
     leaseMap,
@@ -256,5 +287,74 @@ export function planSwarm(prdPath, opts = {}) {
     mergeOrder,
     conflicts,
     criticalShards: shards.filter((s) => s.critical).map((s) => s.name),
+    remoteSuggestion,
+  });
+}
+
+/**
+ * PRD shard에 host가 없고 원격 호스트가 가용하면 분배 제안을 생성한다.
+ * 실제 AskUserQuestion 호출은 스킬(tfx-swarm)에서 수행. 여기는 데이터만.
+ * @param {Shard[]} shards
+ * @param {string} [repoRoot]
+ * @returns {object|null} 제안 데이터 또는 null (제안 없음)
+ */
+function buildRemoteSuggestion(shards, repoRoot) {
+  const localShards = shards.filter((s) => !s.host);
+  if (localShards.length === 0) return null; // 모든 shard에 host 지정됨
+
+  // 각 shard의 agent에 대해 가용 원격 호스트 조회
+  const agentTypes = [...new Set(localShards.map((s) => s.agent))];
+  const availableHosts = [];
+
+  for (const agent of agentTypes) {
+    try {
+      const hosts = selectHostForCapability(agent, repoRoot);
+      for (const h of hosts) {
+        if (!availableHosts.find((ah) => ah.name === h.name)) {
+          availableHosts.push(h);
+        }
+      }
+    } catch {
+      // hosts.json 없거나 파싱 실패 → 무시
+    }
+  }
+
+  if (availableHosts.length === 0) return null;
+
+  // 분배 제안: 로컬 shard 중 절반(내림)을 원격에 배치
+  const remoteCount = Math.min(
+    Math.floor(localShards.length / 2),
+    availableHosts.length,
+  );
+  if (remoteCount === 0) return null;
+
+  // 의존성 없는 shard를 우선 원격 후보로 선택
+  const candidates = localShards
+    .filter((s) => s.depends.length === 0)
+    .concat(localShards.filter((s) => s.depends.length > 0));
+
+  const suggested = [];
+  for (let i = 0; i < remoteCount && i < candidates.length; i++) {
+    const shard = candidates[i];
+    const host = availableHosts[i % availableHosts.length];
+    suggested.push({
+      shardName: shard.name,
+      host: host.name,
+      hostDescription: host.config.description,
+      specs: host.specs,
+    });
+  }
+
+  return Object.freeze({
+    localCount: localShards.length - remoteCount,
+    remoteCount,
+    totalShards: shards.length,
+    availableHosts: availableHosts.map((h) => ({
+      name: h.name,
+      description: h.config.description,
+      specs: h.specs,
+      capabilities: h.config.capabilities,
+    })),
+    suggested: Object.freeze(suggested),
   });
 }

package/hub/team/swarm-preflight.mjs

@@ -0,0 +1,317 @@
+// hub/team/swarm-preflight.mjs — PRD swarm preflight report/gate (#188)
+// Predicts launch-time blockers before any worker session or worktree spawn.
+
+import { resolve } from "node:path";
+import { readHosts, resolveHost } from "@triflux/core/hub/lib/hosts-compat.mjs";
+import { whichCommand } from "@triflux/core/hub/platform.mjs";
+import { MCP_CATALOG } from "./mcp-selector.mjs";
+import { DEFAULT_SENSITIVE_DENY } from "./swarm-locks.mjs";
+import { planSwarm } from "./swarm-planner.mjs";
+
+const AGENT_COMMANDS = Object.freeze({
+  codex: "codex",
+  gemini: "gemini",
+  claude: "claude",
+});
+
+function unique(values) {
+  return [...new Set(values.filter(Boolean))];
+}
+
+function normalizePath(filePath) {
+  return String(filePath || "")
+    .replace(/\\/g, "/")
+    .replace(/^\.\//u, "");
+}
+
+function isSensitiveFile(filePath, sensitiveDeny = DEFAULT_SENSITIVE_DENY) {
+  const path = normalizePath(filePath);
+  const files = new Set(sensitiveDeny.files || []);
+  const prefixes = sensitiveDeny.prefixes || [];
+  return files.has(path) || prefixes.some((prefix) => path.startsWith(prefix));
+}
+
+function planToJson(plan) {
+  return {
+    totalShards: plan.shards.length,
+    shards: plan.shards.map((s) => ({
+      name: s.name,
+      agent: s.agent,
+      host: s.host || null,
+      files: [...s.files],
+      mcp: [...s.mcp],
+      depends: [...s.depends],
+      critical: s.critical,
+    })),
+    leaseMap: Object.fromEntries(plan.leaseMap),
+    mcpManifest: Object.fromEntries(plan.mcpManifest),
+    mergeOrder: [...plan.mergeOrder],
+    criticalShards: [...plan.criticalShards],
+    conflicts: [...plan.conflicts],
+    remoteSuggestion: plan.remoteSuggestion,
+  };
+}
+
+function makeCheck(name, ok, details = {}) {
+  return { name, ok: Boolean(ok), ...details };
+}
+
+function buildLeaseTable(plan, repoRoot) {
+  return plan.shards.map((shard) => ({
+    shard: shard.name,
+    host: shard.host || null,
+    worktreePath: resolve(repoRoot, ".codex-swarm", `wt-${shard.name}`),
+    files: [...shard.files],
+  }));
+}
+
+function checkSensitive(plan, sensitiveDeny) {
+  const matches = [];
+  for (const shard of plan.shards) {
+    for (const file of shard.files) {
+      if (!isSensitiveFile(file, sensitiveDeny)) continue;
+      matches.push({
+        shard: shard.name,
+        file,
+        kind: "sensitive-planned-lease",
+        severity: "warning",
+      });
+    }
+  }
+  return makeCheck("sensitiveDeny", true, { matches });
+}
+
+function checkHosts(plan, repoRoot) {
+  const registry = readHosts(repoRoot);
+  const missing = [];
+  const capabilityWarnings = [];
+
+  for (const shard of plan.shards) {
+    if (!shard.host) continue;
+    const resolvedHost = resolveHost(shard.host, repoRoot);
+    if (!resolvedHost) {
+      missing.push({ shard: shard.name, host: shard.host });
+      continue;
+    }
+    const capabilities = resolvedHost.host.capabilities || [];
+    if (shard.agent && !capabilities.includes(shard.agent)) {
+      capabilityWarnings.push({
+        shard: shard.name,
+        host: shard.host,
+        agent: shard.agent,
+        capabilities,
+      });
+    }
+  }
+
+  return makeCheck("hosts", missing.length === 0, {
+    registryPath: registry.path,
+    missing,
+    warnings: capabilityWarnings,
+  });
+}
+
+function checkLocalWorkerClis(plan, deps = {}) {
+  const which = deps.whichCommand || whichCommand;
+  const missing = [];
+  const present = [];
+  const checked = new Map();
+
+  for (const shard of plan.shards) {
+    if (shard.host) continue;
+    const command = AGENT_COMMANDS[shard.agent] || shard.agent;
+    if (!command) {
+      missing.push({ shard: shard.name, agent: shard.agent, command: null });
+      continue;
+    }
+    if (!checked.has(command)) {
+      checked.set(command, which(command, deps.whichOptions || {}));
+    }
+    const path = checked.get(command);
+    if (path)
+      present.push({ shard: shard.name, agent: shard.agent, command, path });
+    else missing.push({ shard: shard.name, agent: shard.agent, command });
+  }
+
+  return makeCheck("workerCli", missing.length === 0, { present, missing });
+}
+
+function checkMcp(plan) {
+  const catalog = new Map(MCP_CATALOG.map((entry) => [entry.name, entry]));
+  const unknown = [];
+  const incompatible = [];
+
+  for (const shard of plan.shards) {
+    for (const server of shard.mcp) {
+      const entry = catalog.get(server);
+      if (!entry) {
+        unknown.push({ shard: shard.name, server });
+        continue;
+      }
+      if (
+        ["codex", "gemini"].includes(shard.agent) &&
+        !entry.cli.includes(shard.agent)
+      ) {
+        incompatible.push({
+          shard: shard.name,
+          agent: shard.agent,
+          server,
+          supportedCli: [...entry.cli],
+        });
+      }
+    }
+  }
+
+  return makeCheck("mcp", incompatible.length === 0, { unknown, incompatible });
+}
+
+function collectMessages(checks) {
+  const errors = [];
+  const warnings = [];
+
+  const leases = checks.leases;
+  for (const conflict of leases.conflicts || []) {
+    errors.push(
+      `lease conflict: ${conflict.file} assigned to ${conflict.shards.join(", ")}`,
+    );
+  }
+
+  const hosts = checks.hosts;
+  for (const missing of hosts.missing || []) {
+    errors.push(
+      `missing host: shard ${missing.shard} references ${missing.host}`,
+    );
+  }
+  for (const warn of hosts.warnings || []) {
+    warnings.push(
+      `host capability warning: ${warn.host} does not advertise ${warn.agent} for shard ${warn.shard}`,
+    );
+  }
+
+  const workerCli = checks.workerCli;
+  for (const missing of workerCli.missing || []) {
+    errors.push(
+      `missing local worker CLI: shard ${missing.shard} requires ${missing.command || missing.agent}`,
+    );
+  }
+
+  const mcp = checks.mcp;
+  for (const item of mcp.incompatible || []) {
+    errors.push(
+      `MCP incompatibility: ${item.server} is not supported by ${item.agent} for shard ${item.shard}`,
+    );
+  }
+  for (const item of mcp.unknown || []) {
+    warnings.push(
+      `unknown MCP server: ${item.server} requested by shard ${item.shard}`,
+    );
+  }
+
+  const sensitive = checks.sensitiveDeny;
+  for (const item of sensitive.matches || []) {
+    warnings.push(
+      `sensitive path planned lease: ${item.file} owned by shard ${item.shard}`,
+    );
+  }
+
+  return { errors: unique(errors), warnings: unique(warnings) };
+}
+
+/**
+ * Build a no-side-effect preflight report for a swarm PRD.
+ *
+ * @param {string} prdPath
+ * @param {object} [opts]
+ * @param {string} [opts.repoRoot]
+ * @param {object} [opts.deps]
+ * @returns {object}
+ */
+export function runSwarmPreflight(prdPath, opts = {}) {
+  const repoRoot = opts.repoRoot || process.cwd();
+  const absPrd = resolve(prdPath);
+  const sensitiveDeny = opts.sensitiveDeny || DEFAULT_SENSITIVE_DENY;
+  let plan;
+
+  try {
+    plan = (opts.deps?.planSwarm || planSwarm)(absPrd, { repoRoot });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    return {
+      ok: false,
+      verdict: "no-go",
+      prdPath: absPrd,
+      repoRoot,
+      checks: {
+        plan: makeCheck("plan", false, { error: message }),
+      },
+      errors: [message],
+      warnings: [],
+      plan: null,
+      leaseTable: [],
+    };
+  }
+
+  const checks = {
+    plan: makeCheck("plan", true),
+    leases: makeCheck("leases", plan.conflicts.length === 0, {
+      conflicts: [...plan.conflicts],
+    }),
+    sensitiveDeny: checkSensitive(plan, sensitiveDeny),
+    hosts: checkHosts(plan, repoRoot),
+    workerCli: checkLocalWorkerClis(plan, opts.deps),
+    mcp: checkMcp(plan),
+  };
+  const { errors, warnings } = collectMessages(checks);
+  const ok = Object.values(checks).every((check) => check.ok);
+
+  return {
+    ok,
+    verdict: ok ? "go" : "no-go",
+    prdPath: absPrd,
+    repoRoot,
+    checks,
+    errors,
+    warnings,
+    plan: planToJson(plan),
+    leaseTable: buildLeaseTable(plan, repoRoot),
+  };
+}
+
+export function formatPreflightReport(report) {
+  const lines = [`SWARM PREFLIGHT: ${report.verdict.toUpperCase()}`];
+
+  if (report.plan) {
+    lines.push(`PRD: ${report.prdPath}`);
+    lines.push(`Shards: ${report.plan.totalShards}`);
+    lines.push("");
+    lines.push("Lease table:");
+    for (const lease of report.leaseTable) {
+      const host = lease.host ? ` @${lease.host}` : "";
+      lines.push(`  - ${lease.shard}${host}`);
+      lines.push(`    worktree: ${lease.worktreePath}`);
+      lines.push(
+        `    files: ${lease.files.length ? lease.files.join(", ") : "(none)"}`,
+      );
+    }
+  }
+
+  lines.push("");
+  lines.push("Checks:");
+  for (const [name, check] of Object.entries(report.checks || {})) {
+    lines.push(`  ${check.ok ? "✓" : "✗"} ${name}`);
+  }
+
+  if (report.errors?.length) {
+    lines.push("");
+    lines.push("Blocking errors:");
+    for (const error of report.errors) lines.push(`  - ${error}`);
+  }
+
+  if (report.warnings?.length) {
+    lines.push("");
+    lines.push("Warnings:");
+    for (const warning of report.warnings) lines.push(`  - ${warning}`);
+  }
+
+  return `${lines.join("\n")}\n`;
+}