@triflux/remote 10.0.0-alpha.2 → 10.0.0

package/hub/team/swarm-locks.mjs

@@ -1,204 +0,0 @@
-// hub/team/swarm-locks.mjs — File-level lease lock manager for swarm execution
-// Prevents multiple workers from writing to the same file simultaneously.
-// Lock state is kept in-memory (single-process hypervisor) with optional
-// JSON persistence to .triflux/swarm-locks.json for crash recovery.
-
-import { readFileSync, writeFileSync, mkdirSync, existsSync } from 'node:fs';
-import { dirname, resolve, relative } from 'node:path';
-
-const LOCK_TTL_MS = 10 * 60_000; // 10 minutes default TTL
-
-/**
- * Swarm lock manager factory.
- * @param {object} [opts]
- * @param {string} [opts.repoRoot] — repository root for relative path normalization
- * @param {string} [opts.persistPath] — JSON file path for crash recovery persistence
- * @param {number} [opts.ttlMs=600000] — lock TTL in ms (auto-expire stale locks)
- * @returns {SwarmLockManager}
- */
-export function createSwarmLocks(opts = {}) {
-  const {
-    repoRoot = process.cwd(),
-    persistPath,
-    ttlMs = LOCK_TTL_MS,
-  } = opts;
-
-  /** @type {Map<string, LockEntry>} normalized relative path → lock */
-  const locks = new Map();
-
-  // ── helpers ──────────────────────────────────────────────────
-
-  function normalizePath(filePath) {
-    const abs = resolve(repoRoot, filePath);
-    return relative(repoRoot, abs).replace(/\\/g, '/');
-  }
-
-  function now() {
-    return Date.now();
-  }
-
-  function isExpired(entry) {
-    return now() - entry.acquiredAt > ttlMs;
-  }
-
-  function pruneExpired() {
-    for (const [path, entry] of locks) {
-      if (isExpired(entry)) locks.delete(path);
-    }
-  }
-
-  // ── persistence ─────────────────────────────────────────────
-
-  function persist() {
-    if (!persistPath) return;
-    try {
-      mkdirSync(dirname(persistPath), { recursive: true });
-      const data = Object.fromEntries(
-        [...locks].map(([k, v]) => [k, { ...v }]),
-      );
-      writeFileSync(persistPath, JSON.stringify(data, null, 2), 'utf8');
-    } catch { /* best-effort */ }
-  }
-
-  function restore() {
-    if (!persistPath || !existsSync(persistPath)) return;
-    try {
-      const data = JSON.parse(readFileSync(persistPath, 'utf8'));
-      const ts = now();
-      for (const [path, entry] of Object.entries(data)) {
-        if (ts - entry.acquiredAt <= ttlMs) {
-          locks.set(path, entry);
-        }
-      }
-    } catch { /* corrupted file — start fresh */ }
-  }
-
-  // restore on creation
-  restore();
-
-  // ── public API ──────────────────────────────────────────────
-
-  /**
-   * Acquire file leases for a worker.
-   * @param {string} workerId — worker/shard identifier
-   * @param {string[]} files — file paths to lock
-   * @returns {{ ok: boolean, acquired: string[], conflicts: Array<{ file: string, holder: string }> }}
-   */
-  function acquire(workerId, files) {
-    pruneExpired();
-
-    const normalized = files.map((f) => normalizePath(f));
-    const conflicts = [];
-    const toAcquire = [];
-
-    for (let i = 0; i < normalized.length; i++) {
-      const path = normalized[i];
-      const existing = locks.get(path);
-
-      if (existing && existing.workerId !== workerId && !isExpired(existing)) {
-        conflicts.push({ file: files[i], holder: existing.workerId });
-      } else {
-        toAcquire.push(path);
-      }
-    }
-
-    if (conflicts.length > 0) {
-      return { ok: false, acquired: [], conflicts };
-    }
-
-    const ts = now();
-    for (const path of toAcquire) {
-      locks.set(path, { workerId, acquiredAt: ts });
-    }
-
-    persist();
-    return { ok: true, acquired: toAcquire, conflicts: [] };
-  }
-
-  /**
-   * Release all locks held by a worker.
-   * @param {string} workerId
-   * @returns {number} number of locks released
-   */
-  function release(workerId) {
-    let count = 0;
-    for (const [path, entry] of locks) {
-      if (entry.workerId === workerId) {
-        locks.delete(path);
-        count += 1;
-      }
-    }
-    if (count > 0) persist();
-    return count;
-  }
-
-  /**
-   * Check if a file write would violate any lease.
-   * @param {string} workerId — the worker attempting the write
-   * @param {string} filePath — the file being written
-   * @returns {{ allowed: boolean, holder?: string }}
-   */
-  function check(workerId, filePath) {
-    pruneExpired();
-    const path = normalizePath(filePath);
-    const entry = locks.get(path);
-
-    if (!entry || isExpired(entry)) return { allowed: true };
-    if (entry.workerId === workerId) return { allowed: true };
-    return { allowed: false, holder: entry.workerId };
-  }
-
-  /**
-   * Validate a set of changed files against the lease map.
-   * Returns all violations found.
-   * @param {string} workerId
-   * @param {string[]} changedFiles
-   * @returns {Array<{ file: string, holder: string }>}
-   */
-  function validateChanges(workerId, changedFiles) {
-    pruneExpired();
-    const violations = [];
-
-    for (const file of changedFiles) {
-      const path = normalizePath(file);
-      const entry = locks.get(path);
-
-      if (entry && entry.workerId !== workerId && !isExpired(entry)) {
-        violations.push({ file, holder: entry.workerId });
-      }
-    }
-
-    return violations;
-  }
-
-  /**
-   * Get snapshot of all active locks.
-   * @returns {Array<{ file: string, workerId: string, acquiredAt: number }>}
-   */
-  function snapshot() {
-    pruneExpired();
-    return [...locks].map(([file, entry]) => ({
-      file,
-      workerId: entry.workerId,
-      acquiredAt: entry.acquiredAt,
-    }));
-  }
-
-  /**
-   * Release all locks.
-   */
-  function releaseAll() {
-    locks.clear();
-    persist();
-  }
-
-  return Object.freeze({
-    acquire,
-    release,
-    check,
-    validateChanges,
-    snapshot,
-    releaseAll,
-    get size() { return locks.size; },
-  });
-}

package/hub/team/swarm-planner.mjs

@@ -1,256 +0,0 @@
-// hub/team/swarm-planner.mjs — PRD → Swarm execution plan generator
-// Parses a PRD markdown document into shards (units of work), each with:
-//   - file-lease-map: files the shard is allowed to modify
-//   - MCP manifest: MCP servers the shard needs
-//   - mergeOrder: topological order for integrating results
-//
-// PRD format expected:
-//   ## Shard: <name>
-//   - agent: codex|gemini|claude
-//   - files: path/a.mjs, path/b.mjs
-//   - mcp: server1, server2
-//   - depends: shard-name-1, shard-name-2
-//   - critical: true|false
-//   - prompt: |
-//       multi-line prompt text
-
-import { readFileSync } from 'node:fs';
-
-/** Shard schema defaults */
-const SHARD_DEFAULTS = Object.freeze({
-  agent: 'codex',
-  files: [],
-  mcp: [],
-  depends: [],
-  critical: false,
-  prompt: '',
-});
-
-/**
- * Parse a PRD markdown into shard definitions.
- * @param {string} content — PRD markdown content
- * @returns {Shard[]}
- */
-export function parseShards(content) {
-  const lines = content.split(/\r?\n/);
-  const shards = [];
-  let current = null;
-  let inPrompt = false;
-  let promptLines = [];
-
-  function flushPrompt() {
-    if (current && promptLines.length > 0) {
-      current.prompt = promptLines.join('\n').trim();
-      promptLines = [];
-    }
-    inPrompt = false;
-  }
-
-  function flushShard() {
-    flushPrompt();
-    if (current) {
-      shards.push({ ...SHARD_DEFAULTS, ...current });
-      current = null;
-    }
-  }
-
-  for (const line of lines) {
-    // New shard header: ## Shard: <name>
-    const shardMatch = line.match(/^##\s+Shard:\s*(.+)$/i);
-    if (shardMatch) {
-      flushShard();
-      current = { name: shardMatch[1].trim() };
-      continue;
-    }
-
-    // Non-shard heading ends current shard (e.g. ## Notes)
-    if (/^##\s+/.test(line) && !line.match(/^##\s+Shard:/i)) {
-      flushShard();
-      continue;
-    }
-
-    if (!current) continue;
-
-    // Prompt block continuation
-    if (inPrompt) {
-      if (/^- \w+:/i.test(line)) {
-        flushPrompt();
-        // fall through to field parsing
-      } else {
-        promptLines.push(line);
-        continue;
-      }
-    }
-
-    // Field parsing: - key: value
-    const fieldMatch = line.match(/^-\s+(\w+):\s*(.*)$/i);
-    if (!fieldMatch) continue;
-
-    const [, key, rawValue] = fieldMatch;
-    const value = rawValue.trim();
-
-    switch (key.toLowerCase()) {
-      case 'agent':
-        current.agent = value.toLowerCase();
-        break;
-      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);
-        break;
-      case 'depends':
-        current.depends = value.split(/,\s*/).map((d) => d.trim()).filter(Boolean);
-        break;
-      case 'critical':
-        current.critical = /^(true|yes|1)$/i.test(value);
-        break;
-      case 'prompt':
-        if (value && !value.startsWith('|')) {
-          current.prompt = value;
-        } else {
-          inPrompt = true;
-          promptLines = [];
-        }
-        break;
-      default:
-        // store unknown fields as-is
-        current[key] = value;
-    }
-  }
-
-  flushShard();
-  return shards;
-}
-
-/**
- * Build file-lease-map from shards.
- * Maps each shard name to its allowed files.
- * Detects conflicting file assignments across shards.
- * @param {Shard[]} shards
- * @returns {{ leaseMap: Map<string, string[]>, conflicts: Array<{ file: string, shards: string[] }> }}
- */
-export function buildFileLeaseMap(shards) {
-  const leaseMap = new Map();
-  const fileOwners = new Map(); // file → [shard names]
-
-  for (const shard of shards) {
-    leaseMap.set(shard.name, [...shard.files]);
-    for (const file of shard.files) {
-      const owners = fileOwners.get(file) || [];
-      owners.push(shard.name);
-      fileOwners.set(file, owners);
-    }
-  }
-
-  const conflicts = [];
-  for (const [file, owners] of fileOwners) {
-    if (owners.length > 1) {
-      conflicts.push({ file, shards: owners });
-    }
-  }
-
-  return { leaseMap, conflicts };
-}
-
-/**
- * Build MCP manifest from shards.
- * Maps each shard name to its required MCP servers.
- * @param {Shard[]} shards
- * @returns {Map<string, string[]>}
- */
-export function buildMcpManifest(shards) {
-  const manifest = new Map();
-  for (const shard of shards) {
-    manifest.set(shard.name, [...shard.mcp]);
-  }
-  return manifest;
-}
-
-/**
- * Compute topological merge order based on shard dependencies.
- * @param {Shard[]} shards
- * @returns {{ order: string[], cycles: string[][] }}
- */
-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
-
-  for (const shard of shards) {
-    adj.set(shard.name, []);
-    inDeg.set(shard.name, 0);
-  }
-
-  for (const shard of shards) {
-    for (const dep of shard.depends) {
-      if (!nameSet.has(dep)) continue; // ignore unknown deps
-      adj.get(dep).push(shard.name);
-      inDeg.set(shard.name, inDeg.get(shard.name) + 1);
-    }
-  }
-
-  // Kahn's algorithm
-  const queue = [];
-  for (const [name, deg] of inDeg) {
-    if (deg === 0) queue.push(name);
-  }
-
-  const order = [];
-  while (queue.length > 0) {
-    // stable sort: alphabetical among same-level nodes
-    queue.sort();
-    const node = queue.shift();
-    order.push(node);
-
-    for (const next of adj.get(node)) {
-      const newDeg = inDeg.get(next) - 1;
-      inDeg.set(next, newDeg);
-      if (newDeg === 0) queue.push(next);
-    }
-  }
-
-  // Detect cycles (nodes not in order)
-  const cycles = [];
-  if (order.length < shards.length) {
-    const remaining = shards
-      .filter((s) => !order.includes(s.name))
-      .map((s) => s.name);
-    cycles.push(remaining);
-  }
-
-  return { order, cycles };
-}
-
-/**
- * Full planning pipeline: parse PRD → build plan.
- * @param {string} prdPath — path to PRD markdown file
- * @param {object} [opts]
- * @param {string} [opts.content] — PRD content (if provided, prdPath is ignored)
- * @returns {SwarmPlan}
- */
-export function planSwarm(prdPath, opts = {}) {
-  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.');
-  }
-
-  const { leaseMap, conflicts } = buildFileLeaseMap(shards);
-  const mcpManifest = buildMcpManifest(shards);
-  const { order: mergeOrder, cycles } = computeMergeOrder(shards);
-
-  if (cycles.length > 0) {
-    throw new Error(`Dependency cycle detected: ${cycles[0].join(' → ')}`);
-  }
-
-  return Object.freeze({
-    shards: Object.freeze(shards.map((s) => Object.freeze({ ...s }))),
-    leaseMap,
-    mcpManifest,
-    mergeOrder,
-    conflicts,
-    criticalShards: shards.filter((s) => s.critical).map((s) => s.name),
-  });
-}

package/hub/team/swarm-reconciler.mjs

@@ -1,137 +0,0 @@
-// hub/team/swarm-reconciler.mjs — Redundant execution + result reconciliation
-// For critical shards: launches primary + verifier sessions, compares results,
-// applies conservative adoption (fewer changes wins) or HITL fallback.
-
-import { execFile } from 'node:child_process';
-
-/**
- * Compare two shard results and decide which to accept.
- * Strategy: conservative adoption — the result with fewer changed files wins.
- * If results are identical (same diff), primary is accepted.
- * If they diverge significantly, mark for HITL review.
- *
- * @param {object} primaryResult — { branchName, worktreePath, status }
- * @param {object} verifierResult — { branchName, worktreePath, status }
- * @param {object} [opts]
- * @param {string} [opts.rootDir=process.cwd()]
- * @param {number} [opts.maxDivergenceFiles=5] — beyond this, trigger HITL
- * @returns {Promise<ReconcileDecision>}
- */
-export async function reconcile(primaryResult, verifierResult, opts = {}) {
-  const { rootDir = process.cwd(), maxDivergenceFiles = 5 } = opts;
-
-  // If either failed, pick the one that succeeded
-  if (primaryResult.status !== 'completed' && verifierResult.status === 'completed') {
-    return decision('verifier', 'primary_failed', verifierResult);
-  }
-  if (verifierResult.status !== 'completed' && primaryResult.status === 'completed') {
-    return decision('primary', 'verifier_failed', primaryResult);
-  }
-  if (primaryResult.status !== 'completed' && verifierResult.status !== 'completed') {
-    return decision('none', 'both_failed', null);
-  }
-
-  // Both completed — compare diffs
-  const primaryDiff = await getDiffStat(primaryResult.branchName, rootDir);
-  const verifierDiff = await getDiffStat(verifierResult.branchName, rootDir);
-
-  // Identical diffs → accept primary (no divergence)
-  if (primaryDiff.hash === verifierDiff.hash) {
-    return decision('primary', 'identical', primaryResult);
-  }
-
-  // Compute divergence
-  const divergence = Math.abs(primaryDiff.filesChanged - verifierDiff.filesChanged);
-
-  // High divergence → HITL
-  if (divergence > maxDivergenceFiles) {
-    return {
-      selected: 'hitl',
-      reason: `divergence_too_high (${divergence} files differ)`,
-      result: null,
-      requiresManualReview: true,
-      primary: { filesChanged: primaryDiff.filesChanged, linesChanged: primaryDiff.linesChanged },
-      verifier: { filesChanged: verifierDiff.filesChanged, linesChanged: verifierDiff.linesChanged },
-    };
-  }
-
-  // Conservative adoption: fewer changes wins
-  if (primaryDiff.linesChanged <= verifierDiff.linesChanged) {
-    return decision('primary', 'conservative_adoption', primaryResult);
-  }
-  return decision('verifier', 'conservative_adoption', verifierResult);
-}
-
-function decision(selected, reason, result) {
-  return {
-    selected,
-    reason,
-    result,
-    requiresManualReview: selected === 'hitl' || selected === 'none',
-    primary: null,
-    verifier: null,
-  };
-}
-
-/**
- * Get diff statistics for a branch relative to its merge-base.
- *
- * @param {string} branch
- * @param {string} cwd
- * @returns {Promise<{ filesChanged: number, linesChanged: number, hash: string }>}
- */
-async function getDiffStat(branch, cwd) {
-  try {
-    const stat = await gitExec(['diff', '--stat', '--numstat', `${branch}~1..${branch}`], cwd);
-    const lines = stat.split('\n').filter(Boolean);
-    let filesChanged = 0;
-    let linesChanged = 0;
-
-    for (const line of lines) {
-      const match = line.match(/^(\d+)\s+(\d+)\s+/);
-      if (match) {
-        filesChanged++;
-        linesChanged += Number(match[1]) + Number(match[2]);
-      }
-    }
-
-    // Get tree hash for identity comparison
-    const hash = await gitExec(['rev-parse', `${branch}^{tree}`], cwd);
-
-    return { filesChanged, linesChanged, hash: hash.trim() };
-  } catch {
-    return { filesChanged: 0, linesChanged: 0, hash: '' };
-  }
-}
-
-function gitExec(args, cwd) {
-  return new Promise((res, rej) => {
-    execFile('git', args, { cwd, windowsHide: true, timeout: 15_000 }, (err, stdout) => {
-      if (err) rej(err);
-      else res(stdout);
-    });
-  });
-}
-
-/**
- * Build session configs for redundant execution (primary + verifier).
- *
- * @param {object} shard — from SwarmPlan
- * @param {string} runId
- * @returns {{ primaryId: string, verifierId: string }}
- */
-export function buildRedundantIds(shard, runId) {
-  return {
-    primaryId: `${runId}-${shard.id}-primary`,
-    verifierId: `${runId}-${shard.id}-verifier`,
-  };
-}
-
-/**
- * Check if a shard should use redundant execution.
- * @param {object} shard
- * @returns {boolean}
- */
-export function shouldRunRedundant(shard) {
-  return shard.critical === true;
-}