gnhf 0.1.36 → 0.1.38

package/README.md

@@ -159,6 +159,7 @@ Pass `--current-branch` to run on the branch you are already on instead of creat
 Pass `--push` to push the current branch after each successful iteration.
 Together, `--current-branch --push` is useful for loose projects where you want a deployed or locally watched branch to update throughout the run.
 
+- Re-running the same prompt with `--current-branch` resumes the existing `.gnhf/runs/<runId>/` history on a clean working tree and continues iteration numbering.
 - Push failures abort the run after preserving the successful local commit.
 - gnhf never force-pushes or auto-pulls for this mode.
 - `--push` also works with the default `gnhf/` branch mode and sets `origin` as the upstream when needed.
@@ -203,6 +204,7 @@ If you run `gnhf` on an existing `gnhf/` branch with a different prompt, gnhf as
 | `--worktree`             | Run in a separate git worktree (enables multiple agents concurrently)                                  | `false`                |
 | `--current-branch`       | Run on the current branch instead of creating a `gnhf/` branch                                         | `false`                |
 | `--push`                 | Push the current branch after each successful iteration                                                | `false`                |
+| `--meteor-frequency <n>` | Set TUI meteor frequency from 0 to 5 (`0` disables meteors)                                            | `3`                    |
 | `--version`              | Show version                                                                                           |                        |
 
 ## Configuration
@@ -275,7 +277,7 @@ You can also pass a raw custom ACP server command directly as a quoted `acp:` sp
 
 - Omit it to keep the default `gnhf <iteration>: <summary>` format.
 - Set `preset: conventional` to ask the agent for `type` and optional `scope`, then commit as `type(scope): summary` for semantic-release style workflows. Valid types are `build`, `ci`, `docs`, `feat`, `fix`, `perf`, `refactor`, `test`, and `chore`; invalid or missing types fall back to `chore`, and empty scopes are omitted.
-- The resolved commit-message convention is saved per run, so resuming a `gnhf/` branch keeps the original subject format even if `config.yml` changes later.
+- The resolved commit-message convention is saved per run, so resuming keeps the original subject format even if `config.yml` changes later.
 
 ### Custom Agent Paths
 

package/dist/cli.mjs

@@ -17287,6 +17287,7 @@ const STAR_CHARS = [
 	"°",
 	"°"
 ];
+const MIN_METEOR_START_GAP_MS = 500;
 function generateStarField(width, height, density, seed) {
 	const stars = [];
 	let s = seed;
@@ -17321,6 +17322,47 @@ function getStarState(star, now) {
 	if (t > .025) return "bright";
 	return "dim";
 }
+function generateMeteorShower(width, height, count, seed) {
+	if (width <= 0 || height <= 0 || count <= 0) return [];
+	const meteors = [];
+	let s = seed % 2147483647;
+	if (s <= 0) s += 2147483646;
+	const rand = () => {
+		s = s * 16807 % 2147483647;
+		return s / 2147483647;
+	};
+	for (let i = 0; i < count; i++) {
+		const length = Math.min(height, 2 + (i + Math.floor(rand() * 6)) % 6);
+		const xMax = Math.max(1, width - length);
+		const yMin = Math.max(0, length - 1);
+		const yMaxExclusive = Math.max(yMin + 1, Math.ceil(height * .75));
+		const ySpan = Math.max(1, yMaxExclusive - yMin);
+		const period = 16e3 + rand() * 2e4;
+		const duration = count >= 8 ? 3e3 + rand() * 600 : 900 + rand() * 500;
+		meteors.push({
+			x: Math.floor(rand() * xMax),
+			y: yMin + Math.floor(rand() * ySpan),
+			length,
+			phase: i === 0 ? 0 : i * (MIN_METEOR_START_GAP_MS + 80) + rand() * 60,
+			period,
+			duration
+		});
+	}
+	return meteors;
+}
+function getMeteorTrail(meteor, now) {
+	const cycleTime = ((now - meteor.phase) % meteor.period + meteor.period) % meteor.period;
+	if (cycleTime >= meteor.duration) return [];
+	const step = Math.floor(cycleTime / 120);
+	const cells = [];
+	for (let i = 0; i < meteor.length; i++) cells.push({
+		x: meteor.x - step + i,
+		y: meteor.y + step - i,
+		state: i === 0 ? "bright" : "dim",
+		char: "╱"
+	});
+	return cells;
+}
 //#endregion
 //#region src/utils/moon.ts
 const MOON_PHASES = [
@@ -17544,6 +17586,8 @@ const CONTENT_WIDTH = 63;
 const MAX_PROMPT_LINES = 3;
 const BASE_CONTENT_ROWS = 24;
 const STAR_DENSITY = .035;
+const DEFAULT_METEOR_FREQUENCY = 3;
+const METEOR_SEED_OFFSET = 101;
 const TICK_MS = 200;
 const MOONS_PER_ROW = 30;
 const MOON_PHASE_PERIOD = 1600;
@@ -17647,6 +17691,17 @@ function starStyle(state) {
 	if (state === "dim") return "dim";
 	return "normal";
 }
+function meteorCountForFrequency(frequency) {
+	if (frequency <= 0) return 0;
+	if (frequency === 1) return 1;
+	if (frequency === 2) return 2;
+	if (frequency === 3) return 4;
+	if (frequency === 4) return 6;
+	return 28;
+}
+function meteorsStartingBefore(meteors, rowOffset, maxStartRow) {
+	return meteors.filter((meteor) => rowOffset + meteor.y < maxStartRow);
+}
 function placeStarsInCells(cells, stars, row, xMin, xMax, xOffset, now) {
 	for (const star of stars) {
 		if (star.y !== row || star.x < xMin || star.x >= xMax) continue;
@@ -17663,15 +17718,28 @@ function placeStarsInCells(cells, stars, row, xMin, xMax, xOffset, now) {
 		};
 	}
 }
-function renderStarLineCells(stars, width, y, now) {
+function placeMeteorsInCells(cells, meteors, row, xMin, xMax, xOffset, now) {
+	for (const meteor of meteors) for (const trail of getMeteorTrail(meteor, now)) {
+		if (trail.y !== row || trail.x < xMin || trail.x >= xMax) continue;
+		const localX = trail.x - xOffset;
+		cells[localX] = {
+			char: trail.char,
+			style: trail.state === "bright" ? "bold" : "dim",
+			width: 1
+		};
+	}
+}
+function renderStarLineCells(stars, meteors, width, y, now) {
 	const cells = emptyCells(width);
 	placeStarsInCells(cells, stars, y, 0, width, 0, now);
+	placeMeteorsInCells(cells, meteors, y, 0, width, 0, now);
 	return cells;
 }
-function renderSideStarsCells(stars, rowIndex, xOffset, sideWidth, now) {
+function renderSideStarsCells(stars, meteors, rowIndex, xOffset, sideWidth, now) {
 	if (sideWidth <= 0) return [];
 	const cells = emptyCells(sideWidth);
 	placeStarsInCells(cells, stars, rowIndex, xOffset, xOffset + sideWidth, xOffset, now);
+	placeMeteorsInCells(cells, meteors, rowIndex, xOffset, xOffset + sideWidth, xOffset, now);
 	return cells;
 }
 function clampCellsToWidth(content, width) {
@@ -17788,7 +17856,7 @@ function buildContentCells(prompt, agentName, state, elapsed, now, availableHeig
 	}
 	return rows;
 }
-function buildFrameCells(prompt, agentName, state, topStars, bottomStars, sideStars, now, terminalWidth, terminalHeight) {
+function buildFrameCells(prompt, agentName, state, topStars, bottomStars, sideStars, now, terminalWidth, terminalHeight, topMeteors = [], bottomMeteors = [], sideMeteors = []) {
 	const elapsed = formatElapsed(now - state.startTime.getTime());
 	const availableHeight = Math.max(0, terminalHeight - 2);
 	const contentRows = buildContentCells(prompt, agentName, state, elapsed, now, availableHeight);
@@ -17797,20 +17865,24 @@ function buildFrameCells(prompt, agentName, state, topStars, bottomStars, sideSt
 	const remaining = Math.max(0, availableHeight - contentCount);
 	const topHeight = Math.max(0, Math.ceil(remaining / 2));
 	const bottomHeight = remaining - topHeight;
+	const maxMeteorStartRow = Math.ceil(availableHeight * .75);
+	const visibleTopMeteors = meteorsStartingBefore(topMeteors, 0, maxMeteorStartRow);
+	const visibleSideMeteors = meteorsStartingBefore(sideMeteors, topHeight, maxMeteorStartRow);
+	const visibleBottomMeteors = meteorsStartingBefore(bottomMeteors, topHeight + contentCount, maxMeteorStartRow);
 	const sideWidth = Math.max(0, Math.floor((terminalWidth - CONTENT_WIDTH) / 2));
 	const frame = [];
-	for (let y = 0; y < topHeight; y++) frame.push(renderStarLineCells(topStars, terminalWidth, y, now));
+	for (let y = 0; y < topHeight; y++) frame.push(renderStarLineCells(topStars, visibleTopMeteors, terminalWidth, y, now));
 	for (let i = 0; i < contentRows.length; i++) {
-		const left = renderSideStarsCells(sideStars, i, 0, sideWidth, now);
+		const left = renderSideStarsCells(sideStars, visibleSideMeteors, i, 0, sideWidth, now);
 		const center = centerLineCells(contentRows[i], CONTENT_WIDTH);
-		const right = renderSideStarsCells(sideStars, i, terminalWidth - sideWidth, sideWidth, now);
+		const right = renderSideStarsCells(sideStars, visibleSideMeteors, i, terminalWidth - sideWidth, sideWidth, now);
 		frame.push([
 			...left,
 			...center,
 			...right
 		]);
 	}
-	for (let y = 0; y < bottomHeight; y++) frame.push(renderStarLineCells(bottomStars, terminalWidth, y, now));
+	for (let y = 0; y < bottomHeight; y++) frame.push(renderStarLineCells(bottomStars, visibleBottomMeteors, terminalWidth, y, now));
 	frame.push(renderResumeHintCells(terminalWidth, state.interruptHint));
 	frame.push(emptyCells(terminalWidth));
 	return frame;
@@ -17826,8 +17898,11 @@ var Renderer = class {
 	topStars = [];
 	bottomStars = [];
 	sideStars = [];
+	topMeteors = [];
+	bottomMeteors = [];
 	cachedWidth = 0;
 	cachedHeight = 0;
+	meteorFrequency;
 	prevCells = [];
 	prevTitle = null;
 	titleSaved = false;
@@ -17846,11 +17921,12 @@ var Renderer = class {
 	handleStopped = () => {
 		this.stop("stopped");
 	};
-	constructor(orchestrator, prompt, agentName, onInterrupt) {
+	constructor(orchestrator, prompt, agentName, onInterrupt, options = {}) {
 		this.orchestrator = orchestrator;
 		this.prompt = prompt;
 		this.agentName = agentName;
 		this.onInterrupt = onInterrupt;
+		this.meteorFrequency = Math.max(0, Math.floor(options.meteorFrequency ?? DEFAULT_METEOR_FREQUENCY));
 		this.state = orchestrator.getState();
 		this.seedTop = Math.floor(Math.random() * 2147483646) + 1;
 		this.seedBottom = Math.floor(Math.random() * 2147483646) + 1;
@@ -17903,6 +17979,7 @@ var Renderer = class {
 			const availableHeight = Math.max(0, h - 2);
 			const remaining = Math.max(0, availableHeight - BASE_CONTENT_ROWS);
 			const topHeight = Math.max(0, Math.ceil(remaining / 2));
+			const bottomHeight = Math.max(0, remaining - topHeight);
 			const proximityRows = 8;
 			const shrinkBig = (s, nearContentRow) => {
 				if (!nearContentRow || s.x < contentStart || s.x >= contentEnd) return s;
@@ -17918,6 +17995,8 @@ var Renderer = class {
 			this.topStars = generateStarField(w, h, STAR_DENSITY, this.seedTop).map((s) => shrinkBig(s, s.y >= topHeight - proximityRows));
 			this.bottomStars = generateStarField(w, h, STAR_DENSITY, this.seedBottom).map((s) => shrinkBig(s, s.y < proximityRows));
 			this.sideStars = generateStarField(w, Math.max(BASE_CONTENT_ROWS, availableHeight), STAR_DENSITY, this.seedSide);
+			this.topMeteors = generateMeteorShower(w, topHeight, topHeight > 0 ? meteorCountForFrequency(this.meteorFrequency) : 0, this.seedTop + METEOR_SEED_OFFSET);
+			this.bottomMeteors = generateMeteorShower(w, bottomHeight, bottomHeight > 0 ? meteorCountForFrequency(this.meteorFrequency) : 0, this.seedBottom + METEOR_SEED_OFFSET);
 			return true;
 		}
 		return false;
@@ -17928,7 +18007,7 @@ var Renderer = class {
 		const h = process$1.stdout.rows || 24;
 		const resized = this.ensureStarFields(w, h);
 		this.updateTerminalTitle(now);
-		const nextCells = buildFrameCells(this.prompt, this.agentName, this.state, this.topStars, this.bottomStars, this.sideStars, now, w, h);
+		const nextCells = buildFrameCells(this.prompt, this.agentName, this.state, this.topStars, this.bottomStars, this.sideStars, now, w, h, this.topMeteors, this.bottomMeteors);
 		if (this.isFirstFrame || resized) {
 			process$1.stdout.write("\x1B[H" + nextCells.map(rowToString).join("\n"));
 			this.isFirstFrame = false;
@@ -17959,6 +18038,7 @@ function slugifyPrompt(prompt) {
 //#region src/cli.ts
 const packageVersion = JSON.parse(readFileSync(new URL("../package.json", import.meta.url), "utf-8")).version;
 const FORCE_EXIT_TIMEOUT_MS = 5e3;
+const MAX_METEOR_FREQUENCY = 5;
 const GNHF_REEXEC_STDIN_PROMPT = "GNHF_REEXEC_STDIN_PROMPT";
 const GNHF_REEXEC_STDIN_PROMPT_FILE = "GNHF_REEXEC_STDIN_PROMPT_FILE";
 const GNHF_REEXEC_STDIN_PROMPT_DIR_PREFIX = "gnhf-stdin-";
@@ -17977,6 +18057,11 @@ function parseNonNegativeInteger(value) {
 	if (!Number.isSafeInteger(parsed)) throw new InvalidArgumentError("must be a safe integer");
 	return parsed;
 }
+function parseMeteorFrequency(value) {
+	const parsed = parseNonNegativeInteger(value);
+	if (parsed > MAX_METEOR_FREQUENCY) throw new InvalidArgumentError(`must be between 0 and ${MAX_METEOR_FREQUENCY}`);
+	return parsed;
+}
 function parseOnOffBoolean(value) {
 	if (value === "on" || value === "true") return true;
 	if (value === "off" || value === "false") return false;
@@ -18053,10 +18138,19 @@ function initializeNewBranch(prompt, cwd, schemaOptions) {
 	const runId = createBranchWithSuffix(slugifyPrompt(prompt), cwd).split("/")[1];
 	return setupRun(runId, prompt, baseCommit, cwd, schemaOptions);
 }
+function promptRunId(prompt) {
+	return slugifyPrompt(prompt).split("/")[1];
+}
+function resumeCurrentBranchRun(prompt, cwd, schemaOptions) {
+	const runId = promptRunId(prompt);
+	if (!existsSync(join(cwd, ".gnhf", "runs", runId))) return null;
+	ensureCleanWorkingTree(cwd);
+	return resumeRun(runId, cwd, schemaOptions);
+}
 function initializeCurrentBranchRun(prompt, cwd, schemaOptions) {
 	ensureCleanWorkingTree(cwd);
 	const baseCommit = getHeadCommit(cwd);
-	return setupRun(createRunIdWithSuffix(slugifyPrompt(prompt).split("/")[1], cwd), prompt, baseCommit, cwd, schemaOptions);
+	return setupRun(createRunIdWithSuffix(promptRunId(prompt), cwd), prompt, baseCommit, cwd, schemaOptions);
 }
 function branchNameWithSuffix(branchName, suffix) {
 	return suffix === 0 ? branchName : `${branchName}-${suffix}`;
@@ -18264,13 +18358,13 @@ function readReexecStdinPrompt(env) {
 	}
 }
 const program = new Command();
-program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", `Agent to use (${AGENT_NAMES.join(", ")}, or acp:<target-or-command>)`).option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--stop-when <condition>", "End when the agent reports this condition, after any commit-failure repair; resumes reuse it, pass a new value to overwrite or \"\" to clear").option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--worktree", "Run in a separate git worktree (enables multiple agents on the same repo)", false).option("--current-branch", "Run on the current branch instead of creating a gnhf branch", false).option("--push", "Push the current branch after each successful iteration", false).option("--mock", "", false).action(async (promptArg, options) => {
+program.name("gnhf").description("Before I go to bed, I tell my agents: good night, have fun").version(packageVersion).argument("[prompt]", "The objective for the coding agent").option("--agent <agent>", `Agent to use (${AGENT_NAMES.join(", ")}, or acp:<target-or-command>)`).option("--max-iterations <n>", "Abort after N total iterations", parseNonNegativeInteger).option("--max-tokens <n>", "Abort after N total input+output tokens", parseNonNegativeInteger).option("--stop-when <condition>", "End when the agent reports this condition, after any commit-failure repair; resumes reuse it, pass a new value to overwrite or \"\" to clear").option("--prevent-sleep <mode>", "Prevent system sleep during the run (\"on\" or \"off\")", parseOnOffBoolean).option("--worktree", "Run in a separate git worktree (enables multiple agents on the same repo)", false).option("--current-branch", "Run on the current branch instead of creating a gnhf branch", false).option("--push", "Push the current branch after each successful iteration", false).option("--meteor-frequency <n>", "Meteor frequency from 0 to 5 (0 disables, 3 is default)", parseMeteorFrequency, 3).option("--mock", "", false).action(async (promptArg, options) => {
 	if (options.mock) {
 		const mock = new MockOrchestrator();
 		enterAltScreen();
-		const renderer = new Renderer(mock, "let's minimize app startup latency without sacrificing any functionality", "claude", () => {
+		const renderer = new Renderer(mock, "let's minimize app startup latency without sacrificing any functionality", "codex", () => {
 			mock.handleInterrupt();
-		});
+		}, { meteorFrequency: options.meteorFrequency });
 		renderer.start();
 		mock.start();
 		await renderer.waitUntilExit();
@@ -18358,7 +18452,14 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			program.help();
 			return;
 		}
-		runInfo = initializeCurrentBranchRun(prompt, cwd, schemaOptions);
+		const existing = resumeCurrentBranchRun(prompt, cwd, buildResumeSchemaOptions(options.stopWhen, effectiveCommitMessage));
+		if (existing) {
+			runInfo = existing;
+			effectiveStopWhen = existing.stopWhen;
+			effectiveCommitMessage = existing.commitMessage;
+			schemaOptions = buildSchemaOptions(effectiveStopWhen, effectiveCommitMessage);
+			startIteration = getLastIterationNumber(existing);
+		} else runInfo = initializeCurrentBranchRun(prompt, cwd, schemaOptions);
 	} else if (onGnhfBranch) {
 		const existingRunId = currentBranch.slice(5);
 		const existingMetadata = peekRunMetadata(existingRunId, cwd);
@@ -18487,7 +18588,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 		requestForceShutdown("SIGTERM");
 	};
 	enterAltScreen();
-	const renderer = new Renderer(orchestrator, prompt, config.agent, handleSigInt);
+	const renderer = new Renderer(orchestrator, prompt, config.agent, handleSigInt, { meteorFrequency: options.meteorFrequency });
 	renderer.start();
 	process$1.on("SIGINT", handleSigInt);
 	process$1.on("SIGTERM", handleSigTerm);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "gnhf",
-  "version": "0.1.36",
+  "version": "0.1.38",
   "description": "Before I go to bed, I tell my agents: good night, have fun",
   "type": "module",
   "bin": {