@brainervirus/workit-core 2.9.0 → 4.0.0

package/src/store/reduce.ts

@@ -0,0 +1,203 @@
+// Pure reduction of a task's events into its state (design §4.1), plus the
+// content-addressed blob encoding for stored candidates.
+//
+// Every event may carry, in `data`:
+//   record   the whole task record (opening events and compaction checkpoints)
+//   ops      a structural patch of the record (see patch.ts)
+//   key      the implicit-task key the task is bound to (null unbinds)
+//   legacy   where a migrated task came from
+// The reducer applies whatever of these an event carries, so an event type
+// this runtime does not know still replays correctly when it uses them. An
+// unknown event that carries none of them is ignored, unless it is marked
+// `critical`, in which case the reader fails closed.
+import { createHash } from "node:crypto";
+import { LogDamage, type StoreEvent } from "./event-log";
+import { apply, isPatch, type PatchOp } from "./patch";
+import type { TaskKey } from "./paths";
+
+export type LegacyOrigin = { path: string; digest: string };
+
+export type ReducedTask = {
+  record: Record<string, unknown>;
+  key: TaskKey | null;
+  legacy: LegacyOrigin | null;
+};
+
+/** Event types that open (or restart, after compaction) a task's log. */
+export const OPENING_TYPES: ReadonlySet<string> = new Set([
+  "task.opened",
+  "task.imported",
+  "migrated.from_v2",
+  "task.checkpoint",
+]);
+
+/** Event types this runtime writes and reads. */
+const KNOWN_TYPES: ReadonlySet<string> = new Set([
+  ...OPENING_TYPES,
+  "task.bound",
+  "task.noted",
+  "task.revised",
+  "task.judged",
+  "task.paused",
+  "task.resumed",
+  "task.closed",
+  "task.updated",
+  "check.ran",
+  "evidence.recorded",
+  "finding.recorded",
+  "finding.updated",
+  "decision.recorded",
+  "decision.updated",
+  "worker.updated",
+]);
+
+const isObject = (value: unknown): value is Record<string, unknown> =>
+  typeof value === "object" && value !== null && !Array.isArray(value);
+
+const isKey = (value: unknown): value is TaskKey =>
+  isObject(value) &&
+  typeof value.key === "string" &&
+  (value.kind === "branch" || value.kind === "detached" || value.kind === "dir") &&
+  (value.branch === null || typeof value.branch === "string");
+
+// ---------------------------------------------------------------------------
+// blobs: stored candidates are written once, by content digest
+
+export type BlobStore = {
+  read(digest: string): unknown;
+  write(digest: string, value: unknown): void;
+};
+
+const BLOB_REF = "$blob";
+const blobRef = (value: unknown): string | null =>
+  isObject(value) &&
+  Object.keys(value).length === 1 &&
+  typeof value[BLOB_REF] === "string" &&
+  /^[0-9a-f]{64}$/.test(value[BLOB_REF])
+    ? value[BLOB_REF]
+    : null;
+
+export const blobDigest = (value: unknown): string =>
+  createHash("sha256").update(JSON.stringify(value)).digest("hex");
+
+const toBlob = (value: unknown, blobs: BlobStore): unknown => {
+  if (!isObject(value)) return value;
+  const digest = blobDigest(value);
+  blobs.write(digest, value);
+  return { [BLOB_REF]: digest };
+};
+
+/** Replace candidate bodies in a record with blob references. */
+export const encodeRecord = (
+  record: Record<string, unknown>,
+  blobs: BlobStore,
+): Record<string, unknown> =>
+  Array.isArray(record.candidates)
+    ? { ...record, candidates: record.candidates.map((item) => toBlob(item, blobs)) }
+    : record;
+
+/** Replace candidate bodies inside patch ops with blob references. */
+export const encodeOps = (ops: PatchOp[], blobs: BlobStore): PatchOp[] =>
+  ops.map((op) => {
+    if (op.path[0] !== "candidates") return op;
+    if (op.op === "push" && op.path.length === 1)
+      return { ...op, values: op.values.map((item) => toBlob(item, blobs)) };
+    if (op.op === "set" && op.path.length === 1 && Array.isArray(op.value))
+      return { ...op, value: op.value.map((item) => toBlob(item, blobs)) };
+    if (op.op === "set" && op.path.length === 2) return { ...op, value: toBlob(op.value, blobs) };
+    return op;
+  });
+
+/** Resolve blob references anywhere in `value`. */
+const decode = (value: unknown, blobs: BlobStore): unknown => {
+  const digest = blobRef(value);
+  if (digest) return blobs.read(digest);
+  if (Array.isArray(value)) return value.map((item) => decode(item, blobs));
+  if (isObject(value)) {
+    const out: Record<string, unknown> = {};
+    for (const [key, item] of Object.entries(value)) out[key] = decode(item, blobs);
+    return out;
+  }
+  return value;
+};
+
+// ---------------------------------------------------------------------------
+// reduction
+
+/** Apply one event to `state` (null before the opening event). */
+export function reduce(
+  state: ReducedTask | null,
+  event: StoreEvent,
+  blobs: BlobStore,
+): ReducedTask | null {
+  const data = event.data;
+  const known = KNOWN_TYPES.has(event.type);
+  const carries = "record" in data || "ops" in data || "key" in data;
+  if (!known && !carries) {
+    if (event.critical === true)
+      throw new LogDamage(
+        `event ${event.type} was written by a newer Workit and must be understood; upgrade Workit to read this task`,
+        true,
+      );
+    return state;
+  }
+  let next = state;
+  if ("record" in data) {
+    if (!isObject(data.record))
+      throw new LogDamage(`event ${event.seq} carries a malformed record`);
+    next = {
+      record: decode(data.record, blobs) as Record<string, unknown>,
+      key: null,
+      legacy: null,
+    };
+  } else if (next === null) {
+    throw new LogDamage(`the log does not start with an opening event (found ${event.type})`);
+  } else next = { ...next };
+  if ("ops" in data) {
+    if (!isPatch(data.ops)) throw new LogDamage(`event ${event.seq} carries a malformed patch`);
+    try {
+      next.record = apply(
+        next.record,
+        decode(data.ops, blobs) as PatchOp[],
+      ) as ReducedTask["record"];
+    } catch (error) {
+      throw new LogDamage(`event ${event.seq} does not apply: ${String(error)}`);
+    }
+  }
+  if ("key" in data) next.key = isKey(data.key) ? data.key : null;
+  if ("legacy" in data && isObject(data.legacy))
+    next.legacy = {
+      path: String(data.legacy.path ?? ""),
+      digest: String(data.legacy.digest ?? ""),
+    };
+  return next;
+}
+
+/** A readable event type for a mutation (informational; replay does not use it). */
+export function eventType(before: Record<string, unknown>, after: Record<string, unknown>): string {
+  const count = (value: unknown) => (Array.isArray(value) ? value.length : 0);
+  if (before.status !== after.status)
+    return after.status === "closed"
+      ? "task.closed"
+      : after.status === "paused"
+        ? "task.paused"
+        : "task.resumed";
+  if (count(after.evidence) > count(before.evidence)) {
+    const last = (after.evidence as Array<{ data?: { observation?: unknown } }>).at(-1);
+    return last?.data?.observation ? "check.ran" : "evidence.recorded";
+  }
+  if (count(after.findings) > count(before.findings)) return "finding.recorded";
+  if (count(after.decisions) > count(before.decisions)) return "decision.recorded";
+  if (JSON.stringify(before.findings) !== JSON.stringify(after.findings)) return "finding.updated";
+  if (JSON.stringify(before.decisions) !== JSON.stringify(after.decisions))
+    return "decision.updated";
+  if (JSON.stringify(before.workers) !== JSON.stringify(after.workers)) return "worker.updated";
+  if (JSON.stringify(before.intent) !== JSON.stringify(after.intent)) return "task.revised";
+  if (
+    JSON.stringify(before.assessments) !== JSON.stringify(after.assessments) ||
+    JSON.stringify(before.policy) !== JSON.stringify(after.policy)
+  )
+    return "task.judged";
+  if (JSON.stringify(before.progress) !== JSON.stringify(after.progress)) return "task.noted";
+  return "task.updated";
+}

package/scripts/doctor-check.ts

@@ -1,37 +0,0 @@
-#!/usr/bin/env bun
-// DG-09: installers run the shared offline doctor after writing configuration and
-// return nonzero when a required registration/config check fails. `installer:
-// true` limits the enforced checks to the ones the installer just guaranteed, so
-// a dev/stub checkout without built assets does not fail a post-install run.
-// CA-02: `cursor --stale` is the installer's self-heal pre-check — it exits 2
-// when the doctor's stale_install check fails and 0 otherwise. A
-// registry-unreachable comparison warns as registry_unreachable and is NOT
-// stale (CA-04): no false stale_install and no install failure. Other check
-// failures are left to the post-install gate.
-import { runDoctor } from "../src/core/doctor";
-
-const hostArg = process.argv[2];
-const host = hostArg === "cursor" ? "cursor" : hostArg === "cli" ? "cli" : "opencode";
-const staleOnly = process.argv.includes("--stale");
-const report = runDoctor({ host, installer: true });
-
-if (staleOnly) {
-  const stale = report.checks.find((c) => c.id === "stale_install");
-  if (stale?.status === "fail") {
-    process.stderr.write(`STALE: ${stale.detail}\n`);
-    if (stale.fix) process.stderr.write(`  fix: ${stale.fix}\n`);
-    process.exit(2);
-  }
-  process.exit(0);
-}
-
-if (report.exitCode !== 0) {
-  for (const check of report.checks) {
-    if (check.status === "fail") {
-      process.stderr.write(`FATAL: workit doctor ${check.id}: ${check.detail}\n`);
-      if (check.fix) process.stderr.write(`  fix: ${check.fix}\n`);
-    }
-  }
-  process.exit(1);
-}
-process.exit(0);

package/src/core/config-conversion.ts

@@ -1,180 +0,0 @@
-import { createHash } from "node:crypto";
-import { existsSync, readFileSync } from "node:fs";
-import path from "node:path";
-import { isConfigObject, mergePreset, type BranchPreset, type ToolkitConfig } from "./config";
-import { writeFileAtomic } from "./safe-write";
-
-export type ConversionInput = {
-  configDir: string;
-};
-
-export type ConversionMapping = {
-  key: string;
-  from: unknown;
-  to: unknown;
-  note?: string;
-};
-
-export type ConversionUnresolved = {
-  key: string;
-  reason: string;
-};
-
-export type ConversionPreview = {
-  mappings: ConversionMapping[];
-  preserved: string[];
-  unresolved: ConversionUnresolved[];
-};
-
-const REDACT_KEYS = /token|secret|password|credential/i;
-
-const readJsonObject = (file: string): Record<string, unknown> | null => {
-  if (!existsSync(file)) return null;
-  try {
-    const parsed = JSON.parse(readFileSync(file, "utf8"));
-    return isConfigObject(parsed) ? parsed : null;
-  } catch {
-    return null;
-  }
-};
-
-const redactValue = (key: string, value: unknown): unknown => {
-  if (REDACT_KEYS.test(key)) return "[redacted]";
-  if (typeof value === "string" && value.length > 8 && !value.includes(" ")) return "[redacted]";
-  return value;
-};
-
-export const redactConversionPreview = (preview: ConversionPreview): ConversionPreview => ({
-  mappings: preview.mappings.map((m) => ({
-    ...m,
-    from: redactValue(m.key, m.from),
-    to: redactValue(m.key, m.to),
-  })),
-  preserved: preview.preserved,
-  unresolved: preview.unresolved,
-});
-
-export function previewConversion(input: ConversionInput): ConversionPreview {
-  const configFile = path.join(input.configDir, "config.json");
-  const config = readJsonObject(configFile);
-  const mappings: ConversionMapping[] = [];
-  const unresolved: ConversionUnresolved[] = [];
-  const preserved: string[] = [];
-
-  if (config) {
-    if (config.locale !== undefined) {
-      mappings.push({ key: "locale", from: config.locale, to: config.locale });
-    }
-    if (config.branchPolicy !== undefined && isConfigObject(config.branchPolicy)) {
-      const bp = config.branchPolicy as ToolkitConfig["branchPolicy"] & {
-        allowed?: string[];
-        protected?: string[];
-      };
-      const preset = bp.preset ?? "gitflow";
-      const merged = mergePreset(
-        preset,
-        {
-          allowed: Array.isArray(bp.allowed) ? bp.allowed : undefined,
-          protectedNames: Array.isArray(bp.protected) ? bp.protected : undefined,
-        },
-        { branchPolicy: bp },
-      );
-      mappings.push({
-        key: "branchPolicy",
-        from: config.branchPolicy,
-        to: merged,
-        note: "preset-derived allowed/protected reset through mergePreset",
-      });
-      if (preset === "custom" && Array.isArray(bp.allowed)) {
-        if (bp.allowed.includes("*")) {
-          unresolved.push({
-            key: "branchPolicy.allowed",
-            reason: 'unsupported permissive value "*" requires an explicit v1 choice',
-          });
-        }
-      }
-    }
-    if (config.workflowMode !== undefined) {
-      unresolved.push({
-        key: "legacyWorkflowMode",
-        reason: "0.x workflow mode has no automatic v1 equivalent; choose how to continue",
-      });
-    }
-  }
-
-  for (const name of ["youtrack.json", "vcs.json", "workspaces.json"]) {
-    const file = path.join(input.configDir, name);
-    if (!existsSync(file)) continue;
-    const parsed = readJsonObject(file);
-    if (parsed)
-      mappings.push({ key: name, from: parsed, to: parsed, note: "carry forward unchanged" });
-  }
-
-  for (const token of ["youtrack.token", "gitlab.token", "github.token"]) {
-    const file = path.join(input.configDir, token);
-    if (existsSync(file)) preserved.push(file);
-  }
-
-  return { mappings, preserved, unresolved };
-}
-
-export const conversionDigest = (preview: ConversionPreview): string =>
-  createHash("sha256")
-    .update(JSON.stringify(redactConversionPreview(preview)))
-    .digest("hex");
-
-export type ConversionApplyResult = {
-  configPath: string;
-  choicesPath: string;
-};
-
-/** Apply approved conversion mappings and record explicit resolution choices. */
-export function applyConversionConfig(
-  configDir: string,
-  preview: ConversionPreview,
-  resolutions: Record<string, string>,
-): ConversionApplyResult {
-  const configFile = path.join(configDir, "config.json");
-  const raw = readJsonObject(configFile) ?? {};
-  const next: Record<string, unknown> = { ...raw };
-
-  for (const mapping of preview.mappings) {
-    if (mapping.key === "locale") {
-      next[mapping.key] = mapping.to;
-    }
-    if (mapping.key === "branchPolicy" && !resolutions["branchPolicy.allowed"]) {
-      next.branchPolicy = mapping.to;
-    }
-  }
-
-  if (resolutions["branchPolicy.allowed"]) {
-    const bp = isConfigObject(next.branchPolicy)
-      ? (next.branchPolicy as ToolkitConfig["branchPolicy"])
-      : { preset: "custom" as BranchPreset, allowed: [], protected: [] };
-    const preset = bp.preset ?? "custom";
-    next.branchPolicy = mergePreset(
-      preset,
-      {
-        allowed: resolutions["branchPolicy.allowed"]
-          .split(",")
-          .map((s) => s.trim())
-          .filter(Boolean),
-      },
-      { branchPolicy: bp },
-    );
-  }
-
-  if (resolutions["legacyWorkflowMode"]) {
-    delete next.workflowMode;
-  }
-
-  writeFileAtomic(configFile, JSON.stringify(next, null, 2) + "\n");
-
-  const choicesPath = path.join(configDir, "cutover-choices.json");
-  writeFileAtomic(
-    choicesPath,
-    JSON.stringify({ resolutions, applied_at: new Date().toISOString() }, null, 2) + "\n",
-  );
-
-  return { configPath: configFile, choicesPath };
-}