triflux 10.9.11 → 10.9.13

package/hub/team/swarm-locks.mjs

@@ -33,6 +33,34 @@ export function createSwarmLocks(opts = {}) {
     return Date.now();
   }
 
+  function normalizeLeaseType(leaseType) {
+    return leaseType === "shared-read" ? "shared-read" : "exclusive";
+  }
+
+  function normalizeSessionMeta(sessionMeta) {
+    return sessionMeta ?? null;
+  }
+
+  function normalizeEntry(entry) {
+    return {
+      workerId: entry.workerId,
+      acquiredAt: entry.acquiredAt,
+      leaseType: normalizeLeaseType(entry.leaseType),
+      sessionMeta: normalizeSessionMeta(entry.sessionMeta),
+    };
+  }
+
+  function hasConflict(existing, requesterId, requestedLeaseType) {
+    if (!existing || existing.workerId === requesterId) return false;
+    if (
+      existing.leaseType === "shared-read" &&
+      requestedLeaseType === "shared-read"
+    ) {
+      return false;
+    }
+    return true;
+  }
+
   function isExpired(entry) {
     return now() - entry.acquiredAt > ttlMs;
   }
@@ -65,7 +93,7 @@ export function createSwarmLocks(opts = {}) {
       const ts = now();
       for (const [path, entry] of Object.entries(data)) {
         if (ts - entry.acquiredAt <= ttlMs) {
-          locks.set(path, entry);
+          locks.set(path, normalizeEntry(entry));
         }
       }
     } catch {
@@ -82,23 +110,42 @@ export function createSwarmLocks(opts = {}) {
    * Acquire file leases for a worker.
    * @param {string} workerId — worker/shard identifier
    * @param {string[]} files — file paths to lock
+   * @param {{ leaseType?: "exclusive" | "shared-read", sessionMeta?: { sessionId: string, host: string, taskSummary: string } }} [opts]
    * @returns {{ ok: boolean, acquired: string[], conflicts: Array<{ file: string, holder: string }> }}
    */
-  function acquire(workerId, files) {
+  function acquire(workerId, files, opts = {}) {
     pruneExpired();
 
+    const leaseType = normalizeLeaseType(opts.leaseType);
+    const sessionMeta = normalizeSessionMeta(opts.sessionMeta);
     const normalized = files.map((f) => normalizePath(f));
     const conflicts = [];
     const toAcquire = [];
+    const allowedSharedRead = [];
 
     for (let i = 0; i < normalized.length; i++) {
       const path = normalized[i];
       const existing = locks.get(path);
 
-      if (existing && existing.workerId !== workerId && !isExpired(existing)) {
+      if (!existing || isExpired(existing)) {
+        toAcquire.push(path);
+        continue;
+      }
+
+      if (hasConflict(existing, workerId, leaseType)) {
         conflicts.push({ file: files[i], holder: existing.workerId });
       } else {
-        toAcquire.push(path);
+        if (
+          !(
+            existing.workerId !== workerId &&
+            existing.leaseType === "shared-read" &&
+            leaseType === "shared-read"
+          )
+        ) {
+          toAcquire.push(path);
+        } else {
+          allowedSharedRead.push(path);
+        }
       }
     }
 
@@ -108,11 +155,15 @@ export function createSwarmLocks(opts = {}) {
 
     const ts = now();
     for (const path of toAcquire) {
-      locks.set(path, { workerId, acquiredAt: ts });
+      locks.set(path, { workerId, acquiredAt: ts, leaseType, sessionMeta });
     }
 
     persist();
-    return { ok: true, acquired: toAcquire, conflicts: [] };
+    return {
+      ok: true,
+      acquired: [...toAcquire, ...allowedSharedRead],
+      conflicts: [],
+    };
   }
 
   /**
@@ -136,15 +187,18 @@ export function createSwarmLocks(opts = {}) {
    * Check if a file write would violate any lease.
    * @param {string} workerId — the worker attempting the write
    * @param {string} filePath — the file being written
+   * @param {"exclusive" | "shared-read"} [leaseType="exclusive"] — requested lease type
    * @returns {{ allowed: boolean, holder?: string }}
    */
-  function check(workerId, filePath) {
+  function check(workerId, filePath, leaseType = "exclusive") {
     pruneExpired();
     const path = normalizePath(filePath);
     const entry = locks.get(path);
+    const normalizedLeaseType = normalizeLeaseType(leaseType);
 
     if (!entry || isExpired(entry)) return { allowed: true };
-    if (entry.workerId === workerId) return { allowed: true };
+    if (!hasConflict(entry, workerId, normalizedLeaseType))
+      return { allowed: true };
     return { allowed: false, holder: entry.workerId };
   }
 
@@ -173,7 +227,7 @@ export function createSwarmLocks(opts = {}) {
 
   /**
    * Get snapshot of all active locks.
-   * @returns {Array<{ file: string, workerId: string, acquiredAt: number }>}
+   * @returns {Array<{ file: string, workerId: string, acquiredAt: number, leaseType: "exclusive" | "shared-read", sessionMeta: { sessionId: string, host: string, taskSummary: string } | null }>}
    */
   function snapshot() {
     pruneExpired();
@@ -181,6 +235,8 @@ export function createSwarmLocks(opts = {}) {
       file,
       workerId: entry.workerId,
       acquiredAt: entry.acquiredAt,
+      leaseType: normalizeLeaseType(entry.leaseType),
+      sessionMeta: normalizeSessionMeta(entry.sessionMeta),
     }));
   }
 

package/hub/team/swarm-reconciler.mjs

@@ -1,9 +1,13 @@
 // 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.
+// v2 (Synapse): parses X-Intent trailers to route complementary/contradictory
+// commits through intent-aware paths before falling back to conservative logic.
 
 import { execFile } from "node:child_process";
 
+import { classifyIntentPair, parseIntentTrailer } from "./swarm-intent.mjs";
+
 /**
  * Compare two shard results and decide which to accept.
  * Strategy: conservative adoption — the result with fewer changed files wins.
@@ -49,6 +53,66 @@ export async function reconcile(primaryResult, verifierResult, opts = {}) {
     return decision("primary", "identical", primaryResult);
   }
 
+  // Intent-aware classification: parse X-Intent trailers from both commits.
+  // When both commits carry an intent, route contradictory pairs to HITL and
+  // complementary (non-overlapping) pairs to a merge-friendly path. Missing or
+  // malformed trailers fall through to the existing divergence/conservative
+  // adoption logic below.
+  const [primaryMsg, verifierMsg] = await Promise.all([
+    getCommitMessage(primaryResult.branchName, rootDir),
+    getCommitMessage(verifierResult.branchName, rootDir),
+  ]);
+
+  const primaryIntent = parseIntentTrailer(primaryMsg);
+  const verifierIntent = parseIntentTrailer(verifierMsg);
+
+  if (primaryIntent && verifierIntent) {
+    const classification = classifyIntentPair(primaryIntent, verifierIntent);
+
+    if (classification.relation === "contradictory") {
+      return {
+        selected: "hitl",
+        reason: `intent_contradictory: ${classification.reason}`,
+        result: null,
+        requiresManualReview: true,
+        intentClassification: classification,
+        primaryIntent,
+        verifierIntent,
+        primary: {
+          filesChanged: primaryDiff.filesChanged,
+          linesChanged: primaryDiff.linesChanged,
+        },
+        verifier: {
+          filesChanged: verifierDiff.filesChanged,
+          linesChanged: verifierDiff.linesChanged,
+        },
+      };
+    }
+
+    if (classification.relation === "complementary") {
+      return {
+        selected: "complementary",
+        reason: `intent_complementary: ${classification.reason}`,
+        result: { primary: primaryResult, verifier: verifierResult },
+        requiresManualReview: false,
+        intentClassification: classification,
+        primaryIntent,
+        verifierIntent,
+        shouldAttemptMerge: true,
+        primary: {
+          filesChanged: primaryDiff.filesChanged,
+          linesChanged: primaryDiff.linesChanged,
+        },
+        verifier: {
+          filesChanged: verifierDiff.filesChanged,
+          linesChanged: verifierDiff.linesChanged,
+        },
+      };
+    }
+
+    // complementary-risky / independent → fall through to existing logic.
+  }
+
   // Compute divergence
   const divergence = Math.abs(
     primaryDiff.filesChanged - verifierDiff.filesChanged,
@@ -90,6 +154,22 @@ function decision(selected, reason, result) {
   };
 }
 
+/**
+ * Read the HEAD commit message of a branch.
+ *
+ * @param {string} branch
+ * @param {string} cwd
+ * @returns {Promise<string>}
+ */
+async function getCommitMessage(branch, cwd) {
+  try {
+    const msg = await gitExec(["log", "-1", "--format=%B", branch], cwd);
+    return msg;
+  } catch {
+    return "";
+  }
+}
+
 /**
  * Get diff statistics for a branch relative to its merge-base.
  *

package/hub/team/synapse-cli.mjs

@@ -0,0 +1,207 @@
+// hub/team/synapse-cli.mjs — CLI surface for Synapse v1.
+// Reads persisted registry state + git log for the "status" and "why" commands.
+// Hub integration comes later; for v1 we go straight to the JSON persist files
+// so the CLI works even when Hub is offline.
+
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { homedir } from "node:os";
+import { join, resolve } from "node:path";
+
+import { parseIntentTrailer } from "./swarm-intent.mjs";
+
+const DEFAULT_REGISTRY_CANDIDATES = [
+  ".triflux/synapse-registry.json",
+  ".triflux/synapse/registry.json",
+  join(homedir(), ".claude", "cache", "tfx-hub", "synapse-registry.json"),
+];
+
+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);
+      },
+    );
+  });
+}
+
+function locateRegistryPath(explicit) {
+  if (explicit && existsSync(explicit)) return explicit;
+  for (const candidate of DEFAULT_REGISTRY_CANDIDATES) {
+    if (existsSync(candidate)) return candidate;
+  }
+  return null;
+}
+
+function loadRegistrySnapshot(path) {
+  if (!path) return [];
+  try {
+    const raw = readFileSync(path, "utf8");
+    const parsed = JSON.parse(raw);
+    if (Array.isArray(parsed)) return parsed;
+    if (parsed && typeof parsed === "object") {
+      // Accept both array-form and object-form persist layouts.
+      if (Array.isArray(parsed.sessions)) return parsed.sessions;
+      return Object.values(parsed);
+    }
+    return [];
+  } catch {
+    return [];
+  }
+}
+
+function formatStatus(sessions) {
+  if (!sessions.length) {
+    return "no active sessions (synapse-registry empty)";
+  }
+  const rows = [];
+  rows.push("SESSION                HOST    BRANCH    DIRTY   STATE    TASK");
+  rows.push("─────────────────────  ──────  ────────  ──────  ───────  ─────────────");
+  for (const s of sessions) {
+    const id = (s.sessionId || "?").padEnd(21).slice(0, 21);
+    const host = (s.host || "?").padEnd(6).slice(0, 6);
+    const branch = (s.branch || "?").padEnd(8).slice(0, 8);
+    const dirty = String((s.dirtyFiles || []).length).padEnd(6).slice(0, 6);
+    const state = (s.status || "active").padEnd(7).slice(0, 7);
+    const task = (s.taskSummary || "").slice(0, 40);
+    rows.push(`${id}  ${host}  ${branch}  ${dirty}  ${state}  ${task}`);
+  }
+  return rows.join("\n");
+}
+
+/**
+ * `tfx synapse status` — list active swarm sessions from persisted registry.
+ */
+export async function cmdSynapseStatus(args = [], opts = {}) {
+  const jsonOut = args.includes("--json") || opts.json;
+  const explicit = extractFlag(args, "--registry");
+  const path = locateRegistryPath(explicit);
+  const sessions = loadRegistrySnapshot(path);
+
+  if (jsonOut) {
+    process.stdout.write(
+      JSON.stringify({ registry: path, count: sessions.length, sessions }, null, 2) + "\n",
+    );
+    return;
+  }
+
+  if (!path) {
+    process.stdout.write(
+      "no registry file found (looked for .triflux/synapse-registry.json)\n",
+    );
+    return;
+  }
+  process.stdout.write(`registry: ${path}\n`);
+  process.stdout.write(`${formatStatus(sessions)}\n`);
+}
+
+function extractFlag(args, name) {
+  const idx = args.indexOf(name);
+  if (idx < 0) return null;
+  return args[idx + 1] || null;
+}
+
+async function resolveCommitForPath(path, cwd) {
+  try {
+    const out = await gitExec(["log", "-1", "--format=%H", "--", path], cwd);
+    return out.trim();
+  } catch {
+    return "";
+  }
+}
+
+async function readCommitMessage(sha, cwd) {
+  try {
+    return await gitExec(["log", "-1", "--format=%B", sha], cwd);
+  } catch {
+    return "";
+  }
+}
+
+async function readCommitMeta(sha, cwd) {
+  try {
+    const out = await gitExec(
+      ["log", "-1", "--format=%h%x1f%an%x1f%ad%x1f%s", "--date=iso", sha],
+      cwd,
+    );
+    const [short, author, date, subject] = out.trim().split("\x1f");
+    return { short, author, date, subject };
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * `tfx why <path>` — show the X-Intent of the last commit touching <path>.
+ */
+export async function cmdSynapseWhy(args = [], opts = {}) {
+  const jsonOut = args.includes("--json") || opts.json;
+  const cwd = process.cwd();
+  const positional = args.filter((a) => !a.startsWith("--"));
+  const target = positional[0];
+
+  if (!target) {
+    const err = { error: "path required", usage: "tfx why <path>" };
+    if (jsonOut) process.stdout.write(JSON.stringify(err) + "\n");
+    else process.stderr.write("tfx why <path> — path 인자 필요\n");
+    process.exitCode = 1;
+    return;
+  }
+
+  const resolved = resolve(cwd, target);
+  if (!existsSync(resolved)) {
+    const err = { error: "path not found", path: target };
+    if (jsonOut) process.stdout.write(JSON.stringify(err) + "\n");
+    else process.stderr.write(`tfx why: 파일 없음: ${target}\n`);
+    process.exitCode = 1;
+    return;
+  }
+
+  const sha = await resolveCommitForPath(target, cwd);
+  if (!sha) {
+    const result = { path: target, commit: null, intent: null };
+    if (jsonOut) process.stdout.write(JSON.stringify(result) + "\n");
+    else process.stdout.write(`no commit touches ${target}\n`);
+    return;
+  }
+
+  const [message, meta] = await Promise.all([
+    readCommitMessage(sha, cwd),
+    readCommitMeta(sha, cwd),
+  ]);
+  const intent = parseIntentTrailer(message);
+
+  if (jsonOut) {
+    process.stdout.write(
+      JSON.stringify({ path: target, commit: { sha, ...meta }, intent }, null, 2) + "\n",
+    );
+    return;
+  }
+
+  const header = meta
+    ? `${meta.short}  ${meta.author}  ${meta.date}  ${meta.subject}`
+    : sha;
+  process.stdout.write(`${target}\n`);
+  process.stdout.write(`  last commit: ${header}\n`);
+  if (intent) {
+    process.stdout.write(`  intent.scope:      ${intent.scope || "-"}\n`);
+    process.stdout.write(`  intent.action:     ${intent.action || "-"}\n`);
+    process.stdout.write(`  intent.reason:     ${intent.reason || "-"}\n`);
+    if (Array.isArray(intent.touches) && intent.touches.length) {
+      process.stdout.write(`  intent.touches:    ${intent.touches.join(", ")}\n`);
+    }
+    if (intent.invariant) {
+      process.stdout.write(`  intent.invariant:  ${intent.invariant}\n`);
+    }
+    if (intent.conflictsWith) {
+      process.stdout.write(`  intent.conflicts:  ${intent.conflictsWith}\n`);
+    }
+  } else {
+    process.stdout.write("  intent: (no X-Intent trailer)\n");
+  }
+}