@triflux/remote 10.53.0 → 10.55.0

package/cto/collect.mjs

@@ -1,490 +0,0 @@
-import { execFileSync } from "node:child_process";
-import {
-  existsSync,
-  mkdirSync,
-  readdirSync,
-  readFileSync,
-  statSync,
-} from "node:fs";
-import { join, relative } from "node:path";
-import { fileURLToPath } from "node:url";
-
-import { renderBrief } from "./brief.mjs";
-import { appendCtoEvent } from "./events.mjs";
-import {
-  readJsonLines,
-  resolveLakeRootDir,
-  writeAtomic,
-} from "./lake-root.mjs";
-
-const SCHEMA_VERSION = "cto-lake.v1";
-const SOURCE_REGISTRY = [
-  {
-    id: "git",
-    kind: "repo",
-    probe: "git rev-parse, git branch, git status",
-    enabled: true,
-  },
-  {
-    id: "ultragoal_omx",
-    kind: "durable-goal-artifact",
-    probe: ".omx/ultragoal/goals.json",
-    enabled: true,
-  },
-  {
-    id: "ultragoal_omc",
-    kind: "durable-goal-artifact",
-    probe: ".omc/ultragoal/goals.json",
-    enabled: true,
-  },
-  {
-    id: "handoffs",
-    kind: "durable-handoff-artifact",
-    probe: ".omx/handoffs/*",
-    enabled: true,
-  },
-];
-const SOURCE_IDS = SOURCE_REGISTRY.map((source) => source.id);
-
-const SCHEMA_PATH = fileURLToPath(
-  new URL("./current.schema.json", import.meta.url),
-);
-
-function isoNow(opts) {
-  const value =
-    opts.now instanceof Date
-      ? opts.now
-      : opts.now
-        ? new Date(opts.now)
-        : new Date();
-  return value.toISOString();
-}
-
-function sourceState(available, status, detail, collectedAt) {
-  return {
-    available,
-    status,
-    detail,
-    collected_at: collectedAt,
-  };
-}
-
-function missingSource(status, detail, collectedAt) {
-  return sourceState(false, status, detail, collectedAt);
-}
-
-function relPath(rootDir, filePath) {
-  const rel = relative(rootDir, filePath).replace(/\\/g, "/");
-  return rel && !rel.startsWith("..") ? rel : filePath;
-}
-
-function readJson(filePath) {
-  return JSON.parse(readFileSync(filePath, "utf8"));
-}
-
-function listDirFiles(dirPath, rootDir, limit = 10) {
-  if (!existsSync(dirPath)) return [];
-  try {
-    return readdirSync(dirPath, { withFileTypes: true })
-      .filter((entry) => entry.isFile())
-      .map((entry) => {
-        const filePath = join(dirPath, entry.name);
-        return {
-          path: relPath(rootDir, filePath),
-          mtime: statSync(filePath).mtime.toISOString(),
-        };
-      })
-      .sort((a, b) => b.mtime.localeCompare(a.mtime))
-      .slice(0, limit);
-  } catch {
-    return [];
-  }
-}
-
-function execGit(args, rootDir, execFileSyncFn) {
-  return execFileSyncFn("git", args, {
-    cwd: rootDir,
-    encoding: "utf8",
-    stdio: ["ignore", "pipe", "pipe"],
-    windowsHide: true,
-  }).trim();
-}
-
-function collectGit(rootDir, collectedAt, execFileSyncFn) {
-  try {
-    const gitRoot = execGit(
-      ["rev-parse", "--show-toplevel"],
-      rootDir,
-      execFileSyncFn,
-    );
-    const branch =
-      execGit(["branch", "--show-current"], gitRoot, execFileSyncFn) || null;
-    const head =
-      execGit(["rev-parse", "--short=12", "HEAD"], gitRoot, execFileSyncFn) ||
-      null;
-    const porcelain = execGit(
-      ["status", "--porcelain"],
-      gitRoot,
-      execFileSyncFn,
-    );
-    const dirty = porcelain.length > 0;
-    const repo = { root: gitRoot, branch, head, dirty };
-    return {
-      repo,
-      source: sourceState(
-        true,
-        dirty ? "dirty" : "clean",
-        {
-          branch,
-          head,
-          dirty,
-          changed_entries: porcelain ? porcelain.split(/\r?\n/u).length : 0,
-        },
-        collectedAt,
-      ),
-    };
-  } catch (error) {
-    return {
-      repo: { root: rootDir, branch: null, head: null, dirty: false },
-      source: missingSource(
-        "unavailable",
-        `git status unavailable: ${error?.message || "unknown error"}`,
-        collectedAt,
-      ),
-    };
-  }
-}
-
-function normalizeGoals(parsed) {
-  const rawGoals = Array.isArray(parsed?.goals)
-    ? parsed.goals
-    : Array.isArray(parsed)
-      ? parsed
-      : [];
-  return rawGoals.map((goal) => ({
-    id: goal?.id || null,
-    title: goal?.title || goal?.objective || goal?.summary || null,
-    status: goal?.status || "unknown",
-    updated_at: goal?.updatedAt || goal?.updated_at || null,
-  }));
-}
-
-function collectUltragoal(dirPath, rootDir, collectedAt) {
-  const goalsPath = join(dirPath, "goals.json");
-  const ledgerPath = join(dirPath, "ledger.jsonl");
-  const briefPath = join(dirPath, "brief.md");
-  if (
-    !existsSync(goalsPath) &&
-    !existsSync(ledgerPath) &&
-    !existsSync(briefPath)
-  ) {
-    return missingSource(
-      "no_shell_readable_artifact",
-      "no ultragoal files found",
-      collectedAt,
-    );
-  }
-
-  const detail = {
-    paths: {},
-    goals_count: 0,
-    active_goals: [],
-    ledger_tail: [],
-    brief: null,
-  };
-
-  try {
-    if (existsSync(goalsPath)) {
-      detail.paths.goals = relPath(rootDir, goalsPath);
-      const parsed = readJson(goalsPath);
-      const goals = normalizeGoals(parsed);
-      detail.goals_count = goals.length;
-      detail.active_goals = goals
-        .filter(
-          (goal) =>
-            !["complete", "completed", "done"].includes(
-              String(goal.status).toLowerCase(),
-            ),
-        )
-        .slice(0, 5);
-    }
-    if (existsSync(ledgerPath)) {
-      detail.paths.ledger = relPath(rootDir, ledgerPath);
-      detail.ledger_tail = readJsonLines(ledgerPath, 5);
-    }
-    if (existsSync(briefPath)) {
-      detail.paths.brief = relPath(rootDir, briefPath);
-      detail.brief = readFileSync(briefPath, "utf8")
-        .replace(/\s+/g, " ")
-        .trim()
-        .slice(0, 300);
-    }
-    return sourceState(true, "ok", detail, collectedAt);
-  } catch (error) {
-    return sourceState(
-      true,
-      "read_error",
-      {
-        path: relPath(rootDir, dirPath),
-        error: error?.message || "ultragoal read failed",
-      },
-      collectedAt,
-    );
-  }
-}
-
-function collectHandoffs(rootDir, collectedAt) {
-  const dirPath = join(rootDir, ".omx", "handoffs");
-  const files = listDirFiles(dirPath, rootDir, 10);
-  if (files.length === 0) {
-    return missingSource(
-      "no_shell_readable_artifact",
-      "no .omx/handoffs files found",
-      collectedAt,
-    );
-  }
-  return sourceState(
-    true,
-    "ok",
-    { path: relPath(rootDir, dirPath), files },
-    collectedAt,
-  );
-}
-
-function buildSummary(current) {
-  const repo = current.repo;
-  const omxGoals = current.sources.ultragoal_omx.detail?.active_goals || [];
-  const omcGoals = current.sources.ultragoal_omc.detail?.active_goals || [];
-  const availableSources = Object.values(current.sources).filter(
-    (source) => source.available,
-  ).length;
-
-  return {
-    repo_state: `branch ${repo.branch || "unknown"} at ${repo.head || "unknown"} is ${repo.dirty ? "dirty" : "clean"}`,
-    active_goals: [...omxGoals, ...omcGoals].slice(0, 5),
-    available_sources: availableSources,
-    missing_sources: SOURCE_IDS.length - availableSources,
-  };
-}
-
-function isPlainObject(value) {
-  return value !== null && typeof value === "object" && !Array.isArray(value);
-}
-
-function assertPlainObject(name, value) {
-  if (!isPlainObject(value)) throw new Error(`${name} must be object`);
-}
-
-function assertOnlyKeys(name, value, allowedKeys) {
-  assertPlainObject(name, value);
-  const allowed = new Set(allowedKeys);
-  for (const key of Object.keys(value)) {
-    if (!allowed.has(key)) throw new Error(`${name} has unexpected ${key}`);
-  }
-}
-
-function assertString(name, value) {
-  if (typeof value !== "string") throw new Error(`${name} must be string`);
-}
-
-function assertStringOrNull(name, value) {
-  if (typeof value !== "string" && value !== null) {
-    throw new Error(`${name} must be string or null`);
-  }
-}
-
-function assertDateTimeStringOrNull(name, value) {
-  assertStringOrNull(name, value);
-  if (value !== null && Number.isNaN(Date.parse(value))) {
-    throw new Error(`${name} must be date-time`);
-  }
-}
-
-function assertBoolean(name, value) {
-  if (typeof value !== "boolean") throw new Error(`${name} must be boolean`);
-}
-
-function validateLedgerEntry(entry, prefix = "ledger_tail entry") {
-  assertOnlyKeys(prefix, entry, ["ts", "event", "source", "summary", "ref"]);
-  assertDateTimeStringOrNull(`${prefix}.ts`, entry.ts);
-  if (entry.ts === null) throw new Error(`${prefix}.ts must be string`);
-  assertString(`${prefix}.event`, entry.event);
-  assertString(`${prefix}.source`, entry.source);
-  assertString(`${prefix}.summary`, entry.summary);
-  if (
-    entry.ref !== null &&
-    typeof entry.ref !== "string" &&
-    !isPlainObject(entry.ref)
-  ) {
-    throw new Error(`${prefix}.ref must be string, object, or null`);
-  }
-}
-
-function isValidLedgerEntry(entry) {
-  try {
-    validateLedgerEntry(entry);
-    return true;
-  } catch {
-    return false;
-  }
-}
-
-function readLedgerTail(lakeRoot, limit = 5) {
-  return readJsonLines(join(lakeRoot, "ledger.jsonl"), limit * 4)
-    .filter(isValidLedgerEntry)
-    .slice(-limit);
-}
-
-function validateSourceState(sourceId, source) {
-  const prefix = `current.json source ${sourceId}`;
-  assertOnlyKeys(prefix, source, [
-    "available",
-    "status",
-    "detail",
-    "collected_at",
-  ]);
-  assertBoolean(`${prefix}.available`, source.available);
-  assertString(`${prefix}.status`, source.status);
-  if (
-    source.detail !== null &&
-    typeof source.detail !== "string" &&
-    typeof source.detail !== "object"
-  ) {
-    throw new Error(`${prefix}.detail must be string, object, array, or null`);
-  }
-  assertDateTimeStringOrNull(`${prefix}.collected_at`, source.collected_at);
-}
-
-function validateCurrent(current) {
-  const schema = readJson(SCHEMA_PATH);
-  assertOnlyKeys("current.json", current, schema.required);
-  for (const field of schema.required) {
-    if (!Object.hasOwn(current, field))
-      throw new Error(`current.json missing ${field}`);
-  }
-  if (current.schema_version !== SCHEMA_VERSION) {
-    throw new Error(`current.json schema_version must be ${SCHEMA_VERSION}`);
-  }
-  assertDateTimeStringOrNull("current.json.generated_at", current.generated_at);
-  if (current.generated_at === null)
-    throw new Error("current.json.generated_at must be string");
-
-  assertOnlyKeys("current.json.repo", current.repo, [
-    "root",
-    "branch",
-    "head",
-    "dirty",
-  ]);
-  assertString("current.json.repo.root", current.repo.root);
-  assertStringOrNull("current.json.repo.branch", current.repo.branch);
-  assertStringOrNull("current.json.repo.head", current.repo.head);
-  assertBoolean("current.json.repo.dirty", current.repo.dirty);
-
-  assertOnlyKeys(
-    "current.json.sources",
-    current.sources,
-    schema.properties.sources.required,
-  );
-  for (const sourceId of schema.properties.sources.required) {
-    const source = current.sources?.[sourceId];
-    if (!source) throw new Error(`current.json missing source ${sourceId}`);
-    validateSourceState(sourceId, source);
-  }
-
-  assertPlainObject("current.json.summary", current.summary);
-  if (!Array.isArray(current.ledger_tail))
-    throw new Error("current.json ledger_tail must be array");
-  for (const [index, entry] of current.ledger_tail.entries()) {
-    validateLedgerEntry(entry, `ledger_tail[${index}]`);
-  }
-}
-
-function collectSources(rootDir, collectedAt, execFileSyncFn) {
-  const git = collectGit(rootDir, collectedAt, execFileSyncFn);
-  const sources = {
-    git: git.source,
-    ultragoal_omx: collectUltragoal(
-      join(rootDir, ".omx", "ultragoal"),
-      rootDir,
-      collectedAt,
-    ),
-    ultragoal_omc: collectUltragoal(
-      join(rootDir, ".omc", "ultragoal"),
-      rootDir,
-      collectedAt,
-    ),
-    handoffs: collectHandoffs(rootDir, collectedAt),
-  };
-
-  return { repo: git.repo, sources };
-}
-
-function hasFlag(args, flag) {
-  return Array.isArray(args) && args.includes(flag);
-}
-
-export async function runCollect(args = [], opts = {}) {
-  if (hasFlag(args, "--help")) {
-    (opts.stdout || process.stdout).write(
-      "Usage: tfx cto collect [--json]\nRefresh the CTO lake from durable authority sources.\n",
-    );
-    return;
-  }
-  const rootDir = opts.rootDir || resolveLakeRootDir(process.cwd());
-  const lakeRoot = opts.lakeRoot || join(rootDir, ".triflux", "lake");
-  const stdout = opts.stdout || process.stdout;
-  const stderr = opts.stderr || process.stderr;
-  const execFileSyncFn = opts.execFileSyncFn || execFileSync;
-  const generatedAt = isoNow(opts);
-
-  mkdirSync(lakeRoot, { recursive: true });
-
-  const { repo, sources } = collectSources(
-    rootDir,
-    generatedAt,
-    execFileSyncFn,
-  );
-  const current = {
-    schema_version: SCHEMA_VERSION,
-    generated_at: generatedAt,
-    repo,
-    sources,
-    summary: {},
-    ledger_tail: readLedgerTail(lakeRoot),
-  };
-  current.summary = buildSummary(current);
-
-  const event = {
-    ts: generatedAt,
-    event: "collect",
-    source: "tfx_cto_collect",
-    summary: `collected ${current.summary.available_sources}/${SOURCE_IDS.length} durable sources`,
-    ref: {
-      current_json: "current.json",
-      current_md: "current.md",
-      sources_json: "sources.json",
-    },
-  };
-  const { appended } = await appendCtoEvent(lakeRoot, event, { stderr });
-  if (appended) current.ledger_tail = readLedgerTail(lakeRoot);
-
-  validateCurrent(current);
-  writeAtomic(
-    join(lakeRoot, "current.json"),
-    `${JSON.stringify(current, null, 2)}\n`,
-  );
-  writeAtomic(join(lakeRoot, "current.md"), renderBrief(current));
-  writeAtomic(
-    join(lakeRoot, "sources.json"),
-    `${JSON.stringify(SOURCE_REGISTRY, null, 2)}
-`,
-  );
-
-  if (opts.json === true || hasFlag(args, "--json")) {
-    stdout.write(`${JSON.stringify(current, null, 2)}\n`);
-  } else {
-    stdout.write(`wrote ${join(lakeRoot, "current.json")} and current.md\n`);
-  }
-
-  return current;
-}

package/cto/current.schema.json

@@ -1,148 +0,0 @@
-{
-  "$schema": "https://json-schema.org/draft/2020-12/schema",
-  "$id": "https://triflux.local/schemas/cto/current.schema.json",
-  "title": "Triflux CTO Lake Current Authority State",
-  "description": "Contract for .triflux/lake/current.json. .triflux/lake is a triflux-owned, namespace-neutral cross-agent rollup for durable artifacts across Claude, Codex/OMX, OMC, and Triflux state. It reads and aggregates .omx/ultragoal and .omc/ultragoal execution ledgers without replacing or duplicating their authority. ledger.jsonl and sources.json companion contracts are documented in $defs.",
-  "type": "object",
-  "additionalProperties": false,
-  "required": [
-    "schema_version",
-    "generated_at",
-    "repo",
-    "sources",
-    "summary",
-    "ledger_tail"
-  ],
-  "properties": {
-    "schema_version": {
-      "type": "string",
-      "const": "cto-lake.v1"
-    },
-    "generated_at": {
-      "type": "string",
-      "format": "date-time"
-    },
-    "repo": {
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["root", "branch", "head", "dirty"],
-      "properties": {
-        "root": {
-          "type": "string",
-          "minLength": 1
-        },
-        "branch": {
-          "type": ["string", "null"]
-        },
-        "head": {
-          "type": ["string", "null"]
-        },
-        "dirty": {
-          "type": "boolean"
-        }
-      }
-    },
-    "sources": {
-      "type": "object",
-      "description": "Durable artifact source states only. A source reports available:false when no shell-readable durable artifact exists.",
-      "additionalProperties": false,
-      "required": ["git", "ultragoal_omx", "ultragoal_omc", "handoffs"],
-      "properties": {
-        "git": {
-          "$ref": "#/$defs/sourceState"
-        },
-        "ultragoal_omx": {
-          "$ref": "#/$defs/sourceState"
-        },
-        "ultragoal_omc": {
-          "$ref": "#/$defs/sourceState"
-        },
-        "handoffs": {
-          "$ref": "#/$defs/sourceState"
-        }
-      }
-    },
-    "summary": {
-      "type": "object",
-      "description": "Human-oriented synthesized authority summary derived from durable artifacts. Phase 1 may add source-derived fields here without changing the top-level contract.",
-      "additionalProperties": true
-    },
-    "ledger_tail": {
-      "type": "array",
-      "description": "Recent append-only .triflux/lake/ledger.jsonl entries copied into current.json for quick status rendering.",
-      "items": {
-        "$ref": "#/$defs/ledgerEntry"
-      }
-    }
-  },
-  "$defs": {
-    "sourceState": {
-      "description": "Every collected durable source reports { available, status, detail, collected_at }. available:false means the surface exposes no shell-readable artifact for this collection pass.",
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["available", "status", "detail", "collected_at"],
-      "properties": {
-        "available": {
-          "type": "boolean"
-        },
-        "status": {
-          "type": "string"
-        },
-        "detail": {
-          "type": ["string", "object", "array", "null"]
-        },
-        "collected_at": {
-          "type": ["string", "null"],
-          "format": "date-time"
-        }
-      }
-    },
-    "ledgerEntry": {
-      "description": ".triflux/lake/ledger.jsonl is append-only and single-writer. The collector must acquire .triflux/lake/ledger.jsonl.lock before appending so concurrent collectors cannot interleave or corrupt JSONL lines. Each line is one JSON object with this shape.",
-      "type": "object",
-      "additionalProperties": false,
-      "required": ["ts", "event", "source", "summary", "ref"],
-      "properties": {
-        "ts": {
-          "type": "string",
-          "format": "date-time"
-        },
-        "event": {
-          "type": "string"
-        },
-        "source": {
-          "type": "string"
-        },
-        "summary": {
-          "type": "string"
-        },
-        "ref": {
-          "type": ["string", "object", "null"]
-        }
-      }
-    },
-    "sourceRegistry": {
-      "$comment": ".triflux/lake/sources.json is an array of durable source probe registrations.",
-      "type": "array",
-      "items": {
-        "type": "object",
-        "additionalProperties": false,
-        "required": ["id", "kind", "probe", "enabled"],
-        "properties": {
-          "id": {
-            "type": "string"
-          },
-          "kind": {
-            "type": "string"
-          },
-          "probe": {
-            "type": ["string", "object"]
-          },
-          "enabled": {
-            "type": "boolean"
-          }
-        }
-      }
-    }
-  }
-}