@raresportan/marram 0.2.1 → 0.2.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@raresportan/marram",
-  "version": "0.2.1",
+  "version": "0.2.3",
   "description": "The gate, ratchet lints and journeys that keep agent-written code from drifting.",
   "license": "MIT",
   "type": "module",

package/src/core/config.mjs

@@ -6,6 +6,7 @@
 //       progress: /lines from a stage worth showing as it runs/,   // besides ✓ and ✗ lines
 //       sleepGapMs: 30000,   // how long a pause counts as the machine sleeping, so a stage that failed runs again
 //       tiers: { fast: [stage, …], default: [stage, …], full: [stage, …] },  // stage: { name, run: [command, …args], env? }
+//       prePush: "full",   // the gate a push must pass (marram hook pre-push): "default" unless set
 //     },
 //     review: { classes: "the mistake-classes doc", rungs: ["type", "lint", …] },
 //   };

package/src/core/gate-state.mjs

@@ -78,9 +78,23 @@ export function updateState(cwd, change) {
 	});
 }
 
-/** `{ passed, stage?, log?, at }` for a tree the default or full gate passed, or failed less than 15 minutes ago. */
-export function verdictOf(cwd, tree) {
-	const verdict = readState(cwd).trees[tree];
-	if (verdict === undefined || verdict.passed) return verdict;
-	return Date.now() - verdict.at < FAILURE_TTL_MS ? verdict : undefined;
+/**
+ * `{ passed, tier, stage?, log?, at }` for a tree `tier` (the default gate, or the full one) passed, or failed less than
+ * 15 minutes ago. A full pass counts for the default gate.
+ */
+export function verdictOf(cwd, tree, tier = "default") {
+	const trees = readState(cwd).trees;
+	const own = current(trees[verdictKey(tree, tier)]);
+	// The full gate runs every default stage, so its pass answers for the default gate too.
+	if (own === undefined && tier === "default" && trees[verdictKey(tree, "full")]?.passed) return trees[verdictKey(tree, "full")];
+	return own;
 }
+
+/** A verdict that still counts: a pass, or a failure from the last FAILURE_TTL_MS. */
+const current = (verdict) => (verdict === undefined || verdict.passed || Date.now() - verdict.at < FAILURE_TTL_MS ? verdict : undefined);
+
+/**
+ * Where a tier's verdict on `tree` is kept: the default gate's under the tree, the full gate's beside it, so a default run
+ * after a full pass doesn't replace it.
+ */
+export const verdictKey = (tree, tier) => (tier === "full" ? `${tree}:full` : tree);

package/src/core/gate.mjs

@@ -12,7 +12,7 @@ import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
 import { mkdir, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
-import { treeOf, updateState } from "./gate-state.mjs";
+import { treeOf, updateState, verdictKey } from "./gate-state.mjs";
 
 const TIERS = ["fast", "default", "full"];
 
@@ -77,7 +77,7 @@ export async function gate(root, config, [tier = "default"]) {
 	// A fast pass doesn't make a change done, so only the default and full gates record a verdict.
 	const tree = tier === "fast" ? undefined : treeOf(root);
 	const verdict = (passed, extra = {}) => {
-		if (tree !== undefined) updateState(root, (state) => { state.trees[tree] = { passed, tier, at: Date.now(), ...extra }; });
+		if (tree !== undefined) updateState(root, (state) => { state.trees[verdictKey(tree, tier)] = { passed, tier, at: Date.now(), ...extra }; });
 	};
 
 	console.log(`Gate (${tier}). Logs: ${dir}`);

package/src/core/hook.mjs

@@ -1,5 +1,6 @@
 // Runs the gate where work is declared done, so nothing finishes or ships while it's red. Usage:
-//   marram hook pre-push      git's pre-push hook: what's pushed must have passed.
+//   marram hook pre-push      git's pre-push hook: what's pushed must have passed `gate.prePush`, the default gate
+//                           unless that names "full".
 //   marram hook claude-turn   Claude Code's UserPromptSubmit: notes the code a turn starts from.
 //   marram hook claude-stop   Claude Code's Stop: a turn that changed code ends only once the gate passes, sent back at
 //                           most 3 times a turn.
@@ -15,16 +16,16 @@ const MAX_SENT_BACK = 3;
 const MARRAM = join(import.meta.dirname, "..", "..", "bin", "marram.mjs");
 const stdin = () => readFileSync(0, "utf8");
 
-/** The gate's verdict on `tree`, running the default gate when there is none. `show` sends its progress to the terminal. */
-async function judge(root, tree, show) {
-	const known = verdictOf(root, tree);
+/** `tier`'s verdict on `tree`, running that gate when there is none. `show` sends its progress to the terminal. */
+async function judge(root, tree, show, tier = "default") {
+	const known = verdictOf(root, tree, tier);
 	if (known !== undefined) return { ...known, reused: true };
-	const gate = spawn(process.execPath, [MARRAM, "gate"], { cwd: root, stdio: ["ignore", show ? "inherit" : "ignore", "inherit"] });
+	const gate = spawn(process.execPath, [MARRAM, "gate", ...(tier === "default" ? [] : [tier])], { cwd: root, stdio: ["ignore", show ? "inherit" : "ignore", "inherit"] });
 	// A hook that's killed (its timeout) passes it on, so the gate can stop what it started.
 	for (const signal of ["SIGINT", "SIGTERM", "SIGHUP"]) process.once(signal, () => gate.kill(signal));
 	await new Promise((done) => gate.once("close", done));
 	// A gate that changed files as it ran records no pass; it counts as failed with no stage.
-	return verdictOf(root, tree) ?? { passed: false };
+	return verdictOf(root, tree, tier) ?? { passed: false };
 }
 
 /** What an agent is told when the gate fails: where it failed, and the end of that stage's log. */
@@ -45,19 +46,24 @@ function failure(verdict) {
 	].join("\n");
 }
 
-async function prePush(root) {
+async function prePush(root, config) {
+	const tier = config.gate?.prePush ?? "default";
+	if (tier !== "default" && tier !== "full") {
+		console.error(`gate.prePush is "${tier}": a push can require the default gate or the full one.`);
+		process.exit(1);
+	}
 	// stdin: one line per ref pushed, "<local ref> <local sha> <remote ref> <remote sha>".
 	for (const line of stdin().split("\n").filter(Boolean)) {
 		const [ref, sha] = line.split(" ");
 		if (/^0+$/.test(sha)) continue; // a deletion
 		const tree = git(root, ["rev-parse", `${sha}^{tree}`]);
-		if (verdictOf(root, tree)?.passed) continue;
+		if (verdictOf(root, tree, tier)?.passed) continue;
 		if (treeOf(root) !== tree) {
-			console.error(`${ref} hasn't passed the gate, and the working tree isn't that commit, so it can't be checked here.\nCommit or stash your changes, check it out and push again (or \`git push --no-verify\` to skip the gate).`);
+			console.error(`${ref} hasn't passed the ${tier} gate, and the working tree isn't that commit, so it can't be checked here.\nCommit or stash your changes, check it out and push again (or \`git push --no-verify\` to skip the gate).`);
 			process.exit(1);
 		}
-		console.error(`Gating ${ref} before it's pushed (\`git push --no-verify\` skips this).`);
-		const verdict = await judge(root, tree, true);
+		console.error(`Gating ${ref} (the ${tier} gate) before it's pushed (\`git push --no-verify\` skips this).`);
+		const verdict = await judge(root, tree, true, tier);
 		if (!verdict.passed) {
 			console.error(failure(verdict));
 			process.exit(1);
@@ -105,10 +111,10 @@ async function finish(root) {
 
 const modes = { "pre-push": prePush, "claude-turn": claudeTurn, "claude-stop": claudeStop, finish };
 
-export async function hook(root, _config, [mode]) {
+export async function hook(root, config, [mode]) {
 	if (!(mode in modes)) {
 		console.error(`Usage: marram hook ${Object.keys(modes).join(" | ")}`);
 		process.exit(1);
 	}
-	await modes[mode](root);
+	await modes[mode](root, config);
 }

package/src/react/keyed.ts

@@ -1,19 +1,25 @@
-import { useCallback, useRef, useState } from "react";
+import { useCallback, useReducer } from "react";
+
+type Value<T> = T | ((previous: T) => T);
 
 /**
  * State that belongs to a key (a watch's parameters, a file, a document): under another key it reads as `initial`, so
  * nothing shows the last key's value while the new key's loads, not even for the one render an effect resetting it
  * would leave. Set it with the key the value is for, or with an update of that key's value; a late answer for a key
- * that's gone reads as `initial` too.
+ * that's gone is dropped, so it can't take the place of the current key's value. A key says only what a value is for:
+ * two requests under one key can still answer out of order, so a caller that re-reads puts a version or try in the key.
  */
-export function useKeyed<T>(key: string, initial: T): [T, (forKey: string, value: T | ((previous: T) => T)) => void] {
-	const [held, setHeld] = useState<{ key: string; value: T }>({ key, value: initial });
-	const first = useRef(initial);
-	const set = useCallback((forKey: string, value: T | ((previous: T) => T)) => {
-		setHeld((last) => {
-			const previous = last.key === forKey ? last.value : first.current;
-			return { key: forKey, value: typeof value === "function" ? (value as (previous: T) => T)(previous) : value };
-		});
-	}, []);
+export function useKeyed<T>(key: string, initial: T): [T, (forKey: string, value: Value<T>) => void] {
+	// Written inline because React runs a reducer in the render an update lands in: this one sees that render's key, which
+	// `set`, called from a promise or a listener, can't know.
+	const [held, apply] = useReducer(
+		(last: { key: string; value: T }, { forKey, value }: { forKey: string; value: Value<T> }) => {
+			if (forKey !== key) return last;
+			const previous = last.key === key ? last.value : initial;
+			return { key, value: typeof value === "function" ? (value as (previous: T) => T)(previous) : value };
+		},
+		{ key, value: initial },
+	);
+	const set = useCallback((forKey: string, value: Value<T>) => apply({ forKey, value }), []);
 	return [held.key === key ? held.value : initial, set];
 }