@triflux/remote 10.53.0 → 10.55.0

package/cto/events.mjs

@@ -1,208 +0,0 @@
-import {
-  appendFileSync,
-  closeSync,
-  mkdirSync,
-  openSync,
-  unlinkSync,
-} from "node:fs";
-import { basename, join } from "node:path";
-import { pathLabel, shortHash, toIsoTime } from "./lake-root.mjs";
-
-export const CTO_EVENT_SCHEMA_VERSION = "cto-event.v1";
-export const DEFAULT_CTO_EVENT_SOURCE = "tfx_cto_event";
-
-export const CTO_EVENT_TYPES = Object.freeze([
-  "collect",
-  "session_started",
-  "session_heartbeat",
-  "session_stale",
-  "checkpoint_saved",
-  "checkpoint_restored",
-  "task_claimed",
-  "task_completed",
-  "pr_created",
-  "pr_merged_or_closed",
-  "worktree_created",
-  "worktree_removed",
-  "hygiene_applied",
-]);
-
-export const CTO_HYGIENE_STATUSES = Object.freeze([
-  "active",
-  "idle",
-  "stale",
-  "superseded",
-  "orphaned",
-  "completed",
-  "blocked",
-  "unknown_owner",
-  "hidden",
-  "needs_attention",
-]);
-
-const EVENT_TYPE_SET = new Set(CTO_EVENT_TYPES);
-const STATUS_SET = new Set(CTO_HYGIENE_STATUSES);
-
-function sleep(ms) {
-  return new Promise((resolve) => setTimeout(resolve, ms));
-}
-
-function maybeString(value) {
-  if (typeof value !== "string") return null;
-  const trimmed = value.trim();
-  return trimmed || null;
-}
-
-function normalizeNumericRefs(values) {
-  const rawValues = Array.isArray(values)
-    ? values
-    : values == null
-      ? []
-      : [values];
-  const refs = [];
-  for (const value of rawValues) {
-    const parsed =
-      typeof value === "number" && Number.isInteger(value)
-        ? value
-        : typeof value === "string"
-          ? Number(value.trim().replace(/^#/u, ""))
-          : NaN;
-    if (Number.isInteger(parsed) && parsed > 0 && !refs.includes(parsed)) {
-      refs.push(parsed);
-    }
-  }
-  return refs;
-}
-
-function normalizeActor(actor) {
-  if (!actor || typeof actor !== "object" || Array.isArray(actor)) return null;
-  const normalized = {};
-  for (const key of ["cli", "session_id", "agent_id", "host"]) {
-    const value = maybeString(actor[key]);
-    if (value) normalized[key] = value;
-  }
-  return Object.keys(normalized).length > 0 ? normalized : null;
-}
-
-function putString(target, key, value) {
-  const normalized = maybeString(value);
-  if (normalized) target[key] = normalized;
-}
-
-function defaultSummary(eventType, ref) {
-  if (ref.task_id) return `${eventType} ${ref.task_id}`;
-  if (ref.checkpoint_id) return `${eventType} ${ref.checkpoint_id}`;
-  if (ref.session_id) return `${eventType} ${ref.session_id}`;
-  return eventType;
-}
-
-export function normalizeCtoEvent(input = {}) {
-  const eventType = maybeString(input.event ?? input.event_type);
-  if (!eventType || !EVENT_TYPE_SET.has(eventType)) {
-    throw new Error(`unknown CTO event: ${eventType || "<empty>"}`);
-  }
-
-  const status = maybeString(input.status);
-  if (status && !STATUS_SET.has(status)) {
-    throw new Error(`invalid CTO status: ${status}`);
-  }
-
-  const ts = toIsoTime(input.now ?? input.ts) || new Date().toISOString();
-  if (eventType === "collect") {
-    return {
-      ts,
-      event: eventType,
-      source: maybeString(input.source) || "tfx_cto_collect",
-      summary: maybeString(input.summary) || eventType,
-      ref: input.ref ?? null,
-    };
-  }
-  const ref = {
-    schema_version: CTO_EVENT_SCHEMA_VERSION,
-    event_type: eventType,
-  };
-
-  putString(ref, "session_id", input.session_id);
-  putString(ref, "parent_session_id", input.parent_session_id);
-  putString(ref, "restored_from_session_id", input.restored_from_session_id);
-  putString(ref, "checkpoint_id", input.checkpoint_id);
-  putString(ref, "artifact_path", input.artifact_path);
-  putString(ref, "task_id", input.task_id);
-  putString(ref, "branch", input.branch);
-  putString(ref, "last_seen_at", input.last_seen_at);
-  putString(ref, "stale_reason", input.stale_reason);
-  putString(ref, "hygiene_key", input.hygiene_key);
-  putString(ref, "hygiene_kind", input.hygiene_kind);
-  putString(ref, "hygiene_id", input.hygiene_id);
-  putString(ref, "hygiene_action", input.hygiene_action);
-  if (status) ref.status = status;
-
-  const projectRoot = maybeString(input.project_root);
-  if (projectRoot) {
-    ref.project_root_hash = shortHash(projectRoot);
-    ref.project_root_label = pathLabel(projectRoot) || basename(projectRoot);
-  }
-
-  const worktreePath = maybeString(input.worktree_path ?? input.worktreePath);
-  if (worktreePath) {
-    ref.worktree_path_hash = shortHash(worktreePath);
-    ref.worktree_label = pathLabel(worktreePath) || basename(worktreePath);
-  }
-
-  const issueRefs = normalizeNumericRefs(input.issue_refs ?? input.issueRefs);
-  if (issueRefs.length > 0) ref.issue_refs = issueRefs;
-  const prRefs = normalizeNumericRefs(input.pr_refs ?? input.prRefs);
-  if (prRefs.length > 0) ref.pr_refs = prRefs;
-
-  const actor = normalizeActor(input.actor);
-  if (actor) ref.actor = actor;
-
-  return {
-    ts,
-    event: eventType,
-    source: maybeString(input.source) || DEFAULT_CTO_EVENT_SOURCE,
-    summary: maybeString(input.summary) || defaultSummary(eventType, ref),
-    ref,
-  };
-}
-
-export async function appendCtoEvent(lakeRoot, input, opts = {}) {
-  const event = normalizeCtoEvent(input);
-  const stderr = opts.stderr || process.stderr;
-  const lockRetries = Number.isInteger(opts.lockRetries) ? opts.lockRetries : 3;
-  const lockRetryDelayMs = Number.isFinite(opts.lockRetryDelayMs)
-    ? opts.lockRetryDelayMs
-    : 100;
-
-  mkdirSync(lakeRoot, { recursive: true });
-  const ledgerPath = join(lakeRoot, "ledger.jsonl");
-  const lockPath = join(lakeRoot, "ledger.jsonl.lock");
-  let fd = null;
-
-  for (let attempt = 0; attempt < lockRetries; attempt += 1) {
-    try {
-      fd = openSync(lockPath, "wx", 0o600);
-      break;
-    } catch (error) {
-      if (error?.code !== "EEXIST") throw error;
-      if (attempt < lockRetries - 1) await sleep(lockRetryDelayMs);
-    }
-  }
-
-  if (fd === null) {
-    stderr.write(
-      "[tfx cto] warning: ledger lock timeout; skipped ledger append\n",
-    );
-    return { appended: false, event };
-  }
-
-  try {
-    appendFileSync(ledgerPath, `${JSON.stringify(event)}\n`, "utf8");
-    return { appended: true, event };
-  } finally {
-    closeSync(fd);
-    try {
-      unlinkSync(lockPath);
-    } catch {}
-  }
-}

package/cto/hygiene.mjs

@@ -1,320 +0,0 @@
-import { existsSync, readFileSync } from "node:fs";
-import { join } from "node:path";
-import { readJsonLines, resolveLakeRootDir } from "./lake-root.mjs";
-
-const COUNT_KEYS = [
-  "active_tasks",
-  "completed_tasks",
-  "stale_sessions",
-  "orphan_worktrees",
-  "superseded_checkpoints",
-  "unknown_owner",
-];
-
-function hasFlag(args, flag) {
-  return Array.isArray(args) && args.includes(flag);
-}
-
-function writeJson(stdout, payload) {
-  stdout.write(`${JSON.stringify(payload, null, 2)}\n`);
-}
-
-function readJson(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
-}
-
-function eventTime(entry) {
-  return typeof entry?.ts === "string" ? entry.ts : "";
-}
-
-function eventRef(entry) {
-  return entry?.ref &&
-    typeof entry.ref === "object" &&
-    !Array.isArray(entry.ref)
-    ? entry.ref
-    : {};
-}
-
-function hasKnownOwner(ref) {
-  const actor = ref?.actor;
-  if (actor && typeof actor === "object" && !Array.isArray(actor)) {
-    for (const key of ["cli", "session_id", "agent_id", "host"]) {
-      if (typeof actor[key] === "string" && actor[key].trim()) return true;
-    }
-  }
-  for (const key of ["owner", "owner_id", "agent_id"]) {
-    if (typeof ref?.[key] === "string" && ref[key].trim()) return true;
-  }
-  return false;
-}
-
-function statusOf(ref, fallback) {
-  return typeof ref?.status === "string" && ref.status.trim()
-    ? ref.status.trim()
-    : fallback;
-}
-
-function rowFrom(kind, id, status, entry, ref, action) {
-  const row = {
-    kind,
-    id,
-    status,
-    last_event_at: eventTime(entry) || null,
-  };
-  if (entry?.summary) row.summary = String(entry.summary);
-  if (action) row.action = action;
-  if (action && !hasKnownOwner(ref)) row.owner = "unknown";
-  if (typeof ref?.artifact_path === "string" && ref.artifact_path.trim()) {
-    row.artifact_path = ref.artifact_path.trim();
-  }
-  if (
-    typeof ref?.project_root_hash === "string" &&
-    ref.project_root_hash.trim()
-  ) {
-    row.project_root_hash = ref.project_root_hash.trim();
-  }
-  if (typeof ref?.session_id === "string" && ref.session_id.trim()) {
-    row.session_id = ref.session_id.trim();
-  }
-  return row;
-}
-
-function rowKey(kind, id) {
-  return `${kind}:${id}`;
-}
-
-function hygieneKeyForRow(row) {
-  return rowKey(row.kind, row.id);
-}
-
-function upsertLatest(map, key, value) {
-  const existing = map.get(key);
-  if (!existing || eventTime(value.entry) >= eventTime(existing.entry)) {
-    map.set(key, value);
-  }
-}
-
-function emptyCounts() {
-  return Object.fromEntries(COUNT_KEYS.map((key) => [key, 0]));
-}
-
-function countsFromRows(rows) {
-  const counts = emptyCounts();
-  for (const row of rows) {
-    if (row.kind === "task") {
-      if (row.status === "completed") counts.completed_tasks += 1;
-      else counts.active_tasks += 1;
-    } else if (row.kind === "session" && row.status === "stale") {
-      counts.stale_sessions += 1;
-    } else if (row.kind === "worktree" && row.status === "orphaned") {
-      counts.orphan_worktrees += 1;
-    } else if (row.kind === "checkpoint" && row.status === "superseded") {
-      counts.superseded_checkpoints += 1;
-    }
-  }
-  counts.unknown_owner = rows.filter((row) => row.owner === "unknown").length;
-  return counts;
-}
-
-export function compactHygieneCounts(projection) {
-  const counts = projection?.counts || {};
-  return Object.fromEntries(COUNT_KEYS.map((key) => [key, counts[key] || 0]));
-}
-
-export function projectCtoHygiene({ current = {}, ledger = null } = {}) {
-  const events = Array.isArray(ledger)
-    ? ledger
-    : Array.isArray(current?.ledger_tail)
-      ? current.ledger_tail
-      : [];
-  const tasks = new Map();
-  const staleSessions = new Map();
-  const worktrees = new Map();
-  const checkpointsBySession = new Map();
-  const explicitSupersededCheckpoints = new Map();
-  const appliedByKey = new Map();
-
-  for (const entry of events) {
-    const ref = eventRef(entry);
-    switch (entry?.event) {
-      case "hygiene_applied": {
-        const key =
-          typeof ref.hygiene_key === "string" && ref.hygiene_key.trim()
-            ? ref.hygiene_key.trim()
-            : null;
-        if (!key) break;
-        upsertLatest(appliedByKey, key, { entry, ref });
-        break;
-      }
-      case "task_claimed":
-      case "task_completed": {
-        const taskId = typeof ref.task_id === "string" ? ref.task_id : null;
-        if (!taskId) break;
-        upsertLatest(tasks, taskId, { entry, ref });
-        break;
-      }
-      case "session_stale": {
-        const sessionId =
-          typeof ref.session_id === "string" ? ref.session_id : null;
-        if (!sessionId) break;
-        upsertLatest(staleSessions, sessionId, { entry, ref });
-        break;
-      }
-      case "worktree_created":
-      case "worktree_removed": {
-        const key =
-          (typeof ref.worktree_path_hash === "string" &&
-            ref.worktree_path_hash) ||
-          (typeof ref.worktree_label === "string" && ref.worktree_label) ||
-          null;
-        if (!key) break;
-        upsertLatest(worktrees, key, { entry, ref });
-        break;
-      }
-      case "checkpoint_saved":
-      case "checkpoint_restored": {
-        const checkpointId =
-          typeof ref.checkpoint_id === "string" ? ref.checkpoint_id : null;
-        if (!checkpointId) break;
-        if (ref.status === "superseded") {
-          upsertLatest(explicitSupersededCheckpoints, checkpointId, {
-            entry,
-            ref,
-          });
-        }
-        const sessionId =
-          (typeof ref.session_id === "string" && ref.session_id) ||
-          (typeof ref.restored_from_session_id === "string" &&
-            ref.restored_from_session_id) ||
-          null;
-        if (!sessionId) break;
-        if (!checkpointsBySession.has(sessionId))
-          checkpointsBySession.set(sessionId, []);
-        checkpointsBySession.get(sessionId).push({ entry, ref, checkpointId });
-        break;
-      }
-      default:
-        break;
-    }
-  }
-
-  const rows = [];
-
-  for (const [taskId, item] of tasks) {
-    const completed = item.entry?.event === "task_completed";
-    const status = statusOf(item.ref, completed ? "completed" : "active");
-    rows.push(
-      rowFrom(
-        "task",
-        taskId,
-        completed || status === "completed" ? "completed" : status,
-        item.entry,
-        item.ref,
-        completed || status === "completed"
-          ? null
-          : "complete_or_reassign_task",
-      ),
-    );
-  }
-
-  for (const [sessionId, item] of staleSessions) {
-    rows.push(
-      rowFrom(
-        "session",
-        sessionId,
-        "stale",
-        item.entry,
-        item.ref,
-        "archive_or_resume_session",
-      ),
-    );
-  }
-
-  for (const [key, item] of worktrees) {
-    if (item.entry?.event === "worktree_removed") continue;
-    const status = statusOf(item.ref, "active");
-    if (status !== "orphaned") continue;
-    rows.push(
-      rowFrom(
-        "worktree",
-        item.ref.worktree_label || key,
-        "orphaned",
-        item.entry,
-        item.ref,
-        "remove_or_reassign_worktree",
-      ),
-    );
-  }
-
-  const superseded = new Map(explicitSupersededCheckpoints);
-  for (const checkpoints of checkpointsBySession.values()) {
-    const ordered = [...checkpoints].sort((a, b) =>
-      eventTime(a.entry).localeCompare(eventTime(b.entry)),
-    );
-    for (const item of ordered.slice(0, -1)) {
-      if (!superseded.has(item.checkpointId)) {
-        superseded.set(item.checkpointId, item);
-      }
-    }
-  }
-  for (const [checkpointId, item] of superseded) {
-    rows.push(
-      rowFrom(
-        "checkpoint",
-        checkpointId,
-        "superseded",
-        item.entry,
-        item.ref,
-        "prune_superseded_checkpoint",
-      ),
-    );
-  }
-
-  const sortedRows = rows
-    .filter((row) => {
-      const applied = appliedByKey.get(hygieneKeyForRow(row));
-      if (!applied) return true;
-      return eventTime(applied.entry) < String(row.last_event_at || "");
-    })
-    .map((row) => {
-      if (row.owner === undefined) {
-        const { owner: _owner, ...rest } = row;
-        return rest;
-      }
-      return row;
-    });
-  const counts = countsFromRows(sortedRows);
-
-  return {
-    schema_version: "cto-hygiene.v1",
-    dry_run: true,
-    counts,
-    rows: sortedRows,
-  };
-}
-
-export async function runHygiene(args = [], opts = {}) {
-  if (args.some((arg) => !["--dry-run", "--json"].includes(arg))) {
-    throw new Error("tfx cto hygiene supports only --dry-run and --json");
-  }
-  if (opts.dryRun !== true && !hasFlag(args, "--dry-run")) {
-    throw new Error("tfx cto hygiene requires --dry-run");
-  }
-  const rootDir = opts.rootDir || resolveLakeRootDir(process.cwd());
-  const lakeRoot = opts.lakeRoot || join(rootDir, ".triflux", "lake");
-  const stdout = opts.stdout || process.stdout;
-  const currentPath = join(lakeRoot, "current.json");
-  const current = existsSync(currentPath) ? readJson(currentPath) : {};
-  const ledger = readJsonLines(join(lakeRoot, "ledger.jsonl"));
-  const projection = projectCtoHygiene({
-    current,
-    ledger: ledger.length ? ledger : null,
-  });
-  if (opts.json === true || hasFlag(args, "--json"))
-    writeJson(stdout, projection);
-  else
-    stdout.write(
-      `cto hygiene dry-run: ${projection.counts.active_tasks} active tasks, ${projection.counts.stale_sessions} stale sessions, ${projection.counts.orphan_worktrees} orphan worktrees\n`,
-    );
-  return projection;
-}

package/cto/lake-root.mjs

@@ -1,127 +0,0 @@
-import { execFileSync as defaultExecFileSync } from "node:child_process";
-import {
-  existsSync as defaultExistsSync,
-  mkdirSync,
-  readFileSync,
-  renameSync,
-  writeFileSync,
-} from "node:fs";
-import { basename, dirname, join, parse } from "node:path";
-
-const MAX_DEPTH = 64;
-
-function execGit(cwd, args, execFileSync) {
-  return execFileSync("git", ["-C", cwd, ...args], {
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "ignore"],
-    windowsHide: true,
-  }).trim();
-}
-
-function resolveViaGitCommonDir(cwd, execFileSync) {
-  try {
-    const commonDir = execGit(
-      cwd,
-      ["rev-parse", "--path-format=absolute", "--git-common-dir"],
-      execFileSync,
-    );
-    if (commonDir && basename(commonDir) === ".git") {
-      return dirname(commonDir);
-    }
-
-    // Bare repos and submodules can have non-`.git` common dirs. In that case,
-    // `--show-toplevel` is the safest project root signal.
-    const topLevel = execGit(
-      cwd,
-      ["rev-parse", "--path-format=absolute", "--show-toplevel"],
-      execFileSync,
-    );
-    return topLevel || null;
-  } catch {
-    return null;
-  }
-}
-
-/**
- * cwd 에서 가장 가까운 git toplevel(`.git` 디렉토리 또는 파일이 있는 폴더)을
- * 찾아 반환한다. linked worktree 에서는 worktree 루트가 아니라 git common dir 의
- * project root 를 반환해 프로젝트당 CTO lake 하나를 유지한다. 못 찾으면 cwd 를
- * 그대로 돌려준다(기존 동작 보존).
- *
- * @param {string} cwd 시작 디렉토리(보통 process.cwd())
- * @param {object} [opts]
- * @param {(path: string) => boolean} [opts.existsSync] 테스트용 주입 seam
- * @param {typeof defaultExecFileSync} [opts.execFileSync] 테스트용 git seam
- * @returns {string}
- */
-export function resolveLakeRootDir(cwd, opts = {}) {
-  const exists = opts?.existsSync || defaultExistsSync;
-  const execFileSync = opts?.execFileSync || defaultExecFileSync;
-  // 비문자열(객체/숫자 등 truthy 포함) 또는 빈 문자열이면 항상 "" 를 반환해
-  // @returns {string} 계약을 지킨다. truthy 비문자열을 그대로 누설하지 않는다.
-  if (typeof cwd !== "string" || !cwd) return "";
-
-  const gitRoot = resolveViaGitCommonDir(cwd, execFileSync);
-  if (gitRoot) return gitRoot;
-
-  let dir = cwd;
-  const { root } = parse(dir);
-  for (let depth = 0; depth < MAX_DEPTH; depth++) {
-    if (exists(join(dir, ".git"))) return dir;
-    if (dir === root) break;
-    const parent = dirname(dir);
-    if (parent === dir) break;
-    dir = parent;
-  }
-  return cwd;
-}
-
-export function toIsoTime(value) {
-  if (typeof value === "string" && value.trim()) return value;
-  if (value instanceof Date) return value.toISOString();
-  if (typeof value === "number" && Number.isFinite(value)) {
-    return new Date(value).toISOString();
-  }
-  return null;
-}
-
-export function shortHash(value) {
-  const str = String(value ?? "");
-  let h = 5381;
-  for (let i = 0; i < str.length; i++) {
-    h = (h * 33) ^ str.charCodeAt(i);
-  }
-  return (h >>> 0).toString(36);
-}
-
-export function pathLabel(value) {
-  const str = String(value ?? "").replace(/[/\\]+$/u, "");
-  if (!str) return "";
-  const segments = str.split(/[/\\]+/u);
-  return segments[segments.length - 1] || "";
-}
-
-export function readJsonLines(filePath, limit = Infinity) {
-  if (!defaultExistsSync(filePath)) return [];
-  const lines = readFileSync(filePath, "utf8")
-    .split(/\r?\n/u)
-    .map((line) => line.trim())
-    .filter(Boolean);
-  return lines.slice(-limit).flatMap((line) => {
-    try {
-      return [JSON.parse(line)];
-    } catch {
-      return [];
-    }
-  });
-}
-
-export function writeAtomic(filePath, body) {
-  mkdirSync(dirname(filePath), { recursive: true });
-  const tmpPath = join(
-    dirname(filePath),
-    `.${basename(filePath)}.${process.pid}.${Date.now()}.tmp`,
-  );
-  writeFileSync(tmpPath, body, "utf8");
-  renameSync(tmpPath, filePath);
-}