gnhf 0.1.33 → 0.1.35

package/README.md

@@ -47,6 +47,7 @@ You wake up to a branch full of clean work and a log of everything that happened
 - **Dead simple** — one command starts an autonomous loop that runs until you request stop or a configured runtime cap is reached
 - **Long running** — each iteration is committed on success, rolled back on failure, with sensible retries; retryable hard agent errors back off exponentially while agent-reported failures continue immediately
 - **Live terminal title** — interactive runs keep your terminal title updated with live status, token totals, and commit count, then clear or restore it on exit depending on terminal support; token totals prefixed with `~` are estimates
+- **Exit summary**: every run ends with a permanent summary covering elapsed time, branch, iterations, tokens, branch diff stats, local notes/log paths, and review commands
 - **Agent-agnostic**: works with Claude Code, Codex, Rovo Dev, OpenCode, GitHub Copilot CLI, Pi, or ACP targets out of the box
 
 ## Quick Start
@@ -137,11 +138,12 @@ npm link
                     └──────────────────────────────────────┘
 ```
 
-- **Incremental commits** - each successful iteration is a separate unsigned git commit, so you can cherry-pick or revert individual changes without GPG or SSH signing prompts blocking the run
+- **Incremental commits** - each successful iteration is a separate unsigned git commit, so you can cherry-pick or revert individual changes without GPG or SSH signing prompts blocking the run; if the first commit attempt fails, gnhf re-stages changes and retries with `--no-verify` so hook-mutated work is not stranded
 - **Failure handling** - all failed iterations are rolled back with `git reset --hard`; agent-reported failures proceed to the next iteration immediately, retryable hard agent errors use exponential backoff, and permanent agent errors such as Claude low credit balance abort immediately and print the run log path. Complete no-op iterations are reported as failures and count toward the consecutive-failure abort limit.
 - **Runtime caps** - `--max-iterations` stops before the next iteration begins, `--max-tokens` can abort mid-iteration once reported usage reaches the cap, and `--stop-when` ends the loop after an iteration whose agent output reports the natural-language condition is met; resumed runs reuse the saved stop condition unless you pass a new value, or `--stop-when ""` to clear it; uncommitted work is rolled back in either case, and in the interactive TUI the final state remains visible until you press Ctrl+C to exit
 - **Iteration finalization** - agents are expected to finish validation, stop any background processes they started, and only then emit the final JSON result for the iteration
 - **Graceful interrupts** - in the interactive TUI, the first Ctrl+C requests a graceful stop and lets the current iteration finish (or ends backoff early), the second Ctrl+C force-stops immediately, and `SIGTERM` also force-stops immediately
+- **Exit summary** - after shutdown cleanup, gnhf prints a permanent stdout summary with the final branch, elapsed time, iteration and token totals, branch diff stats, notes/debug-log paths, and review commands
 - **Shared memory** — the agent reads `notes.md` (built up from prior iterations) to communicate across iterations
 - **Local run metadata** — gnhf stores prompt, notes, stop conditions, and commit-message convention metadata under `.gnhf/runs/` and ignores it locally, so your branch only contains intentional work
 - **Resume support** — run `gnhf` while on an existing `gnhf/` branch to pick up where a previous run left off; if you provide a different prompt, gnhf asks whether to update the saved prompt and continue with the existing history, start a new branch, or quit. New runs whose generated branch already exists use a numeric suffix such as `gnhf/<slug>-1`.

package/dist/cli.mjs

@@ -505,18 +505,84 @@ function getBranchCommitCount(baseCommit, cwd) {
 		`${baseCommit}..HEAD`
 	], cwd), 10);
 }
+function emptyBranchDiffStats$1() {
+	return {
+		commits: 0,
+		filesChanged: 0,
+		filesAdded: 0,
+		filesUpdated: 0,
+		filesDeleted: 0,
+		filesRenamed: 0,
+		binaryFiles: 0,
+		linesAdded: 0,
+		linesDeleted: 0
+	};
+}
+function getBranchDiffStats(baseCommit, cwd) {
+	if (!baseCommit) return emptyBranchDiffStats$1();
+	const range = `${baseCommit}..HEAD`;
+	const stats = emptyBranchDiffStats$1();
+	stats.commits = Number.parseInt(git([
+		"rev-list",
+		"--count",
+		"--first-parent",
+		range
+	], cwd), 10);
+	const nameStatus = git([
+		"diff",
+		"--name-status",
+		range
+	], cwd);
+	for (const line of nameStatus.split("\n")) {
+		if (!line) continue;
+		const [status] = line.split("	");
+		stats.filesChanged++;
+		if (status === "A") stats.filesAdded++;
+		else if (status === "D") stats.filesDeleted++;
+		else if (status?.startsWith("R")) {
+			stats.filesUpdated++;
+			stats.filesRenamed++;
+		} else stats.filesUpdated++;
+	}
+	const numstat = git([
+		"diff",
+		"--numstat",
+		range
+	], cwd);
+	for (const line of numstat.split("\n")) {
+		if (!line) continue;
+		const [added, deleted] = line.split("	");
+		if (added === "-" || deleted === "-") {
+			stats.binaryFiles++;
+			continue;
+		}
+		stats.linesAdded += Number.parseInt(added ?? "0", 10) || 0;
+		stats.linesDeleted += Number.parseInt(deleted ?? "0", 10) || 0;
+	}
+	return stats;
+}
 function commitAll(message, cwd) {
+	const commitArgs = [
+		"-c",
+		"commit.gpgsign=false",
+		"-c",
+		"tag.gpgsign=false",
+		"commit",
+		"-m",
+		message
+	];
 	git(["add", "-A"], cwd);
+	let firstError;
 	try {
-		git([
-			"-c",
-			"commit.gpgsign=false",
-			"-c",
-			"tag.gpgsign=false",
-			"commit",
-			"-m",
-			message
-		], cwd);
+		git(commitArgs, cwd);
+		return;
+	} catch (error) {
+		firstError = error;
+	}
+	git(["add", "-A"], cwd);
+	try {
+		git([...commitArgs, "--no-verify"], cwd);
+		appendDebugLog("git:commit:no-verify-fallback", { firstError: serializeError(firstError) });
 	} catch {}
 }
 function resetHard(cwd) {
@@ -16784,6 +16850,158 @@ var Orchestrator = class extends EventEmitter {
 	}
 };
 //#endregion
+//#region src/utils/tokens.ts
+function formatTokens(count) {
+	if (count >= 0xe8d4a51000) return `${(count / 0xe8d4a51000).toFixed(1)}T`;
+	if (count >= 1e9) return `${(count / 1e9).toFixed(1)}B`;
+	if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
+	if (count >= 1e3) return `${Math.round(count / 1e3)}K`;
+	return String(count);
+}
+//#endregion
+//#region src/core/exit-summary.ts
+const MIN_CARD_WIDTH = 62;
+const LABEL_WIDTH = 16;
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+const ANSI_TOKEN_RE = /\x1b\[[0-9;]*m/g;
+const NO_MISTAKES_URL = "https://github.com/kunchenguid/no-mistakes";
+function stripExitSummaryAnsi(text) {
+	return text.replace(ANSI_RE, "");
+}
+function makeStyles(color) {
+	const wrap = (open, text) => color ? `${open}${text}\x1b[0m` : text;
+	return {
+		dim: (text) => wrap("\x1B[2m", text),
+		bold: (text) => wrap("\x1B[1m", text),
+		cyan: (text) => wrap("\x1B[36m", text),
+		yellow: (text) => wrap("\x1B[33m", text),
+		green: (text) => wrap("\x1B[32m", text),
+		red: (text) => wrap("\x1B[31m", text),
+		magenta: (text) => wrap("\x1B[35m", text),
+		blueUnderline: (text) => wrap("\x1B[34;4m", text)
+	};
+}
+function visibleLength(text) {
+	return stripExitSummaryAnsi(text).length;
+}
+function padVisible(text, width) {
+	return text + " ".repeat(Math.max(0, width - visibleLength(text)));
+}
+function truncateVisible(text, width) {
+	if (visibleLength(text) <= width) return text;
+	if (width <= 0) return "";
+	const targetWidth = Math.max(0, width - 1);
+	let output = "";
+	let visible = 0;
+	let index = 0;
+	let hasActiveStyle = false;
+	const finish = () => `${output}…${hasActiveStyle ? "\x1B[0m" : ""}`;
+	for (const match of text.matchAll(ANSI_TOKEN_RE)) {
+		const chunk = text.slice(index, match.index);
+		for (const char of chunk) {
+			if (visible >= targetWidth) return finish();
+			output += char;
+			visible += 1;
+		}
+		output += match[0];
+		hasActiveStyle = match[0] !== "\x1B[0m";
+		index = match.index + match[0].length;
+	}
+	for (const char of text.slice(index)) {
+		if (visible >= targetWidth) return finish();
+		output += char;
+		visible += 1;
+	}
+	return finish();
+}
+function formatDuration(ms) {
+	const totalSeconds = Math.max(0, Math.floor(ms / 1e3));
+	const hours = Math.floor(totalSeconds / 3600);
+	const minutes = Math.floor(totalSeconds % 3600 / 60);
+	const seconds = totalSeconds % 60;
+	if (hours > 0) return `${hours}h ${minutes}m`;
+	if (minutes > 0) return `${minutes}m ${seconds}s`;
+	return `${seconds}s`;
+}
+function formatNumber(value) {
+	return new Intl.NumberFormat("en-US").format(value);
+}
+function formatTokenCount$1(value, suffix, estimated) {
+	return `${estimated ? "~" : ""}${formatTokens(value)} ${suffix}`;
+}
+function plural(value, singular, pluralText = `${singular}s`) {
+	return `${formatNumber(value)} ${value === 1 ? singular : pluralText}`;
+}
+function metricLine(label, columns) {
+	return `  ${padVisible(`${padVisible(label, LABEL_WIDTH)}${columns[0] ?? ""}`, 30)}${padVisible(columns[1] ?? "", 13)}${columns[2] ?? ""}`;
+}
+function commandLine(label, command) {
+	return `  ${padVisible(label, LABEL_WIDTH)}${command}`;
+}
+function continuationLine(text) {
+	return `  ${"".padEnd(LABEL_WIDTH)}${text}`;
+}
+function resolveCardWidth(contents, terminalColumns) {
+	const contentWidth = Math.max(...contents.map(visibleLength));
+	const desiredWidth = Math.max(MIN_CARD_WIDTH, contentWidth + 4);
+	const columns = terminalColumns && terminalColumns > 0 ? terminalColumns : void 0;
+	return Math.max(4, columns ? Math.min(desiredWidth, columns) : desiredWidth);
+}
+function cardBorder(left, right, width, dim) {
+	return dim(`${left}${"─".repeat(Math.max(0, width - 2))}${right}`);
+}
+function cardLine(content, width, dim) {
+	const contentWidth = Math.max(0, width - 4);
+	return `${dim("│ ")}${padVisible(truncateVisible(content, contentWidth), contentWidth)}${dim(" │")}`;
+}
+function renderExitSummary(options) {
+	const s = makeStyles(options.color);
+	const elapsed = formatDuration(options.elapsedMs);
+	const stopped = options.status === "aborted";
+	const title = stopped ? `${s.red("×")} ${s.bold("gnhf stopped")}` : `${s.cyan("✦")} ${s.bold("gnhf wrapped")}`;
+	const subtitle = stopped ? `${s.cyan(options.agentName)} ran for ${s.yellow(elapsed)} before: ${options.abortReason ?? options.status}` : `${s.cyan(options.agentName)} worked for ${s.yellow(elapsed)} on ${s.magenta(options.branchName)}`;
+	const cardWidth = resolveCardWidth([title, `  ${subtitle}`], options.terminalColumns);
+	const rolledBack = `${options.failCount} rolled back`;
+	const inputTokens = formatTokenCount$1(options.totalInputTokens, "in", options.tokensEstimated);
+	const outputTokens = formatTokenCount$1(options.totalOutputTokens, "out", options.tokensEstimated);
+	const commits = plural(options.commitCount, "commit");
+	const linesAdded = `+${formatNumber(options.diffStats.linesAdded)}`;
+	const linesDeleted = `-${formatNumber(options.diffStats.linesDeleted)}`;
+	return `\n${[
+		cardBorder("╭", "╮", cardWidth, s.dim),
+		cardLine(title, cardWidth, s.dim),
+		cardLine(`  ${subtitle}`, cardWidth, s.dim),
+		cardBorder("╰", "╯", cardWidth, s.dim),
+		"",
+		metricLine(s.dim("iterations"), [
+			`${s.bold(String(options.iterations))} total`,
+			s.green(`${options.successCount} good`),
+			stopped ? s.red(rolledBack) : s.yellow(rolledBack)
+		]),
+		metricLine(s.dim("tokens"), [s.bold(inputTokens), s.bold(outputTokens)]),
+		metricLine(s.dim("branch diff"), [
+			s.bold(commits),
+			s.green(linesAdded),
+			s.red(linesDeleted)
+		]),
+		metricLine(s.dim("files"), [
+			`${options.diffStats.filesAdded} added`,
+			`${options.diffStats.filesUpdated} updated`,
+			`${options.diffStats.filesDeleted} deleted`
+		]),
+		"",
+		commandLine(s.dim("notes"), options.notesPath),
+		commandLine(s.dim("debug log"), options.logPath),
+		"",
+		commandLine(s.dim("next steps"), s.cyan(`git log --oneline ${options.baseRef}..HEAD`)),
+		continuationLine(s.cyan(`git diff --stat ${options.baseRef}..HEAD`)),
+		continuationLine(s.cyan("gh pr create")),
+		"",
+		commandLine(s.dim("too much"), `${s.cyan("git push no-mistakes")}:`),
+		commandLine(s.dim("to review?"), s.blueUnderline(NO_MISTAKES_URL))
+	].join("\n")}\n`;
+}
+//#endregion
 //#region src/mock-orchestrator.ts
 function mockIter(n, success, summary, agoMs) {
 	return {
@@ -16997,15 +17215,6 @@ function formatElapsed(ms) {
 	return `${String(Math.floor(s / 3600)).padStart(2, "0")}:${String(Math.floor(s % 3600 / 60)).padStart(2, "0")}:${String(s % 60).padStart(2, "0")}`;
 }
 //#endregion
-//#region src/utils/tokens.ts
-function formatTokens(count) {
-	if (count >= 0xe8d4a51000) return `${(count / 0xe8d4a51000).toFixed(1)}T`;
-	if (count >= 1e9) return `${(count / 1e9).toFixed(1)}B`;
-	if (count >= 1e6) return `${(count / 1e6).toFixed(1)}M`;
-	if (count >= 1e3) return `${Math.round(count / 1e3)}K`;
-	return String(count);
-}
-//#endregion
 //#region src/utils/terminal-width.ts
 const graphemeSegmenter = new Intl.Segmenter(void 0, { granularity: "grapheme" });
 const MARK_REGEX = /\p{Mark}/u;
@@ -17656,6 +17865,22 @@ function getNativeAgentName(spec) {
 function getTelemetryAgent(spec) {
 	return redactAgentSpecForLogs(spec);
 }
+function shouldUseColor() {
+	return process$1.stdout.isTTY === true && process$1.env.NO_COLOR === void 0 && process$1.env.TERM !== "dumb";
+}
+function emptyBranchDiffStats(commitCount) {
+	return {
+		commits: commitCount,
+		filesChanged: 0,
+		filesAdded: 0,
+		filesUpdated: 0,
+		filesDeleted: 0,
+		filesRenamed: 0,
+		binaryFiles: 0,
+		linesAdded: 0,
+		linesDeleted: 0
+	};
+}
 function redactDebugArgs(args) {
 	const redacted = [...args];
 	for (let i = 0; i < redacted.length; i += 1) {
@@ -18135,6 +18360,38 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 	}
 	{
 		const finalState = orchestrator.getState();
+		let finalBranchName = "HEAD";
+		try {
+			finalBranchName = getCurrentBranch(effectiveCwd);
+		} catch (error) {
+			appendDebugLog("summary:branch-error", { error: serializeError(error) });
+		}
+		let diffStats = emptyBranchDiffStats(finalState.commitCount);
+		try {
+			diffStats = getBranchDiffStats(runInfo.baseCommit, effectiveCwd);
+		} catch (error) {
+			appendDebugLog("summary:diff-stats-error", { error: serializeError(error) });
+		}
+		const exitSummary = renderExitSummary({
+			agentName: redactAgentSpecForLogs(config.agent),
+			branchName: finalBranchName,
+			elapsedMs: Date.now() - finalState.startTime.getTime(),
+			status: finalState.status,
+			abortReason: finalState.lastAgentError ?? finalState.lastMessage,
+			iterations: finalState.currentIteration,
+			successCount: finalState.successCount,
+			failCount: finalState.failCount,
+			totalInputTokens: finalState.totalInputTokens,
+			totalOutputTokens: finalState.totalOutputTokens,
+			tokensEstimated: finalState.tokensEstimated,
+			commitCount: finalState.commitCount,
+			notesPath: runInfo.notesPath,
+			logPath: runInfo.logPath,
+			baseRef: runInfo.baseCommit.slice(0, 12) || runInfo.baseCommit,
+			diffStats,
+			color: shouldUseColor(),
+			terminalColumns: process$1.stdout.columns
+		});
 		appendDebugLog("run:complete", {
 			signal: shutdownSignal,
 			status: finalState.status,
@@ -18172,6 +18429,7 @@ program.name("gnhf").description("Before I go to bed, I tell my agents: good nig
 			worktreeCleanup = null;
 			appendDebugLog("worktree:cleaned-up", { worktreePath });
 		}
+		process$1.stdout.write(exitSummary);
 	}
 	if (shutdownSignal) process$1.exit(getSignalExitCode(shutdownSignal));
 });

package/package.json

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