@kitschpatrol/chagent 0.0.0-stage → 0.1.0

package/dist/bin/cli.js

@@ -0,0 +1,184 @@
+#!/usr/bin/env node
+import { C as version, S as maxTimeoutMs, b as defaultModels, i as generateChangelog, l as agentNames, n as previewChangelog, r as reviewChangelog, s as writeChangelog, t as assertReviewTerminal, u as efforts, x as defaults, y as setLogger } from "../review-LYSADnul.js";
+import { n as assertAmendable, t as amendRelease } from "../lib-CXMRRbJf.js";
+import { t as createProgressLine } from "../progress-DQtRnH1N.js";
+import { createLogger } from "lognow";
+import path from "node:path";
+import yargs from "yargs";
+import { hideBin } from "yargs/helpers";
+
+// src/bin/cli.ts
+/**
+* Route library output: a timer on a terminal, plain lines otherwise or when
+* verbose.
+*/
+function createReporter(verbose, signal) {
+	const progress = !verbose && process.stderr.isTTY ? createProgressLine(process.stderr) : void 0;
+	signal.addEventListener("abort", () => {
+		progress?.stop();
+	}, { once: true });
+	const logDetail = (...args) => {
+		if (progress === void 0) console.error(...args);
+	};
+	const logDebug = (...args) => {
+		if (verbose) console.error(...args);
+	};
+	const logProblem = (...args) => {
+		progress?.clear();
+		console.error(...args);
+	};
+	setLogger(createLogger({
+		logToConsole: {
+			colorize: process.stderr.isTTY === true,
+			getTerminalWidth: () => process.stderr.isTTY ? process.stderr.columns : Number.MAX_SAFE_INTEGER,
+			logger: {
+				debug: logDebug,
+				error: logProblem,
+				info: logDetail,
+				trace: logDebug,
+				warn: logProblem
+			},
+			showLevel: verbose,
+			showName: false,
+			showTime: verbose
+		},
+		name: "chagent",
+		verbose: true
+	}));
+	return {
+		report(message) {
+			progress?.update(message);
+		},
+		async track(work) {
+			progress?.start("Reading repository history.");
+			try {
+				return await work();
+			} finally {
+				progress?.stop();
+			}
+		}
+	};
+}
+const controller = new AbortController();
+for (const signal of [
+	"SIGHUP",
+	"SIGINT",
+	"SIGTERM"
+]) process.once(signal, () => {
+	controller.abort();
+});
+const cli = yargs(hideBin(process.argv));
+try {
+	await cli.scriptName("chagent").command("$0", "Initialize or update changelogs from repository history.", (command) => command.option("cwd", {
+		default: process.cwd(),
+		defaultDescription: "current directory",
+		description: "Repository directory",
+		type: "string"
+	}).option("agent", {
+		choices: agentNames,
+		defaultDescription: defaults.agent,
+		description: "Installed agent CLI",
+		type: "string"
+	}).option("model", {
+		defaultDescription: `${defaultModels.codex} (Codex); ${defaultModels.claude} (Claude)`,
+		description: "Agent model",
+		type: "string"
+	}).option("effort", {
+		choices: efforts,
+		defaultDescription: defaults.effort,
+		description: "Reasoning effort",
+		type: "string"
+	}).option("interactive", {
+		alias: "i",
+		default: false,
+		description: "Review a diff and optionally edit before writing",
+		type: "boolean"
+	}).option("editor", {
+		defaultDescription: "git var GIT_EDITOR",
+		description: "Editor command for interactive review; configure GUI editors to wait",
+		type: "string"
+	}).option("dry-run", {
+		default: false,
+		description: "Print a diff without applying changes",
+		type: "boolean"
+	}).option("rebuild", {
+		default: false,
+		description: "Reconstruct all history, replacing existing release text",
+		type: "boolean"
+	}).option("amend", {
+		default: false,
+		description: "Amend a verified unpublished release commit and matching local tags",
+		type: "boolean"
+	}).option("github", {
+		defaultDescription: String(defaults.github),
+		description: "Enrich Git evidence using gh when available; disable with --no-github",
+		type: "boolean"
+	}).option("cache", {
+		defaultDescription: String(defaults.cache),
+		description: "Cache drafts and incremental state; disable with --no-cache",
+		type: "boolean"
+	}).option("config", {
+		defaultDescription: "auto-detected from repository root",
+		description: "Configuration file path",
+		type: "string"
+	}).option("timeout", {
+		defaultDescription: String(defaults.timeoutMs / 1e3),
+		description: "Agent timeout in seconds",
+		type: "number"
+	}).option("verbose", {
+		default: false,
+		description: "Log commands, cache decisions, and session details to stderr",
+		type: "boolean"
+	}).check((args) => {
+		if (args.timeout !== void 0 && (!Number.isFinite(args.timeout) || args.timeout <= 0 || args.timeout * 1e3 > 2147483647)) throw new Error(`--timeout must be a positive number of seconds, up to ${Math.floor(maxTimeoutMs / 1e3)}.`);
+		return true;
+	}), async (args) => {
+		if (!args.dryRun && args.interactive) assertReviewTerminal();
+		if (!args.dryRun && args.amend) await assertAmendable(args.cwd);
+		const reporter = createReporter(args.verbose, controller.signal);
+		let plan = await reporter.track(async () => generateChangelog({
+			agent: args.agent,
+			cache: args.cache,
+			configFile: args.config,
+			cwd: args.cwd,
+			effort: args.effort,
+			github: args.github,
+			model: args.model,
+			onProgress(message) {
+				reporter.report(message);
+			},
+			rebuild: args.rebuild,
+			signal: controller.signal,
+			timeoutMs: args.timeout === void 0 ? void 0 : args.timeout * 1e3
+		}));
+		try {
+			if (args.dryRun) {
+				process.stdout.write(await previewChangelog(plan));
+				return;
+			}
+			if (args.interactive) {
+				const reviewed = await reviewChangelog(plan, { editor: args.editor });
+				if (reviewed === void 0) {
+					process.stderr.write("Changelog review cancelled.\n");
+					process.exitCode = 1;
+					return;
+				}
+				plan = reviewed;
+			}
+			if (args.amend) await amendRelease(plan);
+			else await writeChangelog(plan);
+		} finally {
+			for (const diagnostic of plan.diagnostics) process.stderr.write(diagnostic + "\n");
+		}
+		process.stderr.write(plan.files.length === 0 ? "Changelogs are up to date.\n" : `Updated ${plan.files.map((file) => path.relative(plan.root, file.path)).join(", ")}.\n`);
+	}).alias("h", "help").version(version).alias("v", "version").help().strict().fail((message, error, instance) => {
+		if (error !== void 0) throw error;
+		instance.showHelp();
+		throw new Error(message);
+	}).wrap(process.stdout.isTTY ? Math.min(120, cli.terminalWidth()) : 0).parse();
+} catch (error) {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exitCode = 1;
+}
+
+export {  };

package/dist/lib/bumpp.d.ts

@@ -0,0 +1,14 @@
+import { u as GenerateOptions } from "../types-Cms1Tu5k.js";
+import { VersionBumpOptions } from "bumpp";
+type ExecuteHook = Exclude<NonNullable<VersionBumpOptions['execute']>, string>;
+export type BumppHookOptions = Omit<GenerateOptions, 'cwd' | 'release'> & {
+  editor?: string;
+  interactive?: boolean;
+};
+/**
+ * Generate changelogs inside bumpp's execute phase and include only their
+ * files. Progress and diagnostics go to stderr, unless `onProgress` is given to
+ * handle status messages.
+ */
+export declare function createBumppHook(options?: BumppHookOptions): ExecuteHook;
+export {};

package/dist/lib/bumpp.js

@@ -0,0 +1,72 @@
+import { g as git, i as generateChangelog, m as localDate, r as reviewChangelog, s as writeChangelog, t as assertReviewTerminal } from "../review-LYSADnul.js";
+import { t as createProgressLine } from "../progress-DQtRnH1N.js";
+
+// src/lib/bumpp.ts
+const TAG_TOKEN = /\{(version|oldVersion|tag|releaseType|major|minor|patch|date)\}/gv;
+/** Mirror bumpp's tag rendering, which it does not export. */
+function tagName(template, version, oldVersion, releaseType = "") {
+	if (template === void 0) return;
+	const [major = "", minor = "", patch = ""] = version.split("-", 1)[0].split(".", 3);
+	const tokens = {
+		date: localDate(),
+		major,
+		minor,
+		oldVersion,
+		patch,
+		releaseType,
+		tag: "",
+		version
+	};
+	const rendered = template.replaceAll(TAG_TOKEN, (_match, key) => tokens[key]);
+	if (rendered !== template) return rendered;
+	return template.includes("%s") ? template.replaceAll("%s", () => version) : template + version;
+}
+/**
+* Generate changelogs inside bumpp's execute phase and include only their
+* files. Progress and diagnostics go to stderr, unless `onProgress` is given to
+* handle status messages.
+*/
+function createBumppHook(options = {}) {
+	const { editor, interactive, onProgress, ...generateOptions } = options;
+	return async (operation) => {
+		if (interactive === true) assertReviewTerminal();
+		const progress = onProgress === void 0 && process.stderr.isTTY ? createProgressLine(process.stderr) : void 0;
+		progress?.start("Reading repository history.");
+		let plan;
+		try {
+			plan = await generateChangelog({
+				...generateOptions,
+				cwd: operation.options.cwd,
+				onProgress: onProgress ?? ((message) => {
+					if (progress === void 0) process.stderr.write(`${message}\n`);
+					else progress.update(message);
+				}),
+				release: {
+					tag: tagName(operation.options.tag?.name, operation.state.newVersion, operation.state.currentVersion, operation.state.release),
+					version: operation.state.newVersion
+				}
+			});
+		} finally {
+			progress?.stop();
+		}
+		try {
+			if (interactive === true) {
+				const reviewed = await reviewChangelog(plan, { editor });
+				if (reviewed === void 0) throw new Error("Changelog review cancelled. The release has not been committed or tagged.");
+				plan = reviewed;
+			}
+			const files = await writeChangelog(plan);
+			if (files.length === 0) return;
+			await git(plan.root, [
+				"add",
+				"--",
+				...files
+			]);
+			operation.update({ updatedFiles: [.../* @__PURE__ */ new Set([...operation.state.updatedFiles, ...files])] });
+		} finally {
+			for (const diagnostic of plan.diagnostics) process.stderr.write(`${diagnostic}\n`);
+		}
+	};
+}
+
+export { createBumppHook };

package/dist/lib/index.d.ts

@@ -0,0 +1,31 @@
+import { _ as Config, a as ChangeSet, c as Evidence, d as GenerationRequest, f as GenerationResponse, g as RunSettings, h as ReleaseSummary, i as Change, l as FileEdit, m as ReleaseRequest, n as AgentName, o as ChangelogPlan, p as ReleaseContext, r as Category, s as Effort, t as AgentAdapter, u as GenerateOptions, v as defineConfig, y as loadConfig } from "../types-Cms1Tu5k.js";
+import { ILogBasic, ILogLayer } from "lognow";
+/** Create an adapter for an installed CLI using its existing authentication. */
+export declare function createAgent(name: AgentName): AgentAdapter;
+/**
+ * Explicitly amend an unpublished version-only release and its matching local
+ * tags.
+ */
+export declare function amendRelease(plan: ChangelogPlan): Promise<string>;
+/** Generate reviewable edits from Git history without changing tracked files. */
+export declare function generateChangelog(options?: GenerateOptions): Promise<ChangelogPlan>;
+/**
+ * Set the logger instance for the module. Export this for library consumers to
+ * inject their own logger.
+ *
+ * @param logger - Accepts either a LogLayer instance or a Console- or
+ *   Stream-like log target
+ */
+export declare function setLogger(logger?: ILogBasic | ILogLayer<unknown>): void;
+/** Produce a unified diff without modifying the repository or index. */
+export declare function previewChangelog(plan: ChangelogPlan): Promise<string>;
+/** Review a diff and optionally edit temporary candidates before applying them. */
+export declare function reviewChangelog(plan: ChangelogPlan, options?: {
+  editor?: string;
+}): Promise<ChangelogPlan | undefined>;
+/**
+ * Apply reviewed edits, rejecting concurrent changes and rolling back failed
+ * writes.
+ */
+export declare function writeChangelog(plan: ChangelogPlan): Promise<string[]>;
+export { type AgentAdapter, type AgentName, type Category, type Change, type ChangeSet, type ChangelogPlan, type Config, type Effort, type Evidence, type FileEdit, type GenerateOptions, type GenerationRequest, type GenerationResponse, type ReleaseContext, type ReleaseRequest, type ReleaseSummary, type RunSettings, defineConfig, loadConfig };

package/dist/lib/index.js

@@ -0,0 +1,4 @@
+import { a as defineConfig, c as createAgent, i as generateChangelog, n as previewChangelog, o as loadConfig, r as reviewChangelog, s as writeChangelog, y as setLogger } from "../review-LYSADnul.js";
+import { t as amendRelease } from "../lib-CXMRRbJf.js";
+
+export { amendRelease, createAgent, defineConfig, generateChangelog, loadConfig, previewChangelog, reviewChangelog, setLogger, writeChangelog };

package/dist/lib-CXMRRbJf.js

@@ -0,0 +1,175 @@
+import { _ as isAncestor, d as LOCKFILE_PATH, f as inspectRepository, g as git, h as manifestAt, p as isVersionOnlyChange, s as writeChangelog, v as runCommand } from "./review-LYSADnul.js";
+import path from "node:path";
+import { realpath } from "node:fs/promises";
+
+// src/lib/amend.ts
+const SIGNATURE = /-----BEGIN (?:PGP|SSH) SIGNATURE-----/v;
+const RELEASE_MESSAGE = /^(?:release\b|(?:chore|build)(?:\(release\))?:?\s*(?:release\b|v?\d))/iv;
+async function assertUnpublished(root, head, tags) {
+	const remotes = await git(root, ["remote"]);
+	for (const remote of remotes.split("\n")) {
+		if (remote === "") continue;
+		const refs = await git(root, [
+			"ls-remote",
+			"--heads",
+			"--tags",
+			remote
+		]);
+		for (const line of refs.split("\n")) {
+			const [object, ref] = line.split("	", 2);
+			if (object === void 0 || ref === void 0) continue;
+			if (object === head || tags.some((tag) => ref === `refs/tags/${tag.name}`)) throw new Error(`The release is already advertised by ${remote}; refusing to amend it.`);
+			if (!ref.startsWith("refs/heads/")) continue;
+			if ((await runCommand("git", [
+				"cat-file",
+				"-e",
+				object + "^{commit}"
+			], {
+				allowFailure: true,
+				cwd: root
+			})).code !== 0) throw new Error(`Cannot verify unpublished status against ${remote}. Fetch its branches and retry.`);
+			if (await isAncestor(root, head, object)) throw new Error(`The release commit is already reachable on ${remote}; refusing to amend it.`);
+		}
+	}
+}
+async function inspectRelease(root, head) {
+	if (await git(root, [
+		"symbolic-ref",
+		"-q",
+		"HEAD"
+	], true) === "") throw new Error("Amendment requires a checked-out branch.");
+	if ((await git(root, [
+		"rev-list",
+		"--parents",
+		"-n",
+		"1",
+		head
+	])).split(" ").length !== 2) throw new Error("Amendment requires a release commit with exactly one parent.");
+	const subject = await git(root, [
+		"log",
+		"-1",
+		"--format=%s"
+	]);
+	if (!RELEASE_MESSAGE.test(subject)) throw new Error("HEAD does not have a recognizable release commit message. Use the bumpp hook for automatic release integration.");
+	await assertVersionBump(root, head);
+	const repository = await inspectRepository(root);
+	const versions = [repository.rootPackage, ...repository.packages].map((pkg) => pkg.version).filter((version) => version !== void 0);
+	const names = await git(root, [
+		"tag",
+		"--points-at",
+		head
+	]);
+	const tags = [];
+	for (const name of names.split("\n")) {
+		if (name === "") continue;
+		if (versions.every((version) => name !== version && name !== `v${version}` && !name.endsWith(`@${version}`) && !name.endsWith(`/v${version}`))) throw new Error(`HEAD also has an unrelated tag (${name}); refusing to move it.`);
+		const object = await git(root, ["rev-parse", `refs/tags/${name}`]);
+		const contents = await tagContents(root, object);
+		if (contents !== void 0 && SIGNATURE.test(contents)) throw new Error(`Tag ${name} is signed. Use the bumpp hook before tagging, or re-sign this release manually.`);
+		tags.push({
+			contents,
+			name,
+			object
+		});
+	}
+	await assertUnpublished(root, head, tags);
+	return tags;
+}
+async function tagContents(root, object) {
+	if (await git(root, [
+		"cat-file",
+		"-t",
+		object
+	]) !== "tag") return;
+	return (await runCommand("git", [
+		"cat-file",
+		"-p",
+		object
+	], { cwd: root })).stdout;
+}
+/** Refuse an ineligible amendment before generation spends an agent session. */
+async function assertAmendable(cwd) {
+	const root = await realpath(await git(cwd, ["rev-parse", "--show-toplevel"]));
+	await inspectRelease(root, await git(root, ["rev-parse", "HEAD"]));
+}
+/**
+* Explicitly amend an unpublished version-only release and its matching local
+* tags.
+*/
+async function amendRelease(plan) {
+	if (await git(plan.root, ["rev-parse", "HEAD"]) !== plan.head) throw new Error("HEAD changed during generation; refusing to amend.");
+	const tags = await inspectRelease(plan.root, plan.head);
+	const files = await writeChangelog(plan);
+	if (files.length === 0) return plan.head;
+	if (await git(plan.root, ["rev-parse", "HEAD"]) !== plan.head) throw new Error("HEAD changed while writing changelogs; refusing to amend.");
+	const originalCommit = await git(plan.root, [
+		"cat-file",
+		"-p",
+		plan.head
+	]);
+	await git(plan.root, [
+		"add",
+		"--",
+		...files
+	]);
+	await git(plan.root, [
+		"commit",
+		"--amend",
+		"--no-edit",
+		"--only",
+		...originalCommit.includes("\ngpgsig ") ? ["--gpg-sign"] : [],
+		"--",
+		...files
+	]);
+	const amended = await git(plan.root, ["rev-parse", "HEAD"]);
+	try {
+		const updates = ["start"];
+		for (const tag of tags) {
+			let object = amended;
+			if (tag.contents !== void 0) {
+				const contents = tag.contents.replace(`object ${plan.head}`, () => `object ${amended}`);
+				object = (await runCommand("git", ["mktag"], {
+					cwd: plan.root,
+					input: contents
+				})).stdout.trim();
+			}
+			updates.push(`update refs/tags/${tag.name} ${object} ${tag.object}`);
+		}
+		updates.push("prepare", "commit");
+		await runCommand("git", ["update-ref", "--stdin"], {
+			cwd: plan.root,
+			input: updates.join("\n") + "\n"
+		});
+	} catch (error) {
+		await git(plan.root, [
+			"update-ref",
+			"HEAD",
+			plan.head,
+			amended
+		]);
+		throw new Error("Could not retarget the release tags. Restored the original release commit; changelog edits remain available.", { cause: error });
+	}
+	return amended;
+}
+async function assertVersionBump(root, head) {
+	const files = await git(root, [
+		"diff-tree",
+		"--no-commit-id",
+		"--name-only",
+		"-r",
+		head
+	]);
+	let versionChanged = false;
+	for (const file of files.split("\n")) {
+		if (path.basename(file).toLowerCase() === "changelog.md" || LOCKFILE_PATH.test(file)) continue;
+		if (path.basename(file) !== "package.json") throw new Error(`The release commit also changes ${file}; automatic amendment requires a version-only release commit.`);
+		const before = await manifestAt(root, path.posix.dirname(file), head + "^");
+		const after = await manifestAt(root, path.posix.dirname(file), head);
+		if (before === void 0 || after === void 0 || before.version === after.version) throw new Error(`No verifiable version bump in ${file}.`);
+		if (!await isVersionOnlyChange(root, file, head + "^", head)) throw new Error(`The release changes more than the version in ${file}. Use the bumpp hook instead.`);
+		versionChanged = true;
+	}
+	if (!versionChanged) throw new Error("HEAD does not contain a version bump.");
+}
+
+export { assertAmendable as n, amendRelease as t };

package/dist/progress-DQtRnH1N.js

@@ -0,0 +1,74 @@
+import { styleText } from "node:util";
+import { unicode } from "@clack/prompts";
+
+// src/lib/progress.ts
+const FRAMES = unicode ? [
+	"◒",
+	"◐",
+	"◓",
+	"◑"
+] : [
+	"•",
+	"o",
+	"O",
+	"0"
+];
+const FRAME_INTERVAL_MS = 80;
+const FRAME_PADDING = "  ";
+const CLEAR_TO_LINE_END = "\x1B[K";
+const HIDE_CURSOR = "\x1B[?25l";
+const SHOW_CURSOR = "\x1B[?25h";
+const TRAILING_PERIOD = /\.$/v;
+function formatElapsed(milliseconds) {
+	const seconds = Math.floor(milliseconds / 1e3);
+	const minutes = Math.floor(seconds / 60);
+	return minutes > 0 ? `[${minutes}m ${seconds % 60}s]` : `[${seconds}s]`;
+}
+/**
+* Create a status line with an elapsed timer. Each redraw is one write that
+* overwrites the line in place, so the terminal never shows it blank.
+*/
+function createProgressLine(stream) {
+	let message = "";
+	let started = 0;
+	let tick = 0;
+	let timer;
+	const line = () => {
+		const frame = FRAMES[tick % FRAMES.length] ?? "";
+		tick += 1;
+		const elapsed = formatElapsed(performance.now() - started);
+		const { columns = 0 } = stream;
+		const width = columns > 0 ? Math.max(0, columns - 1 - frame.length - 2) : Infinity;
+		const text = `${message.slice(0, Math.max(0, width - elapsed.length - 1))} ${elapsed}`.slice(0, width);
+		return `\r${styleText("magenta", frame, { stream })}${FRAME_PADDING}${text}${CLEAR_TO_LINE_END}`;
+	};
+	const update = (text) => {
+		message = text.replace(TRAILING_PERIOD, "");
+	};
+	const stop = () => {
+		if (timer === void 0) return;
+		clearInterval(timer);
+		timer = void 0;
+		process.off("exit", stop);
+		stream.write(`\r${CLEAR_TO_LINE_END}${SHOW_CURSOR}`);
+	};
+	return {
+		/** Blank the line so other output can print; the next redraw restores it. */
+		clear() {
+			if (timer !== void 0) stream.write(`\r${CLEAR_TO_LINE_END}`);
+		},
+		start(text) {
+			update(text);
+			started = performance.now();
+			process.once("exit", stop);
+			stream.write(`${HIDE_CURSOR}${line()}`);
+			timer = setInterval(() => {
+				stream.write(line());
+			}, FRAME_INTERVAL_MS);
+		},
+		stop,
+		update
+	};
+}
+
+export { createProgressLine as t };