reeval 0.0.1

package/dist/command-D-jnQWVG.js

@@ -0,0 +1,673 @@
+import { t as UsageError } from "./errors-CSxfJ4qu.js";
+import { n as loadEnvFiles, t as inCI } from "./env-BQqj93gu.js";
+import { n as SECRET_NAME } from "./redact-C4fL_bZP.js";
+import { i as PACKAGE_DIR, o as PACKAGE_VERSION } from "./root-CFDjpWuc.js";
+import { a as fromCwd } from "./ids-Bp6ut7ZD.js";
+import { et as run } from "./src-DwwiVLqv.js";
+import { i as configPathFor, l as loadConfig } from "./config-Cuj0kVYj.js";
+import { i as parseAttemptKey, t as attemptDebugDir } from "./files-BLlrhU4-.js";
+import { i as masks, n as readInvocations, o as registerEnvFileValues, s as scrubber } from "./invocations-rXktgSAn.js";
+import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSync } from "node:fs";
+import { homedir, release } from "node:os";
+import { basename, dirname, extname, join, relative, resolve } from "node:path";
+import { execFile } from "node:child_process";
+import { detectAgent } from "std-env";
+import { gzipSync } from "node:zlib";
+const LOG_LINES = 60;
+const TRACE_LINES = 20;
+const TRACE_LINE_CHARS = 500;
+/** `npm_config_user_agent` names the manager that ran `reeval`; else the project's lockfile. */
+function packageManager(env, root) {
+	const agent = /^(npm|pnpm|yarn|bun)\/(\S+)/.exec(env.npm_config_user_agent ?? "");
+	if (agent) return {
+		name: agent[1],
+		version: agent[2],
+		from: "user agent"
+	};
+	const locks = [
+		["pnpm-lock.yaml", "pnpm"],
+		["yarn.lock", "yarn"],
+		["bun.lock", "bun"],
+		["bun.lockb", "bun"],
+		["package-lock.json", "npm"]
+	];
+	for (let dir = root;; dir = dirname(dir)) {
+		const hit = locks.find(([file]) => existsSync(join(dir, file)));
+		if (hit) return {
+			name: hit[1],
+			version: null,
+			from: hit[0]
+		};
+		if (dirname(dir) === dir) return null;
+	}
+}
+/** The config's keys and the kinds it uses; no value, model or path from it. */
+function configShape(config) {
+	const harnesses = new Set(config.harness.map((h) => h.kind));
+	const sandboxes = /* @__PURE__ */ new Set([config.sandbox.kind]);
+	for (const profile of Object.values(config.profiles)) {
+		for (const h of [profile.defaults?.harness ?? []].flat()) harnesses.add(h.kind);
+		if (profile.defaults?.sandbox) sandboxes.add(profile.defaults.sandbox.kind);
+	}
+	return {
+		file: config.file,
+		optionKeys: [...config.optionKeys ?? []].sort(),
+		harnesses: [...harnesses],
+		sandboxes: [...sandboxes],
+		profiles: Object.entries(config.profiles).map(([name, p]) => ({
+			name,
+			keys: Object.keys(p).sort(),
+			defaults: Object.keys(p.defaults ?? {}).sort()
+		}))
+	};
+}
+const tail = (text, n) => text.trimEnd().split("\n").slice(-n);
+const OMITTED_CONFIG = JSON.stringify({
+	kind: "config",
+	omitted: "reeval report leaves the config's values out"
+});
+/** A trace without its `config` entries, which hold the config's values. */
+const withoutConfig = (trace) => trace.split("\n").map((line) => {
+	if (!line.includes("\"kind\":\"config\"")) return line;
+	try {
+		return JSON.parse(line).kind === "config" ? OMITTED_CONFIG : line;
+	} catch {
+		return line;
+	}
+}).join("\n");
+const read = (path) => existsSync(path) ? readFileSync(path, "utf8") : "";
+function filesIn(dir) {
+	if (!existsSync(dir)) return [];
+	return readdirSync(dir, {
+		recursive: true,
+		withFileTypes: true
+	}).filter((e) => e.isFile()).map((e) => relative(dir, join(e.parentPath, e.name)).replaceAll("\\", "/")).sort();
+}
+function failedAttempts(record) {
+	return record.evals.flatMap((e) => e.attempts.filter((a) => a.outcome === "fail" || a.outcome === "infra_error"));
+}
+function attemptSlice(root, runId, attempt) {
+	const key = parseAttemptKey(attempt.key);
+	const dir = key ? attemptDebugDir(root, runId, key.evalId, key.cell, key.n) : "";
+	const requests = tail(read(join(dir, "requests.ndjson")), 500).filter((line) => {
+		try {
+			const r = JSON.parse(line);
+			return r.allowed === false || (r.status ?? 0) >= 400;
+		} catch {
+			return false;
+		}
+	});
+	return {
+		key: attempt.key,
+		outcome: attempt.outcome,
+		error: attempt.error,
+		turnErrors: attempt.turns.flatMap((t) => t.error ? [t.error] : []),
+		debugFiles: dir ? filesIn(dir) : [],
+		debugLog: tail(read(join(dir, "debug.log")), LOG_LINES).filter(Boolean),
+		trace: tail(withoutConfig(read(join(dir, "trace.ndjson"))), TRACE_LINES).filter(Boolean).map((l) => l.length > TRACE_LINE_CHARS ? `${l.slice(0, TRACE_LINE_CHARS)}…` : l),
+		requests: requests.slice(-20)
+	};
+}
+async function findRun(config, ref) {
+	const { allRuns } = await import("./commands-A4udfyKZ.js");
+	const { resolveRun } = await import("./views-CwCWLWqo.js");
+	const { readRecord, scratchDir } = await import("./files--6CEUXm7.js");
+	try {
+		const entry = resolveRun(await allRuns(config), ref);
+		const dir = entry.recorded ? config.history.dir : scratchDir(config.root);
+		return { record: await readRecord(join(dir, `${entry.runId}.json`)) };
+	} catch (error) {
+		return { error: error.message };
+	}
+}
+/** Which command the report is about: the newest one, or with `--last` the newest that failed. */
+function pickInvocation(root, last) {
+	const logged = readInvocations(root).filter((i) => i.command !== "report");
+	return (last ? logged.filter((i) => i.exitCode !== 0) : logged).at(-1) ?? null;
+}
+/** Collects the bundle for `reeval report [run]`, scrubbed; see `ReportDeps` for what it reads. */
+async function collectReport(flags, refs, deps) {
+	const configPath = configPathFor(flags.config);
+	const root = configPath ? dirname(configPath) : deps.cwd;
+	loadEnvFiles(configPath);
+	for (const name of [".env.local", ".env"]) {
+		const contents = read(join(root, name));
+		if (contents) registerEnvFileValues(contents);
+	}
+	const scrub = scrubber({
+		env: deps.env,
+		home: deps.home,
+		project: root
+	});
+	let config;
+	let configError = null;
+	if (configPath) try {
+		config = await loadConfig(configPath, "report");
+	} catch (error) {
+		configError = error.message;
+	}
+	else configError = "no reeval.config.* here or above";
+	const doctor = await deps.doctor({ config: flags.config }).catch((error) => ({ error: error.message }));
+	const invocation = pickInvocation(root, !!flags.last);
+	let run = null;
+	let runError = null;
+	const ref = refs[0] ?? (flags.last && invocation?.runId ? invocation.runId : "latest");
+	const attachments = [];
+	const attachedMasks = {
+		before: 0,
+		after: 0
+	};
+	if (config) {
+		const found = await findRun(config, ref);
+		if ("error" in found) runError = found.error;
+		else {
+			const { record } = found;
+			const failed = failedAttempts(record);
+			const { runOutcome } = await import("./model-v-0_Ik7S.js");
+			run = {
+				runId: record.runId,
+				status: record.status,
+				outcome: runOutcome(record),
+				summary: { ...record.summary },
+				stack: record.stack,
+				failures: failed.slice(0, 5).map((a) => attemptSlice(root, record.runId, a)),
+				moreFailures: Math.max(0, failed.length - 5)
+			};
+			let bytes = 0;
+			for (const attempt of failed) {
+				const key = parseAttemptKey(attempt.key);
+				if (!key) continue;
+				const dir = attemptDebugDir(root, record.runId, key.evalId, key.cell, key.n);
+				for (const file of filesIn(dir)) {
+					const path = join(dir, file);
+					const size = statSync(path).size;
+					if (bytes + size > 20971520) continue;
+					bytes += size;
+					const text = readFileSync(path, "utf8");
+					const kept = file.endsWith("trace.ndjson") ? withoutConfig(text) : text;
+					const scrubbed = scrub.text(kept);
+					attachedMasks.before += masks(kept);
+					attachedMasks.after += masks(scrubbed);
+					attachments.push({
+						path: relative(join(root, ".reeval", "debug"), path).replaceAll("\\", "/"),
+						data: Buffer.from(scrubbed)
+					});
+				}
+			}
+		}
+	}
+	const raw = {
+		kind: "reeval-report",
+		version: 1,
+		createdAt: deps.now().toISOString(),
+		es: PACKAGE_VERSION,
+		node: deps.nodeVersion,
+		npm: await deps.npmVersion(),
+		os: {
+			platform: deps.platform,
+			release: deps.release,
+			arch: deps.arch
+		},
+		packageManager: packageManager(deps.env, root),
+		ci: inCI(deps.env),
+		agent: deps.agent,
+		env: Object.keys(deps.env).filter((name) => name.startsWith("REEVAL_") || SECRET_NAME.test(name)).filter((name) => deps.env[name]).sort(),
+		invocation,
+		doctor,
+		config: config ? configShape(config) : null,
+		configError,
+		run,
+		runError,
+		redaction: {
+			masked: 0,
+			upstream: 0,
+			paths: scrub.paths
+		}
+	};
+	const bundle = scrub.value(raw);
+	const upstream = masks(JSON.stringify(raw)) + attachedMasks.before;
+	bundle.redaction = {
+		masked: masks(JSON.stringify(bundle)) + attachedMasks.after,
+		upstream,
+		paths: scrub.paths
+	};
+	return {
+		bundle,
+		attachments,
+		root,
+		scrub
+	};
+}
+//#endregion
+//#region src/report/issue.ts
+/** GitHub refuses longer new-issue URLs; this leaves room under its ~8 KB limit. */
+const MAX_URL = 8e3;
+/** GitHub's limit on an issue body is 65536 characters. */
+const MAX_BODY = 6e4;
+/** The issue form in `.github/ISSUE_TEMPLATE/`, and the ids of the fields reeval fills. */
+const ISSUE_TEMPLATE = "bug_report.yml";
+const FIELDS = {
+	report: "report",
+	whatHappened: "what-happened"
+};
+const TRUNCATED = "\n\n…cut to fit the URL: attach report.md for the rest.";
+/** The issues page from `bugs` in reeval's package.json, so a rename moves it too. */
+function issueRepo(pkg = JSON.parse(readFileSync(join(PACKAGE_DIR, "package.json"), "utf8"))) {
+	const url = (typeof pkg.bugs === "string" ? pkg.bugs : pkg.bugs?.url)?.replace(/\/+$/, "");
+	if (!url) throw new Error("reeval's package.json has no bugs URL");
+	return {
+		issues: url,
+		slug: /^https:\/\/github\.com\/([^/]+\/[^/]+)\/issues$/.exec(url)?.[1] ?? null
+	};
+}
+function build(repo, title, whatHappened, report) {
+	const params = new URLSearchParams({
+		template: ISSUE_TEMPLATE,
+		title,
+		[FIELDS.whatHappened]: whatHappened,
+		[FIELDS.report]: report
+	});
+	return `${repo.issues}/new?${params.toString().replaceAll("+", "%20")}`;
+}
+/**
+* The new-issue URL with the form's fields filled, at most `max` characters: the report field is
+* cut at a line (and says so) until it fits.
+*/
+function issueUrl(repo, title, report, whatHappened = "", max = MAX_URL) {
+	const full = build(repo, title, whatHappened, report);
+	if (full.length <= max) return full;
+	let lo = 0;
+	let hi = report.length;
+	while (lo < hi) {
+		const mid = Math.ceil((lo + hi) / 2);
+		if (build(repo, title, whatHappened, report.slice(0, mid) + TRUNCATED).length <= max) lo = mid;
+		else hi = mid - 1;
+	}
+	const cut = report.slice(0, lo);
+	const atLine = cut.lastIndexOf("\n");
+	const url = build(repo, title, whatHappened, (atLine > cut.length / 2 ? cut.slice(0, atLine) : cut) + TRUNCATED);
+	if (url.length > max) throw new Error("The issue title alone is too long for a URL");
+	return url;
+}
+const exec = (command, args) => new Promise((resolve) => {
+	execFile(command, args, { timeout: 6e4 }, (error, stdout, stderr) => resolve({
+		code: error ? typeof error.code === "number" ? error.code : 1 : 0,
+		stdout: String(stdout),
+		stderr: String(stderr)
+	}));
+});
+/** gh through reeval's own `run`, which finds it however it's installed on Windows (.exe or .cmd). */
+const gh = (args) => run("gh", args, {
+	signal: AbortSignal.timeout(6e4),
+	detached: false
+}).then((r) => ({
+	code: r.exitCode,
+	stdout: r.stdout,
+	stderr: r.stderr
+}), (error) => ({
+	code: 1,
+	stdout: "",
+	stderr: error.message
+}));
+function defaultIssueDeps() {
+	return {
+		hasGh: async () => (await gh(["--version"])).code === 0,
+		gh,
+		open: async (url) => {
+			const [command, args] = process.platform === "darwin" ? ["open", [url]] : process.platform === "win32" ? ["cmd", [
+				"/c",
+				"start",
+				"\"\"",
+				url.replaceAll("&", "^&")
+			]] : ["xdg-open", [url]];
+			return (await exec(command, args)).code === 0;
+		}
+	};
+}
+/** Files it with gh when gh is there and the user says yes (or `-y`); else the URL. */
+async function fileIssue(o, deps) {
+	if (o.repo.slug && await deps.hasGh()) {
+		if (o.yes || !!o.confirm && await o.confirm(`File this as an issue on ${o.repo.slug} with gh issue create? [y/N] `)) {
+			const r = await deps.gh([
+				"issue",
+				"create",
+				"--repo",
+				o.repo.slug,
+				"--title",
+				o.title,
+				"--body-file",
+				o.bodyFile
+			]);
+			if (r.code === 0) {
+				o.out(`Filed ${r.stdout.trim()}`);
+				return "gh";
+			}
+			o.out(`gh issue create failed (${r.stderr.trim() || `exit ${r.code}`}); use the URL instead.`);
+		}
+	}
+	const url = issueUrl(o.repo, o.title, o.body, o.whatHappened);
+	o.out("Open this to file the issue (pre-filled; nothing is sent until you submit it):");
+	o.out(url);
+	if (o.interactive) await deps.open(url);
+	return "url";
+}
+//#endregion
+//#region src/report/render.ts
+const isDoctor = (value) => !!value && typeof value === "object" && Array.isArray(value.checks);
+const plural = (n, word) => `${n} ${word}${n === 1 ? "" : "s"}`;
+function versionsLine(b) {
+	const pm = b.packageManager;
+	return [
+		`reeval ${b.es}`,
+		`Node ${b.node}`,
+		b.npm ? `npm ${b.npm}` : "no npm",
+		...pm ? [`${pm.name}${pm.version ? ` ${pm.version}` : ""}`] : [],
+		`${b.os.platform} ${b.os.release} ${b.os.arch}`,
+		...b.ci ? ["CI"] : [],
+		...b.agent ? [`agent ${b.agent}`] : []
+	].join(" · ");
+}
+function commandLine(b) {
+	const i = b.invocation;
+	if (!i) return null;
+	return `reeval ${i.argv.join(" ")} → exit ${i.exitCode}${i.runId ? ` (run ${i.runId})` : ""}, ${i.at}`;
+}
+/** The error the report is about: the last command's, else the run's first failure. */
+function headline(b) {
+	const error = b.invocation?.error;
+	if (error) return `${error.name}: ${error.message}`.split("\n")[0];
+	const unhandled = b.invocation?.unhandledErrors[0];
+	if (unhandled) return unhandled.split("\n")[0];
+	const failure = b.run?.failures.find((f) => f.outcome === "infra_error") ?? b.run?.failures[0];
+	if (failure?.error) return `${failure.error.kind}: ${failure.error.message}`.split("\n")[0];
+	return null;
+}
+function runLine(b) {
+	if (!b.run) return b.runError ? `none (${b.runError})` : null;
+	const s = b.run.summary;
+	const parts = [
+		plural(s.attempts ?? 0, "attempt"),
+		`${s.pass ?? 0} pass`,
+		...s.fail ? [`${s.fail} fail`] : [],
+		...s.infraError ? [plural(s.infraError, "infra error")] : [],
+		...s.skipped ? [`${s.skipped} skipped`] : []
+	];
+	return `${b.run.runId}: ${b.run.outcome}, ${parts.join(", ")}`;
+}
+function doctorLine(b) {
+	if (!isDoctor(b.doctor)) return `didn't run (${b.doctor?.error ?? "?"})`;
+	const d = b.doctor;
+	const failing = [...new Set(d.checks.filter((c) => c.status === "fail").map((c) => c.id))];
+	return `${plural(d.problems, "problem")}${failing.length ? ` (${failing.join(", ")})` : ""}, ${plural(d.warnings, "warning")}`;
+}
+function configLine(b) {
+	const c = b.config;
+	if (!c) return `not loaded (${b.configError ?? "?"})`;
+	return [
+		`${c.file}: keys ${c.optionKeys.join(", ") || "none"}`,
+		`harness ${c.harnesses.join(", ")}`,
+		`sandbox ${c.sandboxes.join(", ")}`,
+		c.profiles.length ? `profiles ${c.profiles.map((p) => p.name).join(", ")}` : "no profiles"
+	].join("; ");
+}
+function redactionLine(b) {
+	const paths = ["home → ~", ...b.redaction.paths.includes("<project>") ? ["project → <project>"] : []];
+	const { masked, upstream } = b.redaction;
+	const already = upstream && upstream < masked ? `, ${upstream} of them already by reeval's records and logs` : upstream ? ", all already by reeval's records and logs" : "";
+	return `${plural(masked, "secret value")} masked${already}; ${paths.join(", ")}`;
+}
+/** The terminal summary, one labelled line each. */
+function summaryLines(b, attached) {
+	const rows = [
+		["versions", versionsLine(b)],
+		["command", commandLine(b) ?? "none logged in this project"],
+		["error", headline(b)],
+		["run", runLine(b)],
+		["failing", b.run?.failures.length ? b.run.failures.map((f) => `${f.key}${f.error ? ` (${f.error.kind})` : ""}`).join("; ") + (b.run.moreFailures ? ` and ${b.run.moreFailures} more` : "") : null],
+		["doctor", doctorLine(b)],
+		["config", configLine(b)],
+		["logs", attached ? `${plural(attached, "debug file")} attached` : null],
+		["redacted", redactionLine(b)]
+	];
+	const width = Math.max(...rows.map(([k]) => k.length));
+	return rows.flatMap(([k, v]) => v ? [`${k.padEnd(width)}  ${v}`] : []);
+}
+const fence = (lang, lines) => [
+	"",
+	`\`\`\`${lang}`,
+	...lines,
+	"```"
+];
+function stackLines(b, max = Number.POSITIVE_INFINITY) {
+	const error = b.invocation?.error;
+	if (!error) return [];
+	const lines = (error.stack ?? `${error.name}: ${error.message}`).split("\n");
+	return lines.length > max ? [...lines.slice(0, max), "…"] : lines;
+}
+/** report.md: everything in the bundle, for a person to read and attach. */
+function renderMarkdown(b, attachedFiles) {
+	const out = [
+		"# reeval report",
+		"",
+		`Collected by \`reeval report\` at ${b.createdAt}. ${redactionLine(b)}. Review it before you share it.`,
+		"",
+		"## Environment",
+		"",
+		"| | |",
+		"|---|---|",
+		`| reeval | ${b.es} |`,
+		`| Node | ${b.node} |`,
+		`| npm | ${b.npm ?? "not found"} |`,
+		`| Package manager | ${b.packageManager ? `${b.packageManager.name} ${b.packageManager.version ?? ""} (from ${b.packageManager.from})` : "unknown"} |`,
+		`| OS | ${b.os.platform} ${b.os.release} ${b.os.arch} |`,
+		`| CI | ${b.ci ? "yes" : "no"} |`,
+		`| Coding agent | ${b.agent ?? "none"} |`,
+		`| Variables set | ${b.env.join(", ") || "none"} |`,
+		"",
+		"## Last command",
+		"",
+		b.invocation ? `\`reeval ${b.invocation.argv.join(" ")}\` exited ${b.invocation.exitCode} after ${b.invocation.durationMs} ms, at ${b.invocation.at}${b.invocation.runId ? `, run \`${b.invocation.runId}\`` : ""}.` : "No `reeval` command is logged in this project (`.reeval/cli.jsonl`)."
+	];
+	if (b.invocation?.error) out.push(...fence("text", stackLines(b)));
+	for (const e of b.invocation?.unhandledErrors ?? []) out.push(...fence("text", e.split("\n")));
+	out.push("", "## Run", "");
+	if (!b.run) out.push(b.runError ? `No run: ${b.runError}` : "No run.");
+	else {
+		out.push(`${runLine(b)}, status ${b.run.status}.`);
+		if (b.run.moreFailures) out.push("", `${b.run.moreFailures} more failing attempts aren't shown.`);
+		for (const f of b.run.failures) {
+			out.push("", `### ${f.key}`, "", `Outcome ${f.outcome}.`);
+			if (f.error) out.push(...fence("text", [`${f.error.kind}: ${f.error.message}`]));
+			for (const t of f.turnErrors) out.push(...fence("text", [`turn: ${t}`]));
+			if (f.debugLog.length) out.push("", "debug.log, last lines:", ...fence("text", f.debugLog));
+			if (f.requests.length) out.push("", "Refused or failed gateway requests:", ...fence("json", f.requests));
+			if (f.trace.length) out.push("", "trace.ndjson, last lines:", ...fence("json", f.trace));
+		}
+		out.push("", "### Sandbox and images", ...fence("json", [JSON.stringify(b.run.stack, null, 2)]));
+	}
+	out.push("", "## reeval doctor");
+	if (isDoctor(b.doctor)) out.push(...fence("text", b.doctor.checks.map((c) => `${c.status.padEnd(4)} ${c.id.padEnd(9)} ${c.summary}${c.fix ? ` (fix: ${c.fix})` : ""}`)));
+	else out.push("", doctorLine(b));
+	out.push("", "## Config", "", configLine(b));
+	if (b.config?.profiles.length) {
+		out.push("", "| Profile | Keys | Defaults |", "|---|---|---|");
+		for (const p of b.config.profiles) out.push(`| ${p.name} | ${p.keys.join(", ")} | ${p.defaults.join(", ") || "-"} |`);
+	}
+	if (attachedFiles.length) {
+		out.push("", "## Attached logs", "", "In `report-logs.tar.gz`, by path under `.reeval/debug`:", "");
+		out.push(...attachedFiles.map((f) => `- \`${f}\``));
+	}
+	return `${out.join("\n")}\n`;
+}
+/** The issue's body: what a maintainer reads first; report.md has the rest. */
+function renderIssueBody(b, reportDir) {
+	const out = [
+		`**Environment:** ${versionsLine(b)}`,
+		"",
+		`**Command:** ${b.invocation ? `\`reeval ${b.invocation.argv.join(" ")}\` → exit ${b.invocation.exitCode}` : "none logged"}`
+	];
+	const stack = stackLines(b, 25);
+	if (stack.length) out.push(...fence("text", stack));
+	const run = runLine(b);
+	if (run) out.push("", `**Run:** ${run}`);
+	for (const f of b.run?.failures ?? []) out.push(`- \`${f.key}\`: ${f.error ? `${f.error.kind}: ${f.error.message.split("\n")[0]}` : f.outcome}`);
+	out.push("", `**reeval doctor:** ${doctorLine(b)}`);
+	if (isDoctor(b.doctor)) for (const c of b.doctor.checks.filter((c) => c.status === "fail" || c.status === "warn")) out.push(`- ${c.status} ${c.id}: ${c.summary}`);
+	out.push("", `**Config:** ${configLine(b)}`, "", `_${redactionLine(b)}._`);
+	out.push("", reportDir ? `The full report is in \`${reportDir}\`: attach \`report.md\` (and \`report-logs.tar.gz\`, if it's there) to this issue.` : "Run `reeval report --out <dir>` and attach `report.md` to this issue.");
+	return out.join("\n");
+}
+/** The issue's title, from the error. */
+function issueTitle(b) {
+	const title = `${b.invocation?.command ? `reeval ${b.invocation.command}` : "es"}: ${headline(b) ?? (b.run ? `run ended ${b.run.outcome}` : "bug report")}`;
+	return title.length > 100 ? `${title.slice(0, 99)}…` : title;
+}
+//#endregion
+//#region src/report/tar.ts
+const BLOCK = 512;
+function octal(value, width) {
+	return `${value.toString(8).padStart(width - 1, "0")}\0`;
+}
+/** `path` as ustar's 155-byte prefix and 100-byte name, split on a `/`. */
+function splitPath(path) {
+	if (Buffer.byteLength(path) <= 100) return {
+		prefix: "",
+		name: path
+	};
+	for (let i = path.indexOf("/"); i !== -1; i = path.indexOf("/", i + 1)) {
+		const prefix = path.slice(0, i);
+		const name = path.slice(i + 1);
+		if (Buffer.byteLength(prefix) <= 155 && Buffer.byteLength(name) <= 100) return {
+			prefix,
+			name
+		};
+	}
+	throw new Error(`${path} is too long for a tar entry`);
+}
+function header(path, size, mtime) {
+	const block = Buffer.alloc(BLOCK);
+	const { prefix, name } = splitPath(path);
+	block.write(name, 0);
+	block.write(octal(420, 8), 100);
+	block.write(octal(0, 8), 108);
+	block.write(octal(0, 8), 116);
+	block.write(octal(size, 12), 124);
+	block.write(octal(mtime, 12), 136);
+	block.write(" ".repeat(8), 148);
+	block.write("0", 156);
+	block.write("ustar\0", 257);
+	block.write("00", 263);
+	block.write(prefix, 345);
+	let sum = 0;
+	for (const byte of block) sum += byte;
+	block.write(`${sum.toString(8).padStart(6, "0")}\0 `, 148);
+	return block;
+}
+/** A gzipped ustar archive of regular files, readable by `tar -xzf`. */
+function tarGz(entries, mtime = Math.floor(Date.now() / 1e3)) {
+	const parts = [];
+	for (const { path, data } of entries) {
+		parts.push(header(path, data.length, mtime), data);
+		const pad = (BLOCK - data.length % BLOCK) % BLOCK;
+		if (pad) parts.push(Buffer.alloc(pad));
+	}
+	parts.push(Buffer.alloc(BLOCK * 2));
+	return gzipSync(Buffer.concat(parts));
+}
+//#endregion
+//#region src/report/command.ts
+async function defaultReportDeps() {
+	const { defaultDeps, doctor } = await import("./doctor-CxlH1pDM.js");
+	const doctorDeps = defaultDeps();
+	return {
+		env: process.env,
+		cwd: process.cwd(),
+		home: homedir(),
+		platform: process.platform,
+		release: release(),
+		arch: process.arch,
+		nodeVersion: process.versions.node,
+		npmVersion: () => new Promise((done) => execFile("npm", ["--version"], {
+			shell: process.platform === "win32",
+			timeout: 2e4
+		}, (error, stdout) => done(error ? null : String(stdout).trim()))),
+		doctor: async (flags) => (await doctor(flags, doctorDeps)).report,
+		agent: detectAgent().name ?? null,
+		now: () => /* @__PURE__ */ new Date()
+	};
+}
+const stamp = (date) => date.toISOString().replace(/[-:]/g, "").replace(/\.\d+Z$/, "Z");
+/**
+* Writes report.md, report.json and (with logs) report-logs.tar.gz. `out` is a directory, or a
+* `.md` or `.json` file that the others are written beside.
+*/
+function writeReport(collected, out, attached) {
+	const ext = extname(out).toLowerCase();
+	const asFile = ext === ".md" || ext === ".json";
+	const dir = asFile ? dirname(out) : out;
+	const base = asFile ? basename(out, extname(out)) : "report";
+	mkdirSync(dir, { recursive: true });
+	const markdown = join(dir, `${base}.md`);
+	const json = join(dir, `${base}.json`);
+	writeFileSync(markdown, renderMarkdown(collected.bundle, attached));
+	writeFileSync(json, `${JSON.stringify(collected.bundle, null, 2)}\n`);
+	let logs = null;
+	if (collected.attachments.length) {
+		logs = join(dir, `${base}-logs.tar.gz`);
+		writeFileSync(logs, tarGz(collected.attachments));
+	}
+	return {
+		dir,
+		markdown,
+		json,
+		logs
+	};
+}
+async function reportCommand(flags, refs, io, deps, issueDeps = defaultIssueDeps()) {
+	if (flags.json && flags.issue) throw new UsageError("reeval report --json prints the bundle; --issue files it. Pick one.");
+	const collected = await collectReport(flags, refs, deps ?? await defaultReportDeps());
+	const { bundle, attachments, root } = collected;
+	const attached = attachments.map((a) => a.path);
+	if (flags.json) {
+		io.out(JSON.stringify(bundle, null, 2));
+		if (flags.out) {
+			const w = writeReport(collected, resolve(flags.out), attached);
+			io.err(`Wrote ${files(w)}`);
+		}
+		return 0;
+	}
+	const written = writeReport(collected, resolve(flags.out ?? join(root, ".reeval", "reports", stamp(new Date(bundle.createdAt)))), attached);
+	io.out("reeval report");
+	for (const line of summaryLines(bundle, attached.length)) io.out(line);
+	io.out("");
+	io.out(`Wrote ${files(written)}`);
+	if (!flags.issue) {
+		io.out("Nothing was uploaded. Review the files, then file it with reeval report --issue.");
+		return 0;
+	}
+	const body = renderIssueBody(bundle, collected.scrub.text(written.dir));
+	const bodyFile = join(written.dir, "issue.md");
+	writeFileSync(bodyFile, body.length > 6e4 ? `${body.slice(0, MAX_BODY)}\n…` : body);
+	await fileIssue({
+		repo: issueRepo(),
+		title: issueTitle(bundle),
+		body,
+		bodyFile,
+		whatHappened: "",
+		confirm: io.confirm,
+		yes: !!flags.yes,
+		interactive: io.interactive,
+		out: io.out
+	}, issueDeps);
+	return 0;
+}
+const rel = (path) => fromCwd(path) || path;
+const files = (w) => [
+	w.markdown,
+	w.json,
+	...w.logs ? [w.logs] : []
+].map(rel).join(", ");
+//#endregion
+export { reportCommand };
+
+//# sourceMappingURL=command-D-jnQWVG.js.map