@raresportan/marram 0.1.0 → 0.2.1

package/package.json

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

package/src/core/boundaries.mjs

@@ -4,8 +4,11 @@
 // A project names its layers by folder pattern (`features/*/client`, `*` being one folder). A file may import from its
 // own layer and from the layers it lists. It may reach another feature (`features/<name>`) only through an `index.ts`:
 // the feature's own, or that of one of its sides, as an app's main process needs its host and its renderer its client,
-// and one index for both would pull the host into the renderer. Only a layer with `builtins: true` may import `node:` modules or `electron`. Existing violations go on a
-// ratchet list, by `file -> import`.
+// and one index for both would pull the host into the renderer. An index only opens the feature: the side it belongs
+// to must still be a layer the file may import. A file in no layer, such as a feature's own index, is no way around
+// that: importing it counts as importing what it imports. Only a layer with `builtins: true` may import Node's modules,
+// as `node:fs` or `fs`, or `electron`. Existing violations go on a ratchet list, by `file -> import`.
+import { isBuiltin } from "node:module";
 import { dirname, relative, resolve, sep } from "node:path";
 import ts from "typescript";
 import { lineOf, parse, ratchet, sourceFiles } from "./ratchet.mjs";
@@ -31,21 +34,36 @@ const featureOf = (path) => /^(features\/[^/]+)(\/|$)/.exec(path)?.[1];
 /** A feature's way in: its folder's `index.ts`, or the `index.ts` of one of its sides (`host/index.ts`, `client/index.ts`). */
 const isEntry = (target, feature) => target === feature || /^features\/[^/]+(\/[^/]+)?\/index(\.tsx?)?$/.test(target);
 
-const isBuiltin = (specifier) => specifier === "electron" || specifier.startsWith("node:");
+const needsHost = (specifier) => /^electron(\/|$)/.test(specifier) || specifier.startsWith("node:") || isBuiltin(specifier);
 
-/** What's wrong with `from` (a path from the folder) importing `specifier`, if anything. */
-function problem(from, specifier, layers) {
-	const mine = layerOf(from, layers);
-	if (isBuiltin(specifier)) return layers[mine?.pattern]?.builtins === true || mine === undefined ? undefined : `${mine.pattern} may not import ${specifier}, which needs a host`;
+/** The source file an import's target (a path from the folder) means, however it's spelled, if it's one of `sources`. */
+const fileOf = (target, sources) => [target, target.replace(/\.jsx?$/, ".ts"), target.replace(/\.jsx?$/, ".tsx"), `${target}.ts`, `${target}.tsx`, `${target}/index.ts`, `${target}/index.tsx`].find((path) => sources.has(path));
+
+/** What's wrong with `from` (a path from the folder) importing `specifier`, if anything, for a file in the layer `mine`. */
+function problem(from, specifier, layers, sources, mine = layerOf(from, layers), seen = new Set()) {
+	if (needsHost(specifier)) return layers[mine?.pattern]?.builtins === true || mine === undefined ? undefined : `${mine.pattern} may not import ${specifier}, which needs a host`;
 	if (!specifier.startsWith(".")) return undefined;
 	const target = posix(relative(".", resolve(dirname(from), specifier)));
 	const theirFeature = featureOf(target);
-	if (theirFeature !== undefined && theirFeature !== featureOf(from)) return isEntry(target, theirFeature) ? undefined : `reaches inside ${theirFeature}: import an index.ts`;
+	if (theirFeature !== undefined && theirFeature !== featureOf(from) && !isEntry(target, theirFeature)) return `reaches inside ${theirFeature}: import an index.ts`;
 	const theirs = layerOf(target, layers);
-	if (mine === undefined || theirs === undefined || theirs.pattern === mine.pattern) return undefined;
+	if (mine === undefined) return undefined;
+	if (theirs === undefined) return throughFile(fileOf(target, sources), layers, sources, mine, seen);
+	if (theirs.pattern === mine.pattern) return undefined;
 	return (layers[mine.pattern].may ?? []).includes(theirs.pattern) ? undefined : `${mine.pattern} may not import from ${theirs.pattern}`;
 }
 
+/** What's wrong with a file in the layer `mine` importing `file`, which is in no layer: the first of `file`'s imports it may not have. */
+function throughFile(file, layers, sources, mine, seen) {
+	if (file === undefined || seen.has(file)) return undefined;
+	seen.add(file);
+	for (const specifier of imports(parse(sources.get(file)))) {
+		const wrong = problem(file, specifier.text, layers, sources, mine, seen);
+		if (wrong !== undefined) return `${wrong} (through ${file})`;
+	}
+	return undefined;
+}
+
 /** Import specifiers in `source`, including `export … from` and `import()`, each with its node; types count too. */
 function imports(source) {
 	const found = [];
@@ -64,11 +82,13 @@ function imports(source) {
  */
 export function importBoundaries({ root, folder, layers, allowed = {}, list }) {
 	const base = resolve(root, folder);
-	const found = sourceFiles(base).flatMap((file) => {
+	const files = sourceFiles(base);
+	const sources = new Map(files.map((file) => [posix(relative(base, file)), file]));
+	const found = files.flatMap((file) => {
 		const source = parse(file);
 		const from = posix(relative(base, file));
 		return imports(source).flatMap((specifier) => {
-			const wrong = problem(from, specifier.text, layers);
+			const wrong = problem(from, specifier.text, layers, sources);
 			return wrong === undefined ? [] : [{ key: `${from} -> ${specifier.text}`, at: `${folder}/${from}:${lineOf(source, specifier)}`, what: wrong }];
 		});
 	});

package/src/core/config.mjs

@@ -4,6 +4,7 @@
 //     gate: {
 //       logs: "where each run's logs go",
 //       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? }
 //     },
 //     review: { classes: "the mistake-classes doc", rungs: ["type", "lint", …] },

package/src/core/gate.mjs

@@ -5,10 +5,12 @@
 //   full      The default gate and more (a build, the slow journeys). Before merging UI work, or nightly.
 // What each tier runs is the project's: `gate.tiers` in marram.config.mjs. Stages run in order and the first failure
 // stops the gate. Each stage's output is kept in its own log under `gate.logs`/gate-<tier>-<time>/, with report.json.
+// A stage that fails after the machine slept during it runs again: timeouts ran out and frames stopped while it slept,
+// so that failure says nothing about the code. A pause counts as sleep past `gate.sleepGapMs`, 30 seconds by default.
 // The default and full gates record their verdict for the working tree (gate-state.mjs), which the hooks reuse.
 import { spawn } from "node:child_process";
 import { createWriteStream } from "node:fs";
-import { mkdir, writeFile } from "node:fs/promises";
+import { mkdir, rename, writeFile } from "node:fs/promises";
 import { join } from "node:path";
 import { treeOf, updateState } from "./gate-state.mjs";
 
@@ -19,7 +21,7 @@ export async function gate(root, config, [tier = "default"]) {
 		console.error(`Unknown gate "${tier}". Usage: marram gate [fast | full]`);
 		process.exit(1);
 	}
-	const { logs, progress, tiers } = config.gate;
+	const { logs, progress, tiers, sleepGapMs = 30_000 } = config.gate;
 	const dir = join(root, logs, `gate-${tier}-${new Date().toISOString().replace(/[:.]/g, "-")}`);
 	await mkdir(dir, { recursive: true });
 	const report = { tier, startedAt: new Date().toISOString(), stages: [], passed: false };
@@ -50,16 +52,26 @@ export async function gate(root, config, [tier = "default"]) {
 		child.stdout.on("data", (chunk) => {
 			for (const line of chunk.toString().split("\n")) if (/^\s*[✓✗]/.test(line) || progress?.test(line)) console.log(`  ${name}: ${line.trim()}`);
 		});
+		let last = Date.now();
+		let slept = 0;
+		const noticeSleep = () => {
+			const gap = Date.now() - last;
+			last += gap;
+			if (gap > sleepGapMs) slept += gap;
+		};
+		const clock = setInterval(noticeSleep, 1000);
 		const code = await new Promise((done) => {
 			child.on("error", () => done(1));
 			child.on("exit", (exit) => done(exit ?? 1));
 		});
+		clearInterval(clock);
+		noticeSleep();
 		log.end();
 		const seconds = Math.round((Date.now() - started) / 1000);
 		report.stages.push({ name, code, seconds });
 		await writeFile(join(dir, "report.json"), JSON.stringify(report, null, 2));
 		console.log(`${code === 0 ? "✓" : "✗"} ${name} (${seconds}s)${code === 0 ? "" : `: see ${join(dir, `${name}.log`)}`}`);
-		return code === 0;
+		return { passed: code === 0, slept };
 	}
 
 	// A fast pass doesn't make a change done, so only the default and full gates record a verdict.
@@ -70,7 +82,12 @@ export async function gate(root, config, [tier = "default"]) {
 
 	console.log(`Gate (${tier}). Logs: ${dir}`);
 	for (const stage of tiers[tier]) {
-		const passed = await runStage(stage);
+		let { passed, slept } = await runStage(stage);
+		while (!passed && slept > 0 && !interrupted) {
+			console.log(`  The machine slept for ${Math.round(slept / 1000)}s during ${stage.name}, so its failure says nothing about the code. Running it again.`);
+			await rename(join(dir, `${stage.name}.log`), join(dir, `${stage.name}-slept.log`));
+			({ passed, slept } = await runStage(stage));
+		}
 		if (interrupted) {
 			console.log(`\nGate interrupted at ${stage.name}.`);
 			process.exit(1);