@codometer/cli 0.0.1

package/dist/main.module-_z85wgY7.js

@@ -0,0 +1,658 @@
+import { ConfigurationModule as e, ConfigurationService as t, FORMAT_NAMES as n } from "@codometer/configuration";
+import { DiscoveryModule as r, MeasureModule as i, MeasureService as a } from "@codometer/measurement";
+import { CODOMETER_MARKERS as o, ChangesModule as s, ChangesService as c, ConfigurationListingModule as l, ConfigurationListingService as u, DeliveryModule as d, DeliveryService as f, DestinationsModule as p, DestinationsService as m, DocumentsModule as ee, DocumentsService as h, JsonModule as g, MarkdownModule as _, RenderConfigurationService as v, RenderModule as y, RenderService as b, ReportModule as x, ReportService as S } from "@codometer/output";
+import { ConsoleLogger as te, Global as ne, Injectable as C, Module as w, Scope as T } from "@nestjs/common";
+import { ConfigModule as E } from "@nestjs/config";
+import { DiscoveryModule as D } from "@nestjs/core";
+import { existsSync as O, mkdirSync as k } from "node:fs";
+import A from "node:path";
+import j from "pino";
+import { z as M } from "zod";
+import { Command as N, CommandRunner as P, Option as F } from "nest-commander";
+//#region packages/logger/src/modules/logger/logger.constants.ts
+var re = /^(\p{Extended_Pictographic}️?(?:‍\p{Extended_Pictographic}️?)*)\s+/u, ie = /^([A-Za-z]+)/, ae = /* @__PURE__ */ new Set([
+	"built",
+	"cut",
+	"found",
+	"got",
+	"kept",
+	"left",
+	"lost",
+	"made",
+	"put",
+	"ran",
+	"read",
+	"rebuilt",
+	"sent",
+	"set",
+	"split",
+	"took",
+	"wrote"
+]), oe = /* @__PURE__ */ new Set([
+	"CommandFactory",
+	"ExceptionHandler",
+	"GraphQLModule",
+	"InstanceLoader",
+	"NestApplication",
+	"NestFactory",
+	"RouterExplorer",
+	"RoutesResolver",
+	"TypeOrmModule"
+]);
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorateMetadata.js
+function I(e, t) {
+	if (typeof Reflect == "object" && typeof Reflect.metadata == "function") return Reflect.metadata(e, t);
+}
+//#endregion
+//#region \0@oxc-project+runtime@0.151.0/helpers/esm/decorate.js
+function L(e, t, n, r) {
+	var i = arguments.length, a = i < 3 ? t : r === null ? r = Object.getOwnPropertyDescriptor(t, n) : r, o;
+	if (typeof Reflect == "object" && typeof Reflect.decorate == "function") a = Reflect.decorate(e, t, n, r);
+	else for (var s = e.length - 1; s >= 0; s--) (o = e[s]) && (a = (i < 3 ? o(a) : i > 3 ? o(t, n, a) : o(t, n)) || a);
+	return i > 3 && a && Object.defineProperty(t, n, a), a;
+}
+//#endregion
+//#region packages/logger/src/modules/logger/logger.service.ts
+var R, z = class extends te {
+	static {
+		R = this;
+	}
+	constructor() {
+		super();
+	}
+	static isProduction = process.env.NODE_ENV === "production";
+	static rootLogger;
+	static writesToStandardError = !1;
+	child = R.root;
+	static createRootLogger() {
+		let e = process.env.LOG_LEVEL ?? "info";
+		return R.isProduction ? R.writesToStandardError ? j({ level: e }, j.destination(2)) : j({ level: e }) : j({
+			level: e,
+			transport: {
+				options: {
+					colorize: !0,
+					destination: R.writesToStandardError ? 2 : 1,
+					ignore: "pid,hostname,emoji",
+					messageFormat: "{emoji} {msg}",
+					singleLine: !0
+				},
+				target: "pino-pretty"
+			}
+		});
+	}
+	static logToStandardError() {
+		if (R.rootLogger !== void 0) {
+			process.emitWarning("LoggerService.logToStandardError() was called after the first log line, so log lines still go to standard output and anything piping that stream will read them as data. Call it as the first statement of the application's bootstrap.");
+			return;
+		}
+		R.writesToStandardError = !0;
+	}
+	assertConventionalMessage(e) {
+		if (R.isProduction || this.shouldSkipConventionalMessageValidation(e.context)) return;
+		let t = this.getConventionalMessageViolation(e.parsed);
+		if (t !== void 0) throw Error(t);
+	}
+	buildBindings(e) {
+		return this.assertConventionalMessage({
+			context: e.context,
+			parsed: e.parsed
+		}), {
+			...e.data,
+			context: e.context,
+			...R.isProduction ? {} : { emoji: e.parsed.emoji }
+		};
+	}
+	getConventionalMessageViolation(e) {
+		let t = e.emoji, n = e.text;
+		if (t === void 0) return `Log message must start with an emoji naming its subject, then a verb: "${n}"`;
+		let r = ie.exec(n)?.[1];
+		if (r === void 0 || !this.isConventionalVerb(r)) return `Log message must begin with a verb in present progressive or past tense, got "${r ?? ""}": "${t} ${n}"`;
+	}
+	isConventionalVerb(e) {
+		let t = e.toLowerCase();
+		return t.endsWith("ing") || t.endsWith("ed") || ae.has(t);
+	}
+	parseMessage(e) {
+		let t = String(e), n = re.exec(t), r = n?.[1];
+		return r === void 0 ? {
+			emoji: void 0,
+			text: t
+		} : {
+			emoji: r,
+			text: t.slice(n?.[0].length)
+		};
+	}
+	shouldSkipConventionalMessageValidation(e) {
+		return e !== void 0 && oe.has(e);
+	}
+	static get root() {
+		return R.rootLogger ??= R.createRootLogger(), R.rootLogger;
+	}
+	buildErrorLogEntry(e, t) {
+		let n = t instanceof Error ? t.stack || t.message : String(t);
+		return {
+			errorMessage: n,
+			logLine: `[${(/* @__PURE__ */ new Date()).toISOString()}] ${e}: ${n}\n`
+		};
+	}
+	createTimestampedOutputLogFilePath(e) {
+		let t = A.join(process.cwd(), "output");
+		return O(t) || k(t, { recursive: !0 }), A.join(t, `${e}-${(/* @__PURE__ */ new Date()).toISOString().replaceAll(/[:.]/g, "-")}.log`);
+	}
+	debug(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.debug(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	error(e, t, n) {
+		let r = this.parseMessage(e), i = typeof n == "object" ? n : void 0, a = typeof n == "string" ? n : this.context;
+		this.child.error({
+			...this.buildBindings({
+				context: a,
+				data: i,
+				parsed: r
+			}),
+			stack: t
+		}, r.text);
+	}
+	info(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.info(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	log(e, t, n) {
+		this.info(e, t, n);
+	}
+	setContext(e) {
+		super.setContext(e), this.child = R.root.child({ context: e });
+	}
+	verbose(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.trace(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+	warn(e, t, n) {
+		let r = this.parseMessage(e);
+		this.child.warn(this.buildBindings({
+			context: t ?? this.context,
+			data: n,
+			parsed: r
+		}), r.text);
+	}
+};
+z = R = L([C({ scope: T.TRANSIENT }), I("design:paramtypes", [])], z);
+//#endregion
+//#region packages/logger/src/modules/logger/logger.module.ts
+var B = class {};
+B = L([ne(), w({
+	controllers: [],
+	exports: [z],
+	imports: [],
+	providers: [z]
+})], B);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/constants.ts
+var V = M.object({}), H, U = H = class extends P {
+	configurationService;
+	changesService;
+	documentsService;
+	renderService;
+	logger;
+	constructor(e, t, n, r, i) {
+		super(), this.configurationService = e, this.changesService = t, this.documentsService = n, this.renderService = r, this.logger = i, this.logger.setContext(H.name);
+	}
+	parseBaseline(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseBaselineUrl(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseDirectory(e) {
+		return this.configurationService.parseDirectoryOption(e);
+	}
+	parseMarkdown(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	parseOutput(e) {
+		return this.configurationService.parseOptionalOption(e);
+	}
+	async run(e, t) {
+		let n = this.configurationService.parseOptionalOption(t.baseline), r = this.configurationService.parseDirectoryOption(t.directory), i = this.changesService.collect({
+			baselineDirectory: n,
+			workingDirectory: r
+		});
+		this.logger.info("⏲️ Collected the codometer change report", void 0, {
+			failures: i.failures.length,
+			rows: i.rows.length
+		});
+		let a = this.renderService.renderSection({
+			baselineUrl: this.configurationService.parseOptionalOption(t.baselineUrl),
+			failures: i.failures,
+			rows: i.rows
+		});
+		await this.documentsService.emit({
+			body: a,
+			destination: {
+				markdown: this.configurationService.parseOptionalOption(t.markdown),
+				output: this.configurationService.parseOptionalOption(t.output)
+			},
+			label: "codometer changes",
+			markers: o
+		});
+	}
+};
+L([
+	F({
+		description: "Directory holding a baseline snapshot of the reports",
+		flags: "--baseline [baseline]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], U.prototype, "parseBaseline", null), L([
+	F({
+		description: "Run URL the baseline came from",
+		flags: "--baseline-url [baselineUrl]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], U.prototype, "parseBaselineUrl", null), L([
+	F({
+		description: "Directory to look for codometer reports in",
+		flags: "-d, --directory [directory]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", String)
+], U.prototype, "parseDirectory", null), L([
+	F({
+		description: "Markdown document to splice the report into",
+		flags: "--markdown [markdown]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], U.prototype, "parseMarkdown", null), L([
+	F({
+		description: "File to write the report to",
+		flags: "--output [output]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], U.prototype, "parseOutput", null), U = H = L([
+	N({
+		description: "Report codometer's changes against a baseline",
+		name: "changes"
+	}),
+	C(),
+	I("design:paramtypes", [
+		t === void 0 ? Object : t,
+		c === void 0 ? Object : c,
+		h === void 0 ? Object : h,
+		b === void 0 ? Object : b,
+		z === void 0 ? Object : z
+	])
+], U);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/modules/changes/changes.module.ts
+var W = class {};
+W = L([w({
+	controllers: [],
+	exports: [U],
+	imports: [
+		s,
+		e,
+		ee,
+		B,
+		y
+	],
+	providers: [U]
+})], W);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/modules/configuration/configuration.constants.ts
+var G = ["json", "markdown"], K = "markdown", q, J = q = class extends P {
+	codometerConfigurationService;
+	configurationService;
+	renderConfigurationService;
+	logger;
+	constructor(e, t, n, r) {
+		super(), this.codometerConfigurationService = e, this.configurationService = t, this.renderConfigurationService = n, this.logger = r, this.logger.setContext(q.name);
+	}
+	parseConfig(e) {
+		return e;
+	}
+	parseDirectory(e) {
+		return this.codometerConfigurationService.parseDirectoryOption(e);
+	}
+	parseFormat(e) {
+		return this.codometerConfigurationService.parseDefaultedOption(e, K);
+	}
+	parseLimits() {
+		return !0;
+	}
+	async run(e, t = {}) {
+		let n = t.format ?? "markdown";
+		if (!G.includes(n)) throw Error(`--format does not accept "${n}". It takes one of ${G.join(" and ")}.`);
+		let r = A.resolve(t.directory ?? process.cwd()), { described: i, rootError: a } = await this.configurationService.describeConfigurations({
+			configurationPath: t.config,
+			workingDirectory: r
+		});
+		this.logger.info("🔧 Listed the codometer configuration", void 0, {
+			configurationCount: i.length,
+			unreadableCount: i.filter((e) => e.error !== void 0).length
+		}), a !== void 0 && (this.logger.error("🔧 Found no configuration answering for the walk root", void 0, { reason: a }), process.exitCode = 1);
+		let o = this.renderConfigurationService.render({
+			described: i,
+			format: n,
+			limitRows: this.configurationService.toLimitRows(i),
+			limitsOnly: t.limits === !0,
+			rootError: a
+		});
+		process.stdout.write(`${o}\n`);
+	}
+};
+L([
+	F({
+		description: "Path to the configuration file answering for the directory being listed",
+		flags: "--config [config]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], J.prototype, "parseConfig", null), L([
+	F({
+		description: "Directory to look for configuration files beneath",
+		flags: "-d, --directory [directory]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", String)
+], J.prototype, "parseDirectory", null), L([
+	F({
+		description: `Output format, one of ${G.join(", ")}`,
+		flags: "-f, --format [format]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", String)
+], J.prototype, "parseFormat", null), L([
+	F({
+		description: "List only the configured limits",
+		flags: "--limits"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", []),
+	I("design:returntype", Boolean)
+], J.prototype, "parseLimits", null), J = q = L([
+	N({
+		description: "List the codometer configuration found beneath a directory",
+		name: "configuration"
+	}),
+	C(),
+	I("design:paramtypes", [
+		t === void 0 ? Object : t,
+		u === void 0 ? Object : u,
+		v === void 0 ? Object : v,
+		z === void 0 ? Object : z
+	])
+], J);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/modules/configuration/configuration.module.ts
+var Y = class {};
+Y = L([w({
+	controllers: [],
+	exports: [J],
+	imports: [e, l],
+	providers: [J]
+})], Y);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/modules/measure/measure.command.ts
+var X, Z = X = class extends P {
+	configurationService;
+	measureService;
+	deliveryService;
+	reportService;
+	destinationsService;
+	logger;
+	constructor(e, t, n, r, i, a) {
+		super(), this.configurationService = e, this.measureService = t, this.deliveryService = n, this.reportService = r, this.destinationsService = i, this.logger = a, this.logger.setContext(X.name);
+	}
+	announceOutputPaths(e) {
+		e.length !== 0 && this.logger.info("📊 Excluded the files codometer writes from what it measures", void 0, { paths: e });
+	}
+	applyInputsOverride(e, t) {
+		return t === void 0 ? e : {
+			...e,
+			inputs: [{
+				analyses: ["language"],
+				compression: "none",
+				directory: ".",
+				exclude: [],
+				include: t,
+				name: "Command Line"
+			}]
+		};
+	}
+	async readConfiguration(e, t) {
+		try {
+			let n = await this.configurationService.loadConfiguration({
+				configurationPath: e.config,
+				searchDirectory: t
+			});
+			return this.logger.debug("🗂️ Loaded the configuration", void 0, { configuredPath: e.config }), n;
+		} catch (e) {
+			this.logger.error("📊 Rejected the configuration", void 0, { reason: e instanceof Error ? e.message : String(e) }), process.exitCode = 1;
+			return;
+		}
+	}
+	rejectCommandLine(e) {
+		this.logger.error("📊 Rejected the command line", void 0, { reasons: e }), process.exitCode = 1;
+	}
+	reportBreaches(e) {
+		let t = e.measurement.limits.filter((e) => e.breached), n = t.filter((e) => e.severity === "fail"), r = t.filter((e) => e.severity === "warn");
+		return r.length > 0 && this.logger.warn("📊 Breached a warning limit", void 0, { limits: r }), n.length > 0 && this.logger.error("📊 Breached a failing limit", void 0, { limits: n }), e.mode.checksLimits && n.length > 0;
+	}
+	reportFailures(e) {
+		return e.measurement.failures.length !== 0 && (this.logger.error("📊 Failed to measure part of the run", void 0, { failures: e.measurement.failures }), e.mode.checksLimits || e.mode.checksReports || e.mode.writesJson || e.mode.writesMarkdown);
+	}
+	reportFindings(e) {
+		let t = this.reportFailures(e), n = this.reportStaleness(e), r = this.reportBreaches(e);
+		(t || n || r) && (process.exitCode = 1), this.logger.info("✅ Finished the measurement run", void 0, {
+			breachCount: e.measurement.limits.filter((e) => e.breached).length,
+			inputCount: e.measurement.inputs.length
+		});
+	}
+	reportStaleness(e) {
+		return e.stalePaths.length !== 0 && (this.logger.error("📊 Found stale reports", void 0, { paths: e.stalePaths }), !0);
+	}
+	async resolveRunPlan(e, t) {
+		let { errors: n, mode: r } = this.configurationService.selectMode(e);
+		if (n.length > 0) {
+			this.rejectCommandLine(n);
+			return;
+		}
+		let i = await this.readConfiguration(e, t);
+		if (i === void 0) return;
+		let a = this.applyInputsOverride(i, e.inputs), o = [], s = this.configurationService.resolveFormat(e.format, a.format, o), { destinations: c, errors: l } = this.destinationsService.resolveDestinations({
+			configuration: a,
+			options: e,
+			workingDirectory: t
+		});
+		if (o.length > 0 || l.length > 0) {
+			this.rejectCommandLine([...o, ...l]);
+			return;
+		}
+		return {
+			configuration: a,
+			consoleMarkdown: this.destinationsService.resolveConsoleMarkdown({
+				configuration: a,
+				options: e,
+				workingDirectory: t
+			}),
+			destinations: c,
+			format: s,
+			mode: r
+		};
+	}
+	resolveWorkingDirectory() {
+		let e = A.resolve(process.cwd());
+		return this.logger.debug("🚀 Started the measurement run", void 0, { directory: e }), e;
+	}
+	parseCheck(e) {
+		return e;
+	}
+	parseConfig(e) {
+		return e;
+	}
+	parseFormat(e) {
+		return e;
+	}
+	parseInputs(e, t = []) {
+		return [...t, e];
+	}
+	parseOutputJson(e) {
+		return e;
+	}
+	parseOutputMarkdown(e) {
+		return e;
+	}
+	async run(e, t) {
+		let n = this.resolveWorkingDirectory(), r = await this.resolveRunPlan(t, n);
+		if (r === void 0) return;
+		let { configuration: i, consoleMarkdown: a, destinations: o, format: s, mode: c } = r, l = this.destinationsService.listOutputPaths({
+			destinations: o,
+			workingDirectory: n
+		});
+		this.announceOutputPaths(l);
+		let u = this.measureService.measure({
+			configuration: i,
+			outputPaths: l,
+			workingDirectory: n
+		}), d = this.reportService.build(u), f = this.deliveryService.deliver({
+			consoleMarkdown: a,
+			destinations: o,
+			format: s,
+			measurement: u,
+			mode: c,
+			report: d,
+			scope: this.destinationsService.selectScope(n)
+		});
+		this.reportFindings({
+			measurement: u,
+			mode: c,
+			stalePaths: f
+		});
+	}
+};
+L([
+	F({
+		description: "Fail on a comma-separated set drawn from \"reports\" and \"limits\"",
+		flags: "--check [check]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [String]),
+	I("design:returntype", String)
+], Z.prototype, "parseCheck", null), L([
+	F({
+		description: "Path to the codometer configuration file",
+		flags: "--config [config]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], Z.prototype, "parseConfig", null), L([
+	F({
+		description: `What to print to standard output, one of ${n.join(" and ")}`,
+		flags: "-f, --format <format>"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [String]),
+	I("design:returntype", String)
+], Z.prototype, "parseFormat", null), L([
+	F({
+		description: "Glob array measured in place of every configured input, with no configured input — not even the built-in codebase one — active",
+		flags: "--inputs [globs...]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [String, Array]),
+	I("design:returntype", Array)
+], Z.prototype, "parseInputs", null), L([
+	F({
+		description: "Write the JSON report, at the given path or the configured one",
+		flags: "--output-json [outputJson]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], Z.prototype, "parseOutputJson", null), L([
+	F({
+		description: "Write the markdown badge block, at the given path or the configured one",
+		flags: "--output-markdown [outputMarkdown]"
+	}),
+	I("design:type", Function),
+	I("design:paramtypes", [Object]),
+	I("design:returntype", Object)
+], Z.prototype, "parseOutputMarkdown", null), Z = X = L([
+	N({
+		description: "Measure a directory and produce every resolved output",
+		name: "measure"
+	}),
+	C(),
+	I("design:paramtypes", [
+		t === void 0 ? Object : t,
+		a === void 0 ? Object : a,
+		f === void 0 ? Object : f,
+		S === void 0 ? Object : S,
+		m === void 0 ? Object : m,
+		z === void 0 ? Object : z
+	])
+], Z);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/modules/measure/measure.module.ts
+var Q = class {};
+Q = L([w({
+	controllers: [],
+	exports: [Z],
+	imports: [
+		i,
+		e,
+		d,
+		p,
+		B,
+		x
+	],
+	providers: [Z]
+})], Q);
+//#endregion
+//#region packages/ic-suite/codometer/codometer-cli/src/main.module.ts
+var $ = class {};
+$ = L([w({ imports: [
+	E.forRoot({
+		envFilePath: ".env",
+		isGlobal: !0,
+		validate: (e) => V.parse(e)
+	}),
+	D,
+	B,
+	W,
+	Y,
+	Q,
+	r,
+	e,
+	g,
+	_
+] })], $);
+//#endregion
+export { J as a, z as c, Y as i, Q as n, W as o, Z as r, U as s, $ as t };