@augurworks/augur 0.15.1

package/scripts/status.mjs

@@ -0,0 +1,177 @@
+// status.mjs — "what is live, and is it what I have?"
+//
+//   augur status            every space this checkout can see
+//   … --fetch               ask each remote for its current main first
+//
+// This is the command that would have ended a whole evening. Space content ships by
+// publishing, not by pushing, so work can be committed, pushed, reviewed and still
+// not be on the site — and nothing about the repo tells you that. This puts the
+// three numbers side by side: what the store is serving, what your clone has, and
+// what the remote has.
+//
+// Reads /_build.json (public, cache-busted) plus plain git in each space clone. No
+// token needed.
+
+import { execFileSync } from "node:child_process";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import path from "node:path";
+import { resolveOrigin, resolveToken, apiClient, buildStamp, ENGINE_ROOT } from "./lib/store.mjs";
+import { fetchMarks, markLine } from "./lib/marks.mjs";
+import { registryList, unitClient, draftsReport } from "./lib/draft.mjs";
+
+const args = process.argv.slice(2);
+const DO_FETCH = args.includes("--fetch");
+const log = (msg) => console.error(`\x1b[36m[status]\x1b[0m ${msg}`);
+
+const C = { dim: "\x1b[2m", red: "\x1b[31m", yellow: "\x1b[33m", green: "\x1b[32m", off: "\x1b[0m" };
+
+const origin = resolveOrigin();
+if (!origin) { log('no target origin — set AUGUR_ORIGIN, or add "siteOrigin" to space.json.'); process.exit(1); }
+
+const git = (dir, ...a) => {
+  try {
+    return execFileSync("git", ["-C", dir, ...a], { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"] }).trim();
+  } catch (e) { return ""; }
+};
+
+// Space clones, found the same way build.js and publish.mjs find them: siblings of
+// the engine, the shell's spaces/ mount, or the cwd itself.
+function findSpaceDirs() {
+  const roots = [];
+  if (process.env.GV_SPACES_ROOT) roots.push(process.env.GV_SPACES_ROOT);
+  roots.push(path.join(ENGINE_ROOT, ".."), path.join(ENGINE_ROOT, "spaces"));
+  const out = new Map();
+  if (existsSync(path.join(process.cwd(), "space.json"))) out.set(idOf(process.cwd()), process.cwd());
+  for (const root of roots) {
+    let entries = [];
+    try { entries = readdirSync(root, { withFileTypes: true }); } catch (e) { continue; }
+    for (const e of entries) {
+      if (!e.isDirectory() || e.name.startsWith(".")) continue;
+      const dir = path.join(root, e.name);
+      if (!existsSync(path.join(dir, "space.json"))) continue;
+      const id = idOf(dir);
+      if (!out.has(id)) out.set(id, dir);
+    }
+  }
+  return out;
+}
+function idOf(dir) {
+  try { return JSON.parse(readFileSync(path.join(dir, "space.json"), "utf8")).id || path.basename(dir); }
+  catch (e) { return path.basename(dir); }
+}
+
+const stamp = await buildStamp(origin);
+const clones = findSpaceDirs();
+const ids = [...new Set([...Object.keys(stamp.spaces || {}), ...clones.keys()])].sort();
+
+console.log(`${C.dim}${origin}${C.off}`);
+console.log("");
+
+let problems = 0;
+for (const id of ids) {
+  const liveInfo = (stamp.spaces || {})[id];
+  const dir = clones.get(id);
+  const head = dir ? git(dir, "rev-parse", "HEAD") : "";
+  const localDirty = dir ? git(dir, "status", "--porcelain").length > 0 : false;
+  if (dir && DO_FETCH) git(dir, "fetch", "--quiet", "origin");
+  const remote = dir ? git(dir, "rev-parse", "origin/main") : "";
+  // Direction matters and a plain inequality doesn't carry it: a clone can be
+  // ahead of the remote (work nobody else can see) or behind it (work you
+  // haven't got yet), and telling someone to pull when they need to push sends
+  // them the wrong way.
+  const [ahead, behind] = dir && remote
+    ? git(dir, "rev-list", "--left-right", "--count", `${head}...${remote}`).split(/\s+/).map(Number)
+    : [0, 0];
+
+  const short = (s) => (s ? s.slice(0, 12) : "—");
+  const bits = [];
+  let verdict, colour;
+
+  if (!liveInfo) {
+    verdict = "never published"; colour = C.red; problems++;
+  } else if (liveInfo.dirty) {
+    verdict = "published from a working tree"; colour = C.red; problems++;
+  } else if (!dir) {
+    verdict = "live (no local clone to compare)"; colour = C.dim;
+  } else if (liveInfo.sha === head && !localDirty && !ahead && !behind) {
+    verdict = "live matches your clone"; colour = C.green;
+  } else if (localDirty) {
+    verdict = "uncommitted changes — run `augur ship`"; colour = C.yellow; problems++;
+  } else if (liveInfo.sha !== head && !behind) {
+    verdict = "your clone is AHEAD of live — run `augur ship`"; colour = C.yellow; problems++;
+  } else if (ahead) {
+    verdict = `${ahead} commit(s) only on this machine — run \`augur ship\``; colour = C.yellow; problems++;
+  } else if (behind) {
+    verdict = `${behind} commit(s) waiting on the remote — pull, then ship`; colour = C.yellow; problems++;
+  } else {
+    verdict = "live matches your clone"; colour = C.green;
+  }
+
+  if (liveInfo) {
+    bits.push(`live ${short(liveInfo.sha)}${liveInfo.version ? ` v${liveInfo.version}` : ""}`);
+    if (liveInfo.publishedBy) bits.push(`by ${liveInfo.publishedBy}`);
+  }
+  if (dir) bits.push(`local ${short(head)}${localDirty ? "*" : ""}`);
+  if (remote && remote !== head) bits.push(`origin/main ${short(remote)}`);
+
+  console.log(`  ${colour}${id.padEnd(16)}${verdict}${C.off}`);
+  console.log(`  ${C.dim}${" ".repeat(16)}${bits.join("  ·  ")}${C.off}`);
+}
+
+const eng = stamp.engine || {};
+console.log("");
+console.log(`  ${C.dim}engine chrome    ${eng.sha ? eng.sha.slice(0, 12) : "—"}` +
+  `${eng.version ? ` (v${eng.version})` : ""}${eng.publishedAt ? `  ·  shipped ${eng.publishedAt}` : ""}${C.off}`);
+
+// ── who is working where, right now ─────────────────────────────────────────
+//
+// `F-presence-marks`. The three numbers above answer "is what I have what is live"; they
+// cannot answer "is somebody else in here", and that is the question that decides whether
+// the next hour of work is going to be merged or forked.
+//
+// NEEDS A TOKEN and does not ask for one. `status` has always been the command that runs
+// with nothing configured — the build stamp is public — so a missing credential quietly
+// costs the marks section and nothing else. It affects the exit code in no way: marks
+// refuse nothing, and a mark is not a problem.
+const markToken = resolveToken(origin);
+if (markToken) {
+  const marks = await fetchMarks(apiClient(origin, markToken));
+  if (marks.length) {
+    console.log("");
+    console.log(`  ${C.dim}being worked on right now${C.off}`);
+    for (const m of marks) console.log(`  ${C.dim}  ${markLine(m)}${C.off}`);
+  }
+} else {
+  // The one thing a fresh agent needs to know and has no other way to learn: this machine
+  // holds no token, and the way to get one is pairing, not a password. Same words as the
+  // instance's own /llms.txt. Costs nothing here — status never needed the token.
+  console.log("");
+  console.log(`  ${C.dim}not paired with ${origin}. Publishing from here needs a token; get one without a password:${C.off}`);
+  console.log(`  ${C.dim}  augur connect --origin ${origin}   (the owner approves a code in a signed-in browser)${C.off}`);
+}
+
+// ── drafts open on this machine (docs/drafts-that-land.md §4) ────────────────
+// Read from the machine's registry, so it costs nothing; who else is on each unit is asked
+// of the instance when a token is at hand, and the report stands without it.
+{
+  const mine = registryList().filter((e) => !e.readOnly);
+  if (mine.length) {
+    console.log("");
+    console.log(`  ${C.dim}drafts open on this machine${C.off}`);
+    const presence = {};
+    for (const unit of new Set(mine.map((e) => e.unit))) {
+      const e = mine.find((x) => x.unit === unit);
+      const tok = resolveToken(e.origin);
+      if (!tok) continue;
+      try {
+        const p = await unitClient({ origin: e.origin, token: tok, space: "", session: "" }).presence(unit);
+        if (p && p.drafts) presence[unit] = p.drafts;
+      } catch (e2) { /* the report stands without presence */ }
+    }
+    for (const line of draftsReport(mine, presence)) console.log(`  ${C.dim}  ${line}${C.off}`);
+  }
+}
+
+// Exit code is the answer, so this can gate a script: 0 = everything live is what
+// its clone says it should be.
+process.exit(problems ? 1 : 0);

package/scripts/sync.mjs

@@ -0,0 +1,27 @@
+#!/usr/bin/env node
+// augur sync — fold what landed on main since this draft opened into the draft. One-sided
+// changes are taken; a file changed on both sides is merged where the lines do not overlap
+// and left to you where they do (theirs is written under .augur/theirs/). Nothing is guessed.
+import { resolveOrigin, resolveToken } from "./lib/store.mjs";
+import { readState, unitClient, doSync, THEIRS_DIR } from "./lib/draft.mjs";
+
+const log = (m) => console.error(`\x1b[35m[sync]\x1b[0m ${m}`);
+const die = (m) => { console.error(`\x1b[31m[sync]\x1b[0m ${m}`); process.exit(1); };
+const dir = process.cwd();
+const st = readState(dir);
+if (!st) die("not a draft folder — run `augur open <prototype>` first.");
+const origin = st.origin || resolveOrigin();
+const token = resolveToken(origin);
+if (!token) die("no publish token — run `augur connect` once.");
+const client = unitClient({ origin, token, space: st.space, session: st.session });
+const r = await doSync({ client, dir });
+if (!r.ok) die(`sync refused: ${r.error || r.status}`);
+for (const f of r.taken) log(`took theirs   ${f}`);
+for (const f of r.merged) log(`merged        ${f}`);
+for (const c of r.conflicts) {
+  log(`OVERLAP       ${c.rel} — yours stays in place, theirs is at ${THEIRS_DIR}/${c.rel}`);
+  for (const h of c.hunks) log(`  lines ${h.baseStart + 1}-${h.baseEnd}: yours ${JSON.stringify(h.mine.join("\n")).slice(0, 80)} · theirs ${JSON.stringify(h.theirs.join("\n")).slice(0, 80)}`);
+}
+log(`draft now based on revision ${r.mainRevision}${r.conflicts.length ? " — fold the overlaps in, check the draft address, then land" : " — check the draft address, then land"}`);
+console.log(`${origin}${st.address}`);
+if (r.conflicts.length) process.exit(2);