@savvy-web/cli 3.5.1 → 3.6.0

package/internal/failure-line.js

@@ -1,4 +1,4 @@
-import { Cause } from "effect";
+import { CliDoc } from "@effected/cli";
 
 //#region src/internal/failure-line.ts
 /** Where a defect report asks to be filed; mirrors `package.json#bugs.url`. */
@@ -29,6 +29,8 @@ const describe = (error) => {
 	}
 	return String(error);
 };
+/** Whether a typed failure draws itself through the kit's `CliDoc` protocol. */
+const drawsItself = (error) => typeof error === "object" && error !== null && CliDoc in error && typeof error[CliDoc] === "function";
 /**
 * Renders a failure for `CliRuntime.main`'s `render` option.
 *
@@ -37,23 +39,35 @@ const describe = (error) => {
 * or a defect, so nothing here guesses that from the error's shape.
 *
 * - A typed failure is an expected outcome and reads as one line. The kit's
-*   default is `String(error)`, which prints a `Data.TaggedError` with no
-*   `message` as its bare tag and drops the fields that say what went wrong
-*   (`CleanError`, with the `reason` lost), so this prefers the error's own
-*   message, then its tag with its fields, then `String`.
+*   default report (`details.defaultLines`) is a status line plus a cleaned
+*   stack, which is noise for an expected outcome, and a `Data.TaggedError`
+*   with no `message` loses the fields that say what went wrong (`CleanError`,
+*   with the `reason` lost), so this prefers the error's own message, then
+*   its tag with its fields, then `String`.
+* - A typed failure whose error implements the kit's `CliDoc` protocol (the
+*   CLI's own `CommandError`) has already said how it reads, so it gets the
+*   kit's report of that document (`details.defaultLines`), drawn for the
+*   run's audience, instead of one line.
 * - A defect — a `die`, a thrown exception — is a bug in savvy. It gets the
-*   issue-report treatment: a headline, the whole pretty-printed cause with
-*   its stack, and where to report it.
+*   kit's default report (`details.defaultLines`: the status line and the
+*   program's own stack frames, drawn for the run's audience) followed by
+*   where to report it.
 *
 * @internal
 */
 var FailureLine = class {
 	constructor() {}
-	static render = (error, details) => details.isDefect ? [
-		`savvy hit an unexpected error: ${describe(error)}`,
-		...Cause.pretty(details.cause).split("\n"),
-		`This is a bug in savvy. Please report it with the output above at ${ISSUES_URL}`
-	] : describe(error);
+	static render = (error, details) => {
+		if (details.isDefect) return [...details.defaultLines, `This is a bug in savvy. Please report it with the output above at ${ISSUES_URL}`];
+		return drawsItself(error) ? details.defaultLines : describe(error);
+	};
+	/**
+	* One line for a typed failure: its own message, else its tag with its
+	* fields, else `String`. What {@link FailureLine.render} prints for a typed
+	* failure that does not draw itself, and what `CommandError.from` keeps of
+	* a foreign error.
+	*/
+	static describe = (error) => describe(error);
 };
 
 //#endregion

package/internal/report.js

@@ -0,0 +1,101 @@
+import { Doc, Status } from "@effected/cli";
+import { Effect } from "effect";
+import { TerminalEnv } from "@effected/env";
+
+//#region src/internal/report.ts
+/** A status line, with any detail lines muted and indented under it. */
+const item = (status, text, detail) => {
+	const head = [
+		Doc.status(Status.core, status),
+		" ",
+		...Array.isArray(text) ? text : [text]
+	];
+	return detail.length === 0 ? Doc.line(head) : Doc.lines([head, ...detail.map((line) => Doc.text(`  ${line}`, "muted"))]);
+};
+/**
+* The result a person ran a command to see, as `Doc` blocks.
+*
+* @remarks
+* A command builds its report from these blocks and writes it once with
+* {@link Report.print}, which renders for the run's audience on stdout: ANSI
+* for a person at a terminal, plain text for an agent or a pipe, and a GitHub
+* Actions log under Actions. Only the status glyph and headings are painted,
+* so the text reads the same piped. Progress and diagnostics stay on
+* `Effect.log*`, which the CLI logger sends to stderr; a failure is the
+* runtime's to report, never a block here — fail with `CommandError`
+* (`./command-error.ts`), which draws itself.
+*
+* `Report` covers what every command repeats: status items, headings, detail
+* lines, the summary and the audience-aware print. Anything richer — a
+* table, a titled section, a callout, a tree, a file link, a GitHub Actions
+* annotation — is built with `Doc.*` from `@effected/cli` directly and mixed
+* into the same document (both build `Block`s); `Report` deliberately does not
+* re-wrap those constructors.
+*
+* @internal
+*/
+var Report = class {
+	constructor() {}
+	/** A passing item: `✓ text`, with optional muted detail lines under it. */
+	static ok = (text, ...detail) => item("success", text, detail);
+	/** An item that passed with a caveat: `⚠ text`. */
+	static warn = (text, ...detail) => item("warning", text, detail);
+	/** A finding — still output, not a crash: `✗ text`. */
+	static fail = (text, ...detail) => item("failure", text, detail);
+	/** An item that is absent or not applicable — neither a pass nor a finding: `↷ text`. */
+	static skip = (text, ...detail) => item("skip", text, detail);
+	/** A section title. */
+	static heading = (text) => Doc.heading(2, text);
+	/** Supporting detail under the block before it, indented and muted. */
+	static detail = (text) => Doc.line(Doc.text(`  ${text}`, "muted"));
+	/**
+	* A line printed as given; an empty string is a blank separator between
+	* blocks of one document. A document holding only blank lines renders as
+	* nothing, so a separator between two separately printed documents is a
+	* `Console.log("")`, not a `Report.line("")`.
+	*/
+	static line = (text) => Doc.line(text);
+	/** Text already laid out (a diff, a config dump), kept verbatim. */
+	static verbatim = (text) => Doc.verbatim(text);
+	/** `3 ok, 1 warning, 2 failed`, zero parts left out; `nothing to do` when every count is zero. */
+	static summary = (counts) => {
+		const ok = counts.ok ?? 0;
+		const warn = counts.warn ?? 0;
+		const fail = counts.fail ?? 0;
+		if (ok + warn + fail === 0) return Doc.line("nothing to do");
+		return Doc.counts({
+			layout: "inline",
+			share: false,
+			counters: [
+				Doc.counter(Status.core, "success", {
+					key: "ok",
+					label: "ok",
+					n: ok
+				}),
+				Doc.counter(Status.core, "warning", {
+					key: "warn",
+					label: warn === 1 ? "warning" : "warnings",
+					n: warn
+				}),
+				Doc.counter(Status.core, "failure", {
+					key: "fail",
+					label: "failed",
+					n: fail
+				})
+			]
+		});
+	};
+	/**
+	* Render `doc` for the run's audience and write it to stdout.
+	*
+	* @remarks
+	* A terminal wraps to its width. A pipe has no width to honour — the kit
+	* would otherwise wrap a person's piped output at 80 columns and split a
+	* long path or a `file:line:col` finding a caller greps — so off a terminal
+	* nothing is wrapped.
+	*/
+	static print = (doc) => Effect.flatMap(TerminalEnv, (terminal) => Doc.print(doc, terminal.stdout.isTerminal ? {} : { width: Number.POSITIVE_INFINITY }));
+};
+
+//#endregion
+export { Report };

package/main.js

@@ -1,9 +1,8 @@
-import { AppLive, CliPlatform, rootCommand } from "./cli/index.js";
 import { FailureLine } from "./internal/failure-line.js";
+import { AppLive, CliConfigLive, CliPlatform, rootCommand } from "./cli/index.js";
 import { VersionLine } from "./internal/version-line.js";
 import { CLI_VERSION } from "./version.js";
-import { Command } from "effect/cli";
-import { CliColor, CliRuntime } from "@effected/cli";
+import { CliAudience, CliRuntime } from "@effected/cli";
 import { Effect, Layer, Option } from "effect";
 import * as NodeRuntime from "@effect/platform-node/NodeRuntime";
 import { CurrentDistribution } from "@effected/engine";
@@ -14,15 +13,19 @@ import { CurrentDistribution } from "@effected/engine";
 * never import this module from the barrel.
 *
 * @remarks
-* Assembles the `Command.run` Effect over `rootCommand`, provides the merged
-* `AppLive` stack and the carrier-aware version formatter, and hands the
-* program to `@effected/cli`'s `CliRuntime.main`, which provides the platform
-* and the kit-default CLI logger (every log line on stderr), reports failures
-* through that logger (a typed failure as one line, a defect as a bug report),
-* applies the `CliExit` code a command set, and exits `64` on a usage error
-* with the help document on stderr, so stdout stays clean for a caller that
-* parses it. The version formatter rides in `platform`, not `program`: help
-* routing only sees a Formatter provided there.
+* Runs `rootCommand` through `CliAudience.run`, which resolves `--audience`,
+* `--human`, `--agent` and `--ci` before core parses, provides the merged
+* `AppLive` stack and `CliConfigLive` (core's built-in flags minus
+* `--wizard`), and hands the program to `@effected/cli`'s
+* `CliRuntime.main`. Its `env` builds the presentation environment once — the
+* audience (overridable through `SAVVY_AUDIENCE`), the terminal, the theme,
+* editor links and the prompt gate — installs `CliLog` (diagnostics opt-in
+* through `SAVVY_LOG_LEVEL`, every log line on stderr) and the coloured help
+* formatter with the carrier-aware `--version` line. `main` reports failures
+* through that logger (a typed failure as one line, a defect as a bug
+* report), applies the `CliExit` code a command set, and exits `64` on a
+* usage error with the help document on stderr, so stdout stays clean for a
+* caller that parses it.
 * No type casts: the layer graph is validated by the compiler.
 *
 * @packageDocumentation
@@ -35,11 +38,15 @@ import { CurrentDistribution } from "@effected/engine";
 */
 const main = (options = {}) => {
 	const distribution = Option.fromNullishOr(options.distribution);
-	const VersionFormatterLive = CliColor.formatterLayer({ formatVersion: (name, version) => VersionLine.format(name, version, distribution) });
-	const program = Command.run(rootCommand, { version: CLI_VERSION }).pipe(Effect.provide(AppLive), Effect.provideService(CurrentDistribution, distribution));
-	const platform = VersionFormatterLive.pipe(Layer.provideMerge(CliPlatform));
+	const program = CliAudience.run(rootCommand, { version: CLI_VERSION }).pipe(Effect.provide(Layer.merge(AppLive, CliConfigLive)), Effect.provideService(CurrentDistribution, distribution));
 	NodeRuntime.runMain(CliRuntime.main(program, {
-		platform,
+		platform: CliPlatform,
+		env: {
+			audienceEnvVar: "SAVVY_AUDIENCE",
+			stderrIsTerminal: Effect.sync(() => process.stderr.isTTY === true),
+			log: { envVar: "SAVVY_LOG_LEVEL" },
+			formatter: { formatVersion: (name, version) => VersionLine.format(name, version, distribution) }
+		},
 		render: FailureLine.render,
 		helpOnUsageError: "stderr"
 	}));

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/cli",
-	"version": "3.5.1",
+	"version": "3.6.0",
 	"private": false,
 	"description": "The savvy CLI — unified commit, changeset, and lint commands for the Silk Suite",
 	"homepage": "https://github.com/savvy-web/systems/tree/main/packages/cli",
@@ -36,16 +36,21 @@
 		"savvy": "bin/savvy.js"
 	},
 	"dependencies": {
-		"@effect/platform-node": "4.0.0-rc.118",
-		"@effected/cli": "^0.10.0",
-		"@effected/commands": "^0.10.0",
-		"@effected/engine": "^0.2.0",
-		"@effected/git": "^0.19.0",
-		"@effected/jsonc": "^0.14.0",
-		"@effected/templates": "^0.9.1",
-		"@effected/workspaces": "^0.30.3",
-		"@effected/yaml": "^0.18.0",
-		"@savvy-web/silk-effects": "9.3.1",
-		"effect": "4.0.0-rc.118"
+		"@effect/platform-node": "^4.0.0",
+		"@effected/cli": "^0.11.0",
+		"@effected/commands": "^0.11.0",
+		"@effected/engine": "^0.3.0",
+		"@effected/env": "^0.1.0",
+		"@effected/git": "^0.20.0",
+		"@effected/glob": "^0.10.0",
+		"@effected/jsonc": "^0.15.0",
+		"@effected/templates": "^0.10.0",
+		"@effected/walker": "^0.15.0",
+		"@effected/workspaces": "^0.31.0",
+		"@effected/yaml": "^0.19.0",
+		"@savvy-web/silk-effects": "9.4.0",
+		"effect": "^4.0.0",
+		"ink": "^7.1.1",
+		"react": "^19.3.0"
 	}
 }

package/version.js

@@ -7,7 +7,7 @@
 * @packageDocumentation
 */
 /** @internal */
-const CLI_VERSION = "3.5.1";
+const CLI_VERSION = "3.6.0";
 
 //#endregion
 export { CLI_VERSION };

package/internal/output.js

@@ -1,52 +0,0 @@
-import { CliColor } from "@effected/cli";
-import { Console, Effect } from "effect";
-
-//#region src/internal/output.ts
-/**
-* Human-readable command output.
-*
-* @packageDocumentation
-*/
-const paint = (on, code, text) => on ? `\u001b[${code}m${text}\u001b[0m` : text;
-const glyphLine = (code, glyph, text) => Effect.flatMap(CliColor.enabled, (on) => Console.log(`${paint(on, code, glyph)} ${text}`));
-/**
-* The result a person ran a command to see, written to stdout.
-*
-* @remarks
-* Every line goes through `Console.log`, so stdout carries a command's product
-* and nothing else; progress and diagnostics stay on `Effect.log*`, which the
-* CLI logger sends to stderr. Colour follows `CliColor.enabled` — off when
-* stdout is not a terminal or `NO_COLOR` is set — and only ever tints the
-* glyph or heading, so the text reads the same piped.
-*
-* @internal
-*/
-var Output = class {
-	constructor() {}
-	/** A passing item: `✓ text`. */
-	static ok = (text) => glyphLine("32", "✓", text);
-	/** An item that passed with a caveat: `⚠ text`. */
-	static warn = (text) => glyphLine("33", "⚠", text);
-	/** A finding — still output, not a crash: `✗ text`. */
-	static fail = (text) => glyphLine("31", "✗", text);
-	/** An item that is absent or not applicable — neither a pass nor a finding: `• text`, dimmed. */
-	static skip = (text) => glyphLine("2", "•", text);
-	/** A section title, bold on a terminal. */
-	static heading = (text) => Effect.flatMap(CliColor.enabled, (on) => Console.log(paint(on, "1", text)));
-	/** Supporting detail under the line before it, indented and dimmed on a terminal. */
-	static detail = (text) => Effect.flatMap(CliColor.enabled, (on) => Console.log(`  ${paint(on, "2", text)}`));
-	/** A line printed as given — a blank separator, or a block already formatted. */
-	static line = (text) => Console.log(text);
-	/** `3 ok · 1 warning · 2 failed`, zero parts left out; `nothing to do` when every count is zero. */
-	static summary = (counts) => {
-		const parts = [
-			counts.ok ? `${counts.ok} ok` : void 0,
-			counts.warn ? `${counts.warn} ${counts.warn === 1 ? "warning" : "warnings"}` : void 0,
-			counts.fail ? `${counts.fail} failed` : void 0
-		].filter((part) => part !== void 0);
-		return Console.log(parts.length === 0 ? "nothing to do" : parts.join(" · "));
-	};
-};
-
-//#endregion
-export { Output };