@effected/cli 0.12.0 → 0.14.0

package/CliRuntime.js

@@ -1,4 +1,6 @@
+import { Cancelled } from "./Cancelled.js";
 import { sanitize } from "./Fmt.js";
+import { NotInteractive } from "./NotInteractive.js";
 import { FailureTargetCell, currentTarget, fallbackTarget, guardConsumerLines, linesOf, plainFailureLines, readSpans, refreshFailureTarget } from "./internal/failureTarget.js";
 import { CliColor } from "./CliColor.js";
 import { CliEnv } from "./CliEnv.js";
@@ -173,6 +175,8 @@ var CliRuntime = class CliRuntime {
 			const details = {
 				cause,
 				isDefect: !Cause.hasFails(cause),
+				isCancelled: error instanceof Cancelled,
+				isNotInteractive: error instanceof NotInteractive,
 				defaultLines,
 				lines: (options) => options?.status === false || options?.spans !== void 0 ? reportLines(options?.status !== false, options?.spans) : defaultLines
 			};

package/Render.js

@@ -186,7 +186,7 @@ var Render = class {
 	*
 	* Under GitHub Actions (`neutralizeWorkflowCommands`) the same neutralizing applies, since markdown can be printed
 	* to the log. Markdown escapes `[` in text, so `##[` cannot appear outside code and the headings are untouched
-	* (a bare `##` is not a command); code spans and blocks, which are not escaped, get the zero-width space, which can
+	* (a bare `##` is not a command); code spans and blocks, which are not escaped, get the blank marker, which can
 	* also land inside code or table text where it would otherwise have formed a command.
 	*
 	* GitHub also turns `@user`, `@org/team`, `#123` and commit SHAs in rendered markdown into mentions and references.
@@ -238,8 +238,8 @@ var Render = class {
 	*
 	* The runner has two command parsers, and a line is a command if either accepts it: after its leading whitespace it
 	* starts with `::`, or `##[` occurs ANYWHERE in it (a bare `##` is not one). A document's text must not be able to
-	* do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a zero-width space in front, which
-	* the runner does not treat as whitespace, and every `##[` gets one between the `##` and the `[`. The text is
+	* do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a braille pattern blank (U+2800) in
+	* front, which the runner neither trims nor skips, and every `##[` gets one before the `[`. The text is
 	* otherwise unchanged. A
 	* group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
 	* that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience

package/index.d.ts

@@ -2568,6 +2568,24 @@ interface FailureDetails {
    * failure from the error channel.
    */
   readonly isDefect: boolean;
+  /**
+   * `true` when the squashed `error` is the kit's {@link Cancelled}: the person quit a prompt or screen (Esc, Ctrl-C).
+   * It is not a bug and there is nothing to report, whichever channel it arrived through.
+   *
+   * @remarks
+   * A cancel from `CliPrompt.fallback` is a defect (`isDefect` is `true`) and one from `CliUi.run` is a typed failure
+   * (`isDefect` is `false`), so a `render` that gives a defect the "please report this" treatment must test this flag
+   * first, or Esc prints an issue-report request. `isDefect` keeps its plain meaning, the absence of a typed failure,
+   * and the exit code is unchanged (`130` for the `interrupt` reason). `defaultLines` and `lines()` already draw it as
+   * its one fixed line.
+   */
+  readonly isCancelled: boolean;
+  /**
+   * `true` when the squashed `error` is the kit's {@link NotInteractive}: the program asked for a prompt or a screen in
+   * a run that cannot show one (a pipe, an agent, a CI). It is a usage problem, not a bug, whichever channel it
+   * arrived through; `isDefect` is as for {@link FailureDetails.isCancelled}.
+   */
+  readonly isNotInteractive: boolean;
   /**
    * The report the kit writes for this failure when there is no `render`: for this run, in this audience, with its
    * colour, links and `displayPath`. A `render` that hands a failure back returns these lines unchanged, and the
@@ -2687,9 +2705,11 @@ interface MainOptions<RP, EP> extends ReportFailuresOptions {
    * one that writes output must use `Console` or `Stdio`, never `Terminal`.
    *
    * Stderr's colour mirrors stdout's terminal check unless `env.stderrIsTerminal` says otherwise, so with stderr
-   * redirected and stdout a terminal the failure report is painted into the file. On Node, pass the real check:
-   * `env: { stderrIsTerminal: Effect.sync(() => process.stderr.isTTY === true) }` (core's `Stdio` reports only
-   * stdout; upstream Effect-TS/effect#8639).
+   * redirected and stdout a terminal the failure report is painted into the file. On Node, pass the real check from
+   * the bin's entry, the one place it reads the host:
+   * `env: { stderrIsTerminal: Effect.sync(() => process.stderr.isTTY === true) }`. Core's `Stdio` reports only
+   * stdout (upstream Effect-TS/effect#8639); once core has a stderr check, this option reads it and the bin passes
+   * nothing.
    */
   readonly env?: CliEnvOptions | undefined;
   /**
@@ -2706,8 +2726,12 @@ interface MainOptions<RP, EP> extends ReportFailuresOptions {
    *
    * Two cases keep help on stdout even under `"stderr"`. A `CliOutput`
    * Formatter or a `Console` provided inside `program` is not seen by
-   * `main`, so its help is not rerouted; provide the Formatter through
-   * `platform` instead. And with `Command.runWith`'s `renderErrors: false`
+   * `main`, so its help is not rerouted. To change the Formatter, pass
+   * `env.formatter` (for example `formatVersion`): `main` installs its own
+   * Formatter inside the platform, so that is the way in, and a Formatter
+   * provided inside the program is invisible to the routing. A Formatter
+   * the platform provides is shadowed by `main`'s, so pass it through
+   * `env.formatter` as well. And with `Command.runWith`'s `renderErrors: false`
    * no errors are printed, so nothing marks the help as a usage error's.
    */
   readonly helpOnUsageError?: "stdout" | "stderr" | undefined;
@@ -3200,8 +3224,8 @@ interface RenderContext {
   /**
    * Whether the output will be read by the GitHub Actions runner, which has two command parsers: a line is a command
    * if, after .NET whitespace, it starts with `::`, or if `##[` occurs ANYWHERE in it (a bare `##` is not one). When
-   * `true`, `plain`, `ansi` and `markdown` put a zero-width space in front of such a `::` line and between `##` and
-   * `[` at each `##[`, so a document's text, an error message, say, can never inject a command. Unset or `false`
+   * `true`, `plain`, `ansi` and `markdown` put a braille pattern blank (U+2800, one blank cell) in front of such a
+   * `::` line and before the `[` of each `##[`, so a document's text, an error message, say, can never inject a command. Unset or `false`
    * leaves their text alone. `Render.githubLog` ignores it and always neutralizes: its output is for the runner by
    * definition.
    *
@@ -3394,7 +3418,7 @@ export declare class Render {
    *
    * Under GitHub Actions (`neutralizeWorkflowCommands`) the same neutralizing applies, since markdown can be printed
    * to the log. Markdown escapes `[` in text, so `##[` cannot appear outside code and the headings are untouched
-   * (a bare `##` is not a command); code spans and blocks, which are not escaped, get the zero-width space, which can
+   * (a bare `##` is not a command); code spans and blocks, which are not escaped, get the blank marker, which can
    * also land inside code or table text where it would otherwise have formed a command.
    *
    * GitHub also turns `@user`, `@org/team`, `#123` and commit SHAs in rendered markdown into mentions and references.
@@ -3446,8 +3470,8 @@ export declare class Render {
    *
    * The runner has two command parsers, and a line is a command if either accepts it: after its leading whitespace it
    * starts with `::`, or `##[` occurs ANYWHERE in it (a bare `##` is not one). A document's text must not be able to
-   * do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a zero-width space in front, which
-   * the runner does not treat as whitespace, and every `##[` gets one between the `##` and the `[`. The text is
+   * do that (`::add-mask::`, `::error::`, `##[error]`), so such a `::` line gets a braille pattern blank (U+2800) in
+   * front, which the runner neither trims nor skips, and every `##[` gets one before the `[`. The text is
    * otherwise unchanged. A
    * group's title is a command's data, so its `%`, CR and LF are escaped. Lines are split at CR, LF and CRLF before
    * that check, as the runner splits them. There is no ANSI and `paint` and `link` are never called, and the audience

package/internal/renderMarkdown.js

@@ -52,7 +52,7 @@ const codeSpan = (text, mode) => {
 	const longest = Math.max(0, ...[...flat.matchAll(/`+/g)].map((run) => run[0].length));
 	const fence = "`".repeat(longest + 1);
 	const padded = /^`|`$/.test(flat) || /^ .* $/.test(flat) && flat.trim() !== "" || flat === "";
-	const body = mode === "cell" ? flat.replace(/\|/g, "\\|") : flat;
+	const body = mode === "cell" ? flat.split("|").join("\\|") : flat;
 	const pad = padded ? " " : "";
 	return `${fence}${pad}${body === "" ? " " : body}${pad}${fence}`;
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/cli",
-	"version": "0.12.0",
+	"version": "0.14.0",
 	"private": false,
 	"description": "The presentation boundary of an effect/cli program: audience-aware output, a document IR and renderers, editor links, failure reports and logging, plus opt-in Ink screens, widgets and a live view",
 	"keywords": [
@@ -57,17 +57,17 @@
 		"./package.json": "./package.json"
 	},
 	"dependencies": {
-		"@effected/github-commands": "^0.1.0"
+		"@effected/github-commands": "^0.2.0"
 	},
 	"peerDependencies": {
-		"@effected/config-file": "^0.14.1",
+		"@effected/config-file": "^0.14.2",
 		"@effected/env": "^0.1.0",
 		"@effected/glob": "^0.10.0",
 		"@effected/walker": "^0.15.0",
-		"@types/react": "^19.2.0",
+		"@types/react": "^19.3.0",
 		"effect": "^4.0.0",
-		"ink": "^7.1.1",
-		"react": "^19.2.0"
+		"ink": "^8.0.0",
+		"react": "^19.3.0"
 	},
 	"peerDependenciesMeta": {
 		"@effected/config-file": {

package/ui/UiTheme.js

@@ -107,8 +107,9 @@ const useTerminalSize = () => {
 			stdout.off("resize", redraw);
 		};
 	}, [stdout, followsStdout]);
-	const columns = override?.columns ?? stdout.columns;
-	const rows = override?.rows ?? stdout.rows;
+	const reported = stdout;
+	const columns = override?.columns ?? reported.columns;
+	const rows = override?.rows ?? reported.rows;
 	return {
 		columns: Math.max(1, known(columns, 80) - 1),
 		rows: Math.max(1, known(rows, 24) - 1)

package/ui/testing/CliUiTest.js

@@ -218,6 +218,10 @@ const LEADING_MOVES = /^(?:\u001b\[[0-9;?]*[A-Za-ln-z])+/;
 * moves; a write of moves alone is Ink clearing the frame for a log line, not a frame. stdout and stderr are two
 * streams, each read alone, and `fake.written` is both in the order written: one terminal, for `written` and the
 * transcript.
+*
+* Ink calls `onRender` after it writes a render's frame, in the same synchronous turn, so the frame is the last
+* frame-like write of that turn. A production render whose write Ink's throttle defers to its trailing timer has
+* none yet: the next frame-like write is taken instead.
 */
 const makeTerminal = (options, settings = { screens: "debug" }) => {
 	const columns = options.columns ?? 80;
@@ -226,25 +230,48 @@ const makeTerminal = (options, settings = { screens: "debug" }) => {
 	const captures = [];
 	let lastWrite = 0;
 	let frameDue = false;
+	let turn = [];
+	/** A chunk read as a frame in `mode`, or `undefined` for one that is not a frame (brackets or moves alone). */
+	const asFrame = (chunk, mode) => {
+		if (mode === "debug") return chunk;
+		const text = chunk.replace(FRAME_BRACKETS, "");
+		if (text === "" || CONTROLS_ONLY.test(text)) return void 0;
+		return text.replace(LEADING_MOVES, "").replace(/\n+$/, "");
+	};
 	const fake = makeFakeStreams({
 		columns,
 		rows,
 		onStdoutWrite: (chunk) => {
 			lastWrite = Date.now();
+			if (turn.length === 0) {
+				const opened = turn;
+				queueMicrotask(() => {
+					if (turn === opened) turn = [];
+				});
+			}
+			turn.push(chunk);
 			const current = captures.at(-1);
 			if (!frameDue || current === void 0 || current.ended) return;
-			if (current.mode === "debug") {
-				frameDue = false;
-				current.raws.push(chunk);
-				return;
-			}
-			const text = chunk.replace(FRAME_BRACKETS, "");
-			if (text === "") return;
+			const frame = asFrame(chunk, current.mode);
+			if (frame === void 0) return;
 			frameDue = false;
-			if (CONTROLS_ONLY.test(text)) return;
-			current.raws.push(text.replace(LEADING_MOVES, "").replace(/\n+$/, ""));
+			current.raws.push(frame);
 		}
 	});
+	/** Called as Ink reports a render: take the frame it wrote this turn, or wait for the one its throttle defers. */
+	const rendered = () => {
+		const current = captures.at(-1);
+		if (current === void 0 || current.ended) return;
+		for (let index = turn.length - 1; index >= 0; index--) {
+			const frame = asFrame(turn[index], current.mode);
+			if (frame === void 0) continue;
+			turn = [];
+			frameDue = false;
+			current.raws.push(frame);
+			return;
+		}
+		frameDue = true;
+	};
 	const streams = fake.streams;
 	const stream = {
 		isTerminal: true,
@@ -263,9 +290,7 @@ const makeTerminal = (options, settings = { screens: "debug" }) => {
 	}).pipe(Layer.provide(terminal)), CliInteractive.layerTest(options.interactive ?? true), Layer.succeed(UiStreams, streams), Layer.succeed(UiRenderOptions, {
 		...settings.screens === "debug" ? { debug: true } : {},
 		maxFps: 1e3,
-		onRender: () => {
-			frameDue = true;
-		},
+		onRender: rendered,
 		onMount: (kind) => {
 			const mode = kind === "live" ? "production" : settings.screens;
 			captures.push({

package/ui/testing/terminalModel.js

@@ -6,8 +6,9 @@ const ESC = String.fromCharCode(27);
 *
 * @remarks
 * It applies printable text, line feeds, the erase and cursor moves Ink's log-update writes (erase line, cursor up,
-* cursor to column one), and the clears of Ink's clear-terminal frame: `ESC[2J` blanks the visible screen, `ESC[3J`
-* drops the scrollback above it, `ESC[H` homes the cursor to the screen's top left. The visible screen is the last
+* down and forward, cursor to a column, cursor to the next line), and the clears of Ink's full-clear frame: `ESC[J`
+* erases from the cursor to the end of the screen, `ESC[2J` blanks the visible screen, `ESC[3J` drops the scrollback
+* above it, `ESC[H` homes the cursor to the screen's top left. The visible screen is the last
 * `rows` lines; with `rows` unknown, the whole buffer counts as the screen, so a clear takes everything. Every other
 * escape is ignored. It does not wrap a line wider than the terminal. Shared by `CliUiTest.live`'s transcript and the
 * kit's own production-path tests.
@@ -38,8 +39,16 @@ const screenAfter = (written, rows) => {
 			}
 		} else if (command === "K") lines[row] = "";
 		else if (command === "A") row = Math.max(0, row - Number(params === "" ? 1 : params));
-		else if (command === "G") column = 0;
-		else if (command === "J" && params === "2") for (let index = screenTop(); index < lines.length; index++) lines[index] = "";
+		else if (command === "B" || command === "E") {
+			row += Number(params === "" ? 1 : params);
+			if (command === "E") column = 0;
+			while (lines.length <= row) lines.push("");
+		} else if (command === "C") column += Number(params === "" ? 1 : params);
+		else if (command === "G") column = Math.max(0, Number(params === "" ? 1 : params) - 1);
+		else if (command === "J" && (params === "" || params === "0")) {
+			lines[row] = (lines[row] ?? "").slice(0, column);
+			for (let index = row + 1; index < lines.length; index++) lines[index] = "";
+		} else if (command === "J" && params === "2") for (let index = screenTop(); index < lines.length; index++) lines[index] = "";
 		else if (command === "J" && params === "3") {
 			const top = screenTop();
 			lines.splice(0, top);