@triflux/core 10.50.2 → 10.52.0

package/hub/lib/tfx-route-args.mjs

@@ -1,353 +0,0 @@
-// hub/lib/tfx-route-args.mjs
-// Phase 3 Step B — tfx-auto / tfx-route 플래그 파서.
-// 설계 문서: .triflux/plans/phase3-lead-codex-ralph-escalate.md
-//
-// 입력: ARGUMENTS 문자열 또는 토큰 배열.
-// 출력: {cli, mode, parallel, retry, isolation, remote, lead, noClaudeNative,
-//        maxIterations, task, warnings}.
-//
-// 기존 플래그 (Phase 2 v10.9.33+):
-//   --cli {auto|codex|antigravity|claude}
-//   --mode {quick|deep|consensus|live}
-//   --parallel {1|N|swarm}
-//   --retry {0|1|ralph|auto-escalate}    (Phase 3 에서 ralph/auto-escalate 신규)
-//   --isolation {none|worktree}
-//   --remote {none|<host>}
-//   --rounds <N>                          (--mode live 전용, 기본 4)
-//
-// Phase 3 신규:
-//   --lead {claude|codex}             (tfx-auto-codex 의미 흡수)
-//   --no-claude-native                (Claude native sub-agent 경로 disable)
-//   --max-iterations <N>              (ralph / auto-escalate 상한, 0=unlimited)
-
-import { hasCodeChange } from "./staged-file-detect.mjs";
-
-export const DEFAULT_OPTIONS = Object.freeze({
-  cli: "auto",
-  mode: "quick",
-  parallel: "1",
-  retry: "1",
-  isolation: "none",
-  remote: "none",
-  lead: "claude",
-  noClaudeNative: false,
-  maxIterations: 0,
-  rounds: 4,
-});
-
-const VALID_VALUES = Object.freeze({
-  cli: ["auto", "codex", "antigravity", "claude"],
-  mode: ["quick", "deep", "consensus", "live"],
-  retry: ["0", "1", "ralph", "auto-escalate"],
-  isolation: ["none", "worktree"],
-  lead: ["claude", "codex"],
-});
-
-const VALUE_FLAGS = new Set([
-  "--cli",
-  "--mode",
-  "--parallel",
-  "--retry",
-  "--isolation",
-  "--remote",
-  "--lead",
-  "--max-iterations",
-  "--rounds",
-]);
-
-const BOOL_FLAGS = new Set(["--no-claude-native"]);
-
-export function parseArgs(input) {
-  const tokens = Array.isArray(input)
-    ? input.slice()
-    : tokenize(String(input || ""));
-  const opts = { ...DEFAULT_OPTIONS };
-  const warnings = [];
-  const taskTokens = [];
-  const providedFlags = new Set();
-
-  let i = 0;
-  while (i < tokens.length) {
-    const raw = tokens[i];
-
-    if (BOOL_FLAGS.has(raw)) {
-      providedFlags.add(raw);
-      applyBool(opts, raw);
-      i += 1;
-      continue;
-    }
-
-    // --flag=value 지원
-    const eqIdx = raw.indexOf("=");
-    let flag = raw;
-    let value = null;
-    if (eqIdx > 0 && raw.startsWith("--")) {
-      flag = raw.slice(0, eqIdx);
-      value = raw.slice(eqIdx + 1);
-    }
-
-    if (VALUE_FLAGS.has(flag)) {
-      providedFlags.add(flag);
-      if (value === null) {
-        const next = tokens[i + 1];
-        if (next === undefined || next.startsWith("--")) {
-          warnings.push(`${flag} needs a value`);
-          i += 1;
-          continue;
-        }
-        value = next;
-        i += 2;
-      } else {
-        i += 1;
-      }
-      applyValue(opts, flag, value, warnings);
-      continue;
-    }
-
-    if (raw.startsWith("--")) {
-      warnings.push(`unknown flag: ${raw}`);
-      i += 1;
-      continue;
-    }
-
-    taskTokens.push(raw);
-    i += 1;
-  }
-
-  validate(opts, warnings, providedFlags);
-
-  return {
-    ...opts,
-    task: taskTokens.join(" ").trim(),
-    warnings,
-  };
-}
-
-function tokenize(str) {
-  const tokens = [];
-  let cur = "";
-  let quote = null;
-  for (const ch of str) {
-    if (quote) {
-      if (ch === quote) {
-        quote = null;
-      } else {
-        cur += ch;
-      }
-      continue;
-    }
-    if (ch === '"' || ch === "'") {
-      quote = ch;
-      continue;
-    }
-    if (/\s/.test(ch)) {
-      if (cur) {
-        tokens.push(cur);
-        cur = "";
-      }
-      continue;
-    }
-    cur += ch;
-  }
-  if (cur) tokens.push(cur);
-  return tokens;
-}
-
-function applyBool(opts, flag) {
-  switch (flag) {
-    case "--no-claude-native":
-      opts.noClaudeNative = true;
-      break;
-  }
-}
-
-function applyValue(opts, flag, value, warnings) {
-  switch (flag) {
-    case "--cli":
-      if (value === "gemini") {
-        opts.cli = "antigravity";
-        warnings.push(
-          "--cli gemini is deprecated; using --cli antigravity instead",
-        );
-      } else {
-        opts.cli = value;
-      }
-      break;
-    case "--mode":
-      opts.mode = value;
-      break;
-    case "--parallel":
-      opts.parallel = value;
-      break;
-    case "--retry":
-      opts.retry = value;
-      break;
-    case "--isolation":
-      opts.isolation = value;
-      break;
-    case "--remote":
-      opts.remote = value;
-      break;
-    case "--lead":
-      opts.lead = value;
-      break;
-    case "--max-iterations": {
-      const n = Number.parseInt(value, 10);
-      if (Number.isNaN(n) || n < 0) {
-        warnings.push(
-          `invalid --max-iterations=${value}, expected non-negative integer (0=unlimited)`,
-        );
-      } else {
-        opts.maxIterations = n;
-      }
-      break;
-    }
-    case "--rounds": {
-      const n = Number(value);
-      if (!Number.isInteger(n) || n <= 0) {
-        warnings.push(`invalid --rounds=${value}, expected positive integer`);
-      } else {
-        opts.rounds = n;
-      }
-      break;
-    }
-  }
-}
-
-function validate(opts, warnings, providedFlags = new Set()) {
-  for (const key of Object.keys(VALID_VALUES)) {
-    if (!VALID_VALUES[key].includes(opts[key])) {
-      warnings.push(
-        `invalid --${key}=${opts[key]}, expected one of ${VALID_VALUES[key].join("|")}`,
-      );
-    }
-  }
-  if (
-    opts.parallel !== "1" &&
-    opts.parallel !== "swarm" &&
-    !/^\d+$/.test(opts.parallel)
-  ) {
-    warnings.push(`invalid --parallel=${opts.parallel}, expected 1|N|swarm`);
-  }
-
-  if (opts.mode === "live") {
-    const ignored = [
-      ["--parallel", "parallel", DEFAULT_OPTIONS.parallel],
-      ["--isolation", "isolation", DEFAULT_OPTIONS.isolation],
-      ["--remote", "remote", DEFAULT_OPTIONS.remote],
-    ];
-    for (const [flag, key, fallback] of ignored) {
-      if (providedFlags.has(flag)) {
-        warnings.push(`${flag} ignored with --mode live`);
-        opts[key] = fallback;
-      }
-    }
-    if (providedFlags.has("--retry") && opts.retry === "ralph") {
-      warnings.push("--retry ralph ignored with --mode live");
-      opts.retry = DEFAULT_OPTIONS.retry;
-    }
-  } else if (providedFlags.has("--rounds")) {
-    warnings.push("--rounds ignored unless --mode live");
-    opts.rounds = DEFAULT_OPTIONS.rounds;
-  }
-
-  const parallelOne = opts.parallel === "1" || opts.parallel === 1;
-  if (parallelOne && opts.isolation === "worktree") {
-    warnings.push(
-      "--isolation worktree requires --parallel >=2 or swarm; forcing isolation=none",
-    );
-    opts.isolation = "none";
-  }
-  if (opts.remote !== "none" && opts.parallel !== "swarm") {
-    warnings.push(
-      `--remote ${opts.remote} ignored (requires --parallel swarm)`,
-    );
-  }
-}
-
-export { VALID_VALUES };
-
-/**
- * Decide dispatch mode based on parsed args and current git state.
- *
- * Issue #281: auto router code changes should use isolated swarm dispatch for
- * multi-task work unless the user explicitly selected local parallel mode.
- *
- * @param {object} args
- * @param {object} [opts]
- * @param {string} [opts.cwd]
- * @param {Function} [opts.detector]
- * @returns {{
- *   mode: "single" | "multi" | "swarm",
- *   escalated: boolean,
- *   warning: string | null,
- *   reason: string,
- * }}
- */
-export function decideDispatchMode(
-  args = {},
-  { cwd = process.cwd(), detector = hasCodeChange } = {},
-) {
-  const tasksCount = countTasks(args);
-  const parallel = normalizeParallel(args.parallel);
-  const hasUserParallel = parallel !== null && parallel !== "1";
-  const hasUserSwarm = parallel === "swarm" || args.isolation === "worktree";
-  const codeChanged = Boolean(detector({ cwd }));
-
-  if (hasUserSwarm) {
-    return {
-      mode: "swarm",
-      escalated: false,
-      warning: null,
-      reason: "user-explicit-swarm",
-    };
-  }
-
-  if (hasUserParallel && codeChanged) {
-    return {
-      mode: "multi",
-      escalated: false,
-      warning: `[tfx-auto] WARNING: 코드 변경 감지 (cwd race 위험). --parallel swarm --isolation worktree 권장. 사용자 명시 --parallel=${args.parallel} 존중하여 multi 로 진행.`,
-      reason: "user-explicit-multi-with-code-change",
-    };
-  }
-
-  if (tasksCount >= 2 && codeChanged) {
-    return {
-      mode: "swarm",
-      escalated: true,
-      warning: `[tfx-auto] 코드 변경 ${tasksCount}건 태스크 + dirty cwd 감지. swarm dispatch 자동 escalate (--parallel swarm --isolation worktree). Issue #281.`,
-      reason: "auto-escalate-code-change",
-    };
-  }
-
-  if (tasksCount >= 2 || hasUserParallel) {
-    return {
-      mode: "multi",
-      escalated: false,
-      warning: null,
-      reason: "multi-no-code-change",
-    };
-  }
-
-  return {
-    mode: "single",
-    escalated: false,
-    warning: null,
-    reason: "single-task",
-  };
-}
-
-function countTasks(args) {
-  if (Array.isArray(args.tasks)) return args.tasks.length;
-  if (typeof args.tasks === "number") return args.tasks;
-  if (typeof args.tasks === "string") return args.tasks.trim() ? 1 : 0;
-  if (typeof args.task === "string") return args.task.trim() ? 1 : 0;
-  return args.tasks ?? 0;
-}
-
-function normalizeParallel(value) {
-  if (value == null) return null;
-  if (value === "swarm") return value;
-  return String(value);
-}

package/hub/lib/trace-recorder.mjs

@@ -1,153 +0,0 @@
-const VALID_CLIENTS = new Set(["codex", "claude", "gemini", "unknown"]);
-const VALID_PHASES = new Set(["ingress", "handler", "store", "event-loop"]);
-const SAMPLE_LIMIT = 1000;
-
-const categories = new Map();
-const workerDurations = [];
-const workerCounts = {
-  spawned: 0,
-  exited: 0,
-};
-
-function debugInvalid(kind, details) {
-  if (process.env.TFX_TRACE_DEBUG !== "1") return;
-  console.debug(`[trace-recorder] ignored invalid ${kind}`, details);
-}
-
-function normalizeClient(client) {
-  const value = String(client || "unknown").toLowerCase();
-  return VALID_CLIENTS.has(value) ? value : "unknown";
-}
-
-function normalizePhase(phase) {
-  const value = String(phase || "handler");
-  return VALID_PHASES.has(value) ? value : "handler";
-}
-
-function validDuration(durMs) {
-  return Number.isFinite(durMs) && durMs >= 0;
-}
-
-function emptyStats() {
-  return {
-    count: 0,
-    total: 0,
-    min: null,
-    max: null,
-    samples: [],
-    phases: {},
-  };
-}
-
-function addDuration(stats, durMs, phase) {
-  stats.count += 1;
-  stats.total += durMs;
-  stats.min = stats.min == null ? durMs : Math.min(stats.min, durMs);
-  stats.max = stats.max == null ? durMs : Math.max(stats.max, durMs);
-  stats.samples.push(durMs);
-  if (stats.samples.length > SAMPLE_LIMIT) {
-    stats.samples.splice(0, stats.samples.length - SAMPLE_LIMIT);
-  }
-
-  const phaseStats = stats.phases[phase] || emptyPhaseStats();
-  phaseStats.count += 1;
-  phaseStats.total += durMs;
-  phaseStats.min =
-    phaseStats.min == null ? durMs : Math.min(phaseStats.min, durMs);
-  phaseStats.max =
-    phaseStats.max == null ? durMs : Math.max(phaseStats.max, durMs);
-  stats.phases[phase] = phaseStats;
-}
-
-function emptyPhaseStats() {
-  return { count: 0, total: 0, min: null, max: null };
-}
-
-function percentile(samples, percentileValue) {
-  if (!samples.length) return null;
-  const sorted = [...samples].sort((a, b) => a - b);
-  const index = Math.ceil((percentileValue / 100) * sorted.length) - 1;
-  return sorted[Math.max(0, Math.min(sorted.length - 1, index))];
-}
-
-function publicStats(stats) {
-  return {
-    count: stats.count,
-    total: stats.total,
-    min: stats.min,
-    max: stats.max,
-    p50: percentile(stats.samples, 50),
-    p95: percentile(stats.samples, 95),
-    p99: percentile(stats.samples, 99),
-    phases: stats.phases,
-  };
-}
-
-export function recordRequest(
-  category,
-  durMs,
-  client = "unknown",
-  phase = "handler",
-) {
-  if (!category || typeof category !== "string") return;
-  if (!validDuration(durMs)) {
-    debugInvalid("request duration", { category, durMs, client, phase });
-    return;
-  }
-
-  const clientKey = normalizeClient(client);
-  const phaseKey = normalizePhase(phase);
-  const bucket = categories.get(category) || new Map();
-  const stats = bucket.get(clientKey) || emptyStats();
-  addDuration(stats, durMs, phaseKey);
-  bucket.set(clientKey, stats);
-  categories.set(category, bucket);
-}
-
-export function recordWorker(workerId, kind, command, durMs) {
-  if (!workerId || typeof workerId !== "string") return;
-  if (kind === "spawned") {
-    workerCounts.spawned += 1;
-    return;
-  }
-  if (kind !== "exited") return;
-
-  workerCounts.exited += 1;
-  if (durMs == null) return;
-  if (!validDuration(durMs)) {
-    debugInvalid("worker duration", { workerId, kind, command, durMs });
-    return;
-  }
-  workerDurations.push(durMs);
-  if (workerDurations.length > SAMPLE_LIMIT) {
-    workerDurations.splice(0, workerDurations.length - SAMPLE_LIMIT);
-  }
-}
-
-export function snapshot() {
-  const categorySnapshot = {};
-  for (const [category, bucket] of categories.entries()) {
-    categorySnapshot[category] = {};
-    for (const [client, stats] of bucket.entries()) {
-      categorySnapshot[category][client] = publicStats(stats);
-    }
-  }
-
-  return {
-    categories: categorySnapshot,
-    workers: {
-      spawned: workerCounts.spawned,
-      exited: workerCounts.exited,
-      p50: percentile(workerDurations, 50),
-      p95: percentile(workerDurations, 95),
-      p99: percentile(workerDurations, 99),
-    },
-  };
-}
-
-export function reset() {
-  categories.clear();
-  workerDurations.length = 0;
-  workerCounts.spawned = 0;
-  workerCounts.exited = 0;
-}

package/hub/lib/uuidv7.mjs

@@ -1,45 +0,0 @@
-// hub/lib/uuidv7.mjs — UUIDv7 generator (RFC 9562, monotonic)
-import { randomBytes } from "node:crypto";
-
-let _rndPool = Buffer.alloc(0),
-  _rndOff = 0;
-
-function pooledRandom(n) {
-  if (_rndOff + n > _rndPool.length) {
-    _rndPool = randomBytes(256);
-    _rndOff = 0;
-  }
-  const out = Buffer.from(_rndPool.subarray(_rndOff, _rndOff + n));
-  _rndOff += n;
-  return out;
-}
-
-let _lastMs = 0n;
-let _seq = 0;
-
-/** UUIDv7 생성 (RFC 9562, 단조 증가 보장) */
-export function uuidv7() {
-  let now = BigInt(Date.now());
-  if (now <= _lastMs) {
-    _seq++;
-    if (_seq > 0xfff) {
-      now = _lastMs + 1n;
-      _seq = 0;
-    }
-  } else {
-    _seq = 0;
-  }
-  _lastMs = now;
-  const buf = pooledRandom(16);
-  buf[0] = Number((now >> 40n) & 0xffn);
-  buf[1] = Number((now >> 32n) & 0xffn);
-  buf[2] = Number((now >> 24n) & 0xffn);
-  buf[3] = Number((now >> 16n) & 0xffn);
-  buf[4] = Number((now >> 8n) & 0xffn);
-  buf[5] = Number(now & 0xffn);
-  buf[6] = ((_seq >> 8) & 0x0f) | 0x70;
-  buf[7] = _seq & 0xff;
-  buf[8] = (buf[8] & 0x3f) | 0x80;
-  const h = buf.toString("hex");
-  return `${h.slice(0, 8)}-${h.slice(8, 12)}-${h.slice(12, 16)}-${h.slice(16, 20)}-${h.slice(20)}`;
-}