mainflow 0.28.0 → 0.29.0

package/dist/host.js

@@ -1,2 +1,2 @@
-import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-CeN3dvXg.js";
+import { a as openInApp, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, r as caddySites, s as siteBlock, t as APP_BUNDLE_ID } from "./host-BJnrv8xF.js";
 export { APP_BUNDLE_ID, DEFAULT_UI_PORT, caddySites, hostName, openInApp, removeHostLink, siteBlock, syncHost };

package/dist/index-DV6Gqu8K.d.ts

@@ -0,0 +1,423 @@
+import { z } from "zod";
+//#region ../schema/dist/index.d.ts
+declare const FORMAT_VERSION = 2;
+declare const ID_PATTERNS: {
+  readonly mainline: RegExp;
+  readonly task: RegExp;
+  readonly checklistItem: RegExp;
+  readonly criterion: RegExp;
+  readonly decision: RegExp;
+  readonly action: RegExp;
+  readonly issue: RegExp;
+  readonly finding: RegExp;
+  readonly grant: RegExp;
+};
+declare const CHECKLIST_REF: RegExp;
+/** What an action may serve: a checklist item, or a mainline's criterion while the mainline has no task for it yet. */
+declare const SERVES_REF: RegExp;
+declare const SLUG: RegExp;
+/** One source the survey checks: the line's label, what it holds, and how it may be left unchecked. */
+interface SurveyLine {
+  label: string;
+  holds: string;
+  /** The word that marks the source as not checked, followed by the reason, e.g. 不適用：{理由}. Absent when the source is always checked. */
+  skip?: string;
+  /** Text a checked line must contain, e.g. the environment a spike ran in. */
+  requires?: string;
+}
+declare const checklistItemSchema: z.ZodObject<{
+  text: z.ZodString;
+  doneWhen: z.ZodOptional<z.ZodString>;
+  done: z.ZodBoolean;
+  evidence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  doneAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  dropped: z.ZodOptional<z.ZodBoolean>;
+  supersededBy: z.ZodOptional<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  id: z.ZodString;
+  serves: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
+type ChecklistItem = z.infer<typeof checklistItemSchema>;
+declare const mainlineSchema: z.ZodObject<{
+  category: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  created: z.ZodString;
+  closedAt: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  origin: z.ZodOptional<z.ZodString>;
+  refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rel: z.ZodEnum<{
+      "depends-on": "depends-on";
+      relates: "relates";
+      "split-from": "split-from";
+    }>;
+    to: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  title: z.ZodString;
+  status: z.ZodEnum<{
+    active: "active";
+    done: "done";
+    dropped: "dropped";
+    paused: "paused";
+    planning: "planning";
+  }>;
+  priority: z.ZodOptional<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>;
+  due: z.ZodOptional<z.ZodString>;
+  archivedAt: z.ZodOptional<z.ZodString>;
+  criteria: z.ZodArray<z.ZodObject<{
+    text: z.ZodString;
+    doneWhen: z.ZodOptional<z.ZodString>;
+    done: z.ZodBoolean;
+    evidence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    doneAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    dropped: z.ZodOptional<z.ZodBoolean>;
+    supersededBy: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+  }, z.core.$strip>>;
+  budget: z.ZodOptional<z.ZodObject<{
+    amount: z.ZodNumber;
+    unit: z.ZodString;
+  }, z.core.$strip>>;
+  costs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    date: z.ZodString;
+    item: z.ZodString;
+    unit: z.ZodString;
+    estimate: z.ZodOptional<z.ZodNumber>;
+    actual: z.ZodOptional<z.ZodNumber>;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  grants: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    id: z.ZodString;
+    action: z.ZodEnum<{
+      commit: "commit";
+      "install-prompts": "install-prompts";
+      "merge-pr": "merge-pr";
+      publish: "publish";
+      push: "push";
+      release: "release";
+      "sync-hubs": "sync-hubs";
+    }>;
+    target: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+}, z.core.$strip>;
+type Mainline = z.infer<typeof mainlineSchema>;
+declare const decisionSchema: z.ZodObject<{
+  category: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  created: z.ZodString;
+  closedAt: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  origin: z.ZodOptional<z.ZodString>;
+  refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rel: z.ZodEnum<{
+      "depends-on": "depends-on";
+      relates: "relates";
+      "split-from": "split-from";
+    }>;
+    to: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  title: z.ZodString;
+  status: z.ZodEnum<{
+    accepted: "accepted";
+    proposed: "proposed";
+    superseded: "superseded";
+  }>;
+  priority: z.ZodOptional<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>;
+  decidedAt: z.ZodOptional<z.ZodString>;
+  supersededBy: z.ZodOptional<z.ZodString>;
+  by: z.ZodOptional<z.ZodEnum<{
+    ai: "ai";
+    relay: "relay";
+    user: "user";
+  }>>;
+  basis: z.ZodOptional<z.ZodEnum<{
+    explicit: "explicit";
+    recommended: "recommended";
+  }>>;
+  affects: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  reversible: z.ZodOptional<z.ZodBoolean>;
+}, z.core.$strip>;
+type Decision = z.infer<typeof decisionSchema>;
+declare const taskSchema: z.ZodObject<{
+  category: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  created: z.ZodString;
+  closedAt: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  origin: z.ZodOptional<z.ZodString>;
+  refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rel: z.ZodEnum<{
+      "depends-on": "depends-on";
+      relates: "relates";
+      "split-from": "split-from";
+    }>;
+    to: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  title: z.ZodString;
+  status: z.ZodEnum<{
+    blocked: "blocked";
+    doing: "doing";
+    done: "done";
+    dropped: "dropped";
+    todo: "todo";
+  }>;
+  priority: z.ZodOptional<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>;
+  kind: z.ZodEnum<{
+    branch: "branch";
+    phase: "phase";
+  }>;
+  parent: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  order: z.ZodOptional<z.ZodNumber>;
+  dependsOn: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  repo: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+  touches: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  startedAt: z.ZodOptional<z.ZodString>;
+  checklist: z.ZodArray<z.ZodObject<{
+    text: z.ZodString;
+    doneWhen: z.ZodOptional<z.ZodString>;
+    done: z.ZodBoolean;
+    evidence: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    doneAt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+    dropped: z.ZodOptional<z.ZodBoolean>;
+    supersededBy: z.ZodOptional<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    id: z.ZodString;
+    serves: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  }, z.core.$strip>>;
+  blockedBy: z.ZodOptional<z.ZodObject<{
+    reason: z.ZodString;
+    waitingFor: z.ZodOptional<z.ZodString>;
+    signal: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  branch: z.ZodOptional<z.ZodString>;
+  worktree: z.ZodOptional<z.ZodString>;
+  base: z.ZodOptional<z.ZodString>;
+  merge: z.ZodOptional<z.ZodEnum<{
+    abandoned: "abandoned";
+    merged: "merged";
+    open: "open";
+  }>>;
+}, z.core.$strip>;
+type Task = z.infer<typeof taskSchema>;
+/**
+ * A condition a program can check, written `{kind}:{argument}`. `commit` holds once a commit message on the
+ * branch contains the text, `action-done` once the action is done, `file` once the path exists under the hub
+ * root. Git branch names cannot contain a colon, so the text after the branch may.
+ */
+type Until = {
+  kind: 'commit';
+  branch: string;
+  text: string;
+} | {
+  kind: 'action-done';
+  session: string;
+  action: string;
+} | {
+  kind: 'file';
+  path: string;
+};
+/**
+ * Why a blocked action cannot move, what it waits for, and the condition a program checks to end the wait.
+ * `waitingFor` is free text, another session's action such as claude-code-1a2b3c4d#a003, or a hub reference
+ * such as m031/t002 when the whole text is one.
+ */
+declare const actionBlockSchema: z.ZodObject<{
+  reason: z.ZodString;
+  waitingFor: z.ZodOptional<z.ZodString>;
+  until: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type ActionBlock = z.infer<typeof actionBlockSchema>;
+declare const actionSchema: z.ZodObject<{
+  id: z.ZodString;
+  do: z.ZodString;
+  status: z.ZodEnum<{
+    blocked: "blocked";
+    doing: "doing";
+    done: "done";
+    dropped: "dropped";
+    todo: "todo";
+  }>;
+  serves: z.ZodArray<z.ZodString>;
+  note: z.ZodOptional<z.ZodString>;
+  blockedBy: z.ZodOptional<z.ZodObject<{
+    reason: z.ZodString;
+    waitingFor: z.ZodOptional<z.ZodString>;
+    until: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>;
+  startedAt: z.ZodOptional<z.ZodString>;
+  doneAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Action = z.infer<typeof actionSchema>;
+declare const sessionSchema: z.ZodObject<{
+  id: z.ZodString;
+  agent: z.ZodString;
+  status: z.ZodEnum<{
+    active: "active";
+    ended: "ended";
+    "handed-off": "handed-off";
+    paused: "paused";
+  }>;
+  started: z.ZodString;
+  delegatedFrom: z.ZodNullable<z.ZodString>;
+  handoffFrom: z.ZodNullable<z.ZodString>;
+  cwd: z.ZodString;
+  actions: z.ZodArray<z.ZodPreprocess<z.ZodObject<{
+    id: z.ZodString;
+    do: z.ZodString;
+    status: z.ZodEnum<{
+      blocked: "blocked";
+      doing: "doing";
+      done: "done";
+      dropped: "dropped";
+      todo: "todo";
+    }>;
+    serves: z.ZodArray<z.ZodString>;
+    note: z.ZodOptional<z.ZodString>;
+    blockedBy: z.ZodOptional<z.ZodObject<{
+      reason: z.ZodString;
+      waitingFor: z.ZodOptional<z.ZodString>;
+      until: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>>;
+    startedAt: z.ZodOptional<z.ZodString>;
+    doneAt: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>, unknown>>;
+  transcript: z.ZodOptional<z.ZodString>;
+  worktree: z.ZodOptional<z.ZodString>;
+  branch: z.ZodOptional<z.ZodString>;
+  model: z.ZodOptional<z.ZodString>;
+  effort: z.ZodOptional<z.ZodString>;
+  description: z.ZodOptional<z.ZodString>;
+  depth: z.ZodOptional<z.ZodNumber>;
+  summary: z.ZodOptional<z.ZodString>;
+  reminderDigest: z.ZodOptional<z.ZodString>;
+  archivedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Session = z.infer<typeof sessionSchema>;
+/** Front matter of issues/i{NNN}-{slug}.md: follow-ups and waits that must survive the mainline that found them. */
+declare const issueSchema: z.ZodObject<{
+  category: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  created: z.ZodString;
+  closedAt: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  origin: z.ZodOptional<z.ZodString>;
+  refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rel: z.ZodEnum<{
+      "depends-on": "depends-on";
+      relates: "relates";
+      "split-from": "split-from";
+    }>;
+    to: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  title: z.ZodString;
+  status: z.ZodEnum<{
+    closed: "closed";
+    open: "open";
+    planned: "planned";
+  }>;
+  priority: z.ZodOptional<z.ZodEnum<{
+    P0: "P0";
+    P1: "P1";
+    P2: "P2";
+    P3: "P3";
+  }>>;
+  order: z.ZodOptional<z.ZodNumber>;
+  due: z.ZodOptional<z.ZodString>;
+  plannedIn: z.ZodOptional<z.ZodString>;
+  archivedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Issue = z.infer<typeof issueSchema>;
+/** Front matter of findings/f{NNN}-{slug}.md: lessons and pitfalls the next task should read before it starts. */
+declare const findingSchema: z.ZodObject<{
+  category: z.ZodOptional<z.ZodString>;
+  labels: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  created: z.ZodString;
+  closedAt: z.ZodOptional<z.ZodString>;
+  resolution: z.ZodOptional<z.ZodString>;
+  origin: z.ZodOptional<z.ZodString>;
+  refs: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    title: z.ZodString;
+    url: z.ZodOptional<z.ZodString>;
+    path: z.ZodOptional<z.ZodString>;
+    date: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  links: z.ZodOptional<z.ZodArray<z.ZodObject<{
+    rel: z.ZodEnum<{
+      "depends-on": "depends-on";
+      relates: "relates";
+      "split-from": "split-from";
+    }>;
+    to: z.ZodString;
+    note: z.ZodOptional<z.ZodString>;
+  }, z.core.$strip>>>;
+  id: z.ZodString;
+  title: z.ZodString;
+  status: z.ZodEnum<{
+    obsolete: "obsolete";
+    valid: "valid";
+  }>;
+  appliesTo: z.ZodOptional<z.ZodArray<z.ZodString>>;
+  reviewAfter: z.ZodOptional<z.ZodString>;
+  archivedAt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type Finding = z.infer<typeof findingSchema>;
+/** One line of ops/{YYYY-MM}.log: an external operation, append-only. */
+declare const opsEntrySchema: z.ZodObject<{
+  at: z.ZodString;
+  target: z.ZodString;
+  operation: z.ZodString;
+  result: z.ZodString;
+  ref: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+type OpsEntry = z.infer<typeof opsEntrySchema>;
+//#endregion
+export { Until as _, Decision as a, ID_PATTERNS as c, OpsEntry as d, SERVES_REF as f, Task as g, SurveyLine as h, ChecklistItem as i, Issue as l, Session as m, ActionBlock as n, FORMAT_VERSION as o, SLUG as p, CHECKLIST_REF as r, Finding as s, Action as t, Mainline as u };

package/dist/{launch-BKKoCyTj.js → launch-DefacJEL.js}

@@ -1,4 +1,4 @@
-import { _t as WriteError, c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, yt as DATA_DIR } from "./host-CeN3dvXg.js";
+import { c as syncHost, i as hostName, n as DEFAULT_UI_PORT, o as removeHostLink, ot as DATA_DIR, st as WriteError } from "./host-BJnrv8xF.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { join } from "node:path";
 import { spawn, spawnSync } from "node:child_process";
@@ -176,7 +176,7 @@ async function launchUi(root, hub, configured, options) {
 	}
 	let server;
 	if (!reuse) {
-		const { serveUi } = await import("./ui-D_9x6XNs.js");
+		const { serveUi } = await import("./ui-CiapFoik.js");
 		server = await serveUi(root, choice.port);
 		writeUiRecord(root, {
 			port: choice.port,

package/dist/launch.js

@@ -1,2 +1,2 @@
-import { a as portCandidates, c as watchHubGone, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, s as startUiInBackground, t as PORT_SPAN } from "./launch-BKKoCyTj.js";
+import { a as portCandidates, c as watchHubGone, i as networkProbe, n as choosePort, o as readUiRecord, r as launchUi, s as startUiInBackground, t as PORT_SPAN } from "./launch-DefacJEL.js";
 export { PORT_SPAN, choosePort, launchUi, networkProbe, portCandidates, readUiRecord, startUiInBackground, watchHubGone };

package/dist/native/mainflow-swap.c

@@ -0,0 +1,67 @@
+// mainflow-swap: exchange two existing paths in one atomic step, for the sync client.
+//
+// The sync client writes a file from the sync server by preparing it beside the target and exchanging the two.
+// After the exchange the old content sits at the prepared path, so a write by another program that landed just
+// before the exchange is still there to read, where a rename would have dropped it. Node has no call for this,
+// hence this helper: macOS renamex_np(RENAME_SWAP), Linux renameat2(RENAME_EXCHANGE).
+//
+// It answers every request on stdin until stdin ends; the client sends one per run (src/swap.ts). Each request is
+// one line, the two paths separated by a tab; each answer is one line on stdout, in order:
+//   ok            the paths were exchanged
+//   missing       one of the paths does not exist
+//   unsupported   the file system cannot exchange paths
+//   err <reason>  any other failure
+// `mainflow-swap --version` prints the version of this protocol, which the client checks before using it.
+
+#define _GNU_SOURCE
+#include <errno.h>
+#include <stdio.h>
+#include <stdlib.h>
+#include <string.h>
+
+#if defined(__APPLE__)
+#ifndef RENAME_SWAP
+#define RENAME_SWAP 0x00000002
+#endif
+int renamex_np(const char *from, const char *to, unsigned int flags);
+static int exchange(const char *a, const char *b) { return renamex_np(a, b, RENAME_SWAP); }
+#elif defined(__linux__)
+#include <fcntl.h>
+#include <sys/syscall.h>
+#include <unistd.h>
+#ifndef RENAME_EXCHANGE
+#define RENAME_EXCHANGE (1 << 1)
+#endif
+// Through syscall() rather than the libc wrapper, which older glibc and musl do not have.
+static int exchange(const char *a, const char *b) { return (int)syscall(SYS_renameat2, AT_FDCWD, a, AT_FDCWD, b, RENAME_EXCHANGE); }
+#else
+#error "mainflow-swap supports macOS and Linux"
+#endif
+
+#define PROTOCOL "mainflow-swap 1"
+
+int main(int argc, char **argv) {
+  if (argc == 2 && strcmp(argv[1], "--version") == 0) {
+    puts(PROTOCOL);
+    return 0;
+  }
+  setvbuf(stdout, NULL, _IOLBF, 0);
+  char *line = NULL;
+  size_t size = 0;
+  ssize_t length;
+  while ((length = getline(&line, &size, stdin)) != -1) {
+    if (length > 0 && line[length - 1] == '\n') line[length - 1] = '\0';
+    char *tab = strchr(line, '\t');
+    if (!tab) {
+      puts("err bad-request");
+      continue;
+    }
+    *tab = '\0';
+    if (exchange(line, tab + 1) == 0) puts("ok");
+    else if (errno == ENOENT) puts("missing");
+    else if (errno == EINVAL || errno == ENOTSUP || errno == EOPNOTSUPP || errno == ENOSYS || errno == EXDEV) puts("unsupported");
+    else printf("err %s\n", strerror(errno));
+  }
+  free(line);
+  return 0;
+}