@effected/cli 0.25.0 → 0.27.0

package/CliLinks.js

@@ -1,153 +0,0 @@
-import { sanitize } from "./Fmt.js";
-import { isAllowedLinkUrl } from "./internal/linkScheme.js";
-import { DRIVE, UNC, encodeForOsc8, fileUrlPath } from "./internal/linkTarget.js";
-import { Config, Context, Effect, FileSystem, Layer, Option, Path } from "effect";
-import { CurrentRuntimeEnv } from "@effected/env";
-import { Walker } from "@effected/walker";
-
-// src/CliLinks.ts
-const MODES = [
-	"auto",
-	"vscode",
-	"file",
-	"off"
-];
-const parseSetting = (raw) => MODES.find((mode) => mode === raw.trim().toLowerCase());
-/** A URL with its control characters and line breaks removed: none is legal in one, and each could end an OSC 8 early. */
-const cleanUrl = (url) => sanitize(url).replace(/[\r\n]/g, "");
-const makeTarget = (mode, absolute) => (target) => {
-	if ("url" in target) {
-		const url = cleanUrl(target.url);
-		return url === "" || !isAllowedLinkUrl(url) ? Option.none() : Option.some(url);
-	}
-	if (mode === "off") return Option.none();
-	const resolved = absolute(target.file);
-	if (resolved === void 0) return Option.none();
-	const path = fileUrlPath(resolved);
-	if (path === void 0) return Option.none();
-	if (mode === "file") return Option.some(`file://${path}`);
-	const position = target.line === void 0 ? "" : target.col === void 0 ? `:${target.line}` : `:${target.line}:${target.col}`;
-	return Option.some(`vscode://file${path}${position}`);
-};
-const isDirectory = (fs, path) => fs.stat(path).pipe(Effect.map((info) => info.type === "Directory"), Effect.orElseSucceed(() => false));
-const exists = (fs, path) => fs.exists(path).pipe(Effect.orElseSucceed(() => false));
-/**
-* The nearest directory, from `cwd` up, that holds `.git` or `pnpm-workspace.yaml`.
-*
-* It looks at `cwd` and then climbs at most {@link MAX_ASCENT} directories, through `Walker.ascend`, which also stops
-* where `dirname` reaches a fixpoint (the filesystem root). `Walker.findRoot` absorbs a failed probe as "not a root",
-* so one unreadable directory never hides a root above it. `None` when there is none.
-*/
-const findRoot = (fs, path, cwd) => Walker.ascend(cwd, { maxDepth: 65 }).pipe(Effect.provideService(Path.Path, path), Effect.flatMap((directories) => Walker.findRoot(directories, (directory) => Effect.gen(function* () {
-	return (yield* exists(fs, path.join(directory, ".git"))) || (yield* exists(fs, path.join(directory, "pnpm-workspace.yaml")));
-}))));
-const readOption = (name) => Config.option(Config.String(name)).pipe(Effect.orElseSucceed(() => Option.none()));
-const build = (options, ambient) => Effect.gen(function* () {
-	const runtime = yield* CurrentRuntimeEnv;
-	const raw = options.envVar === void 0 ? "" : Option.getOrElse(yield* readOption(options.envVar), () => "").trim();
-	const fromEnv = parseSetting(raw);
-	if (options.envVar !== void 0 && raw !== "" && fromEnv === void 0) yield* Effect.logWarning(`${options.envVar}=${raw} is not one of ${MODES.join("|")}; ignoring it`);
-	const setting = fromEnv ?? options.editorLinks ?? "auto";
-	const pwd = options.cwd === void 0 ? yield* readOption("PWD") : Option.none();
-	const cwd = options.cwd ?? Option.getOrUndefined(pwd) ?? (Option.isSome(ambient.path) ? ambient.path.value.resolve(".") : void 0);
-	const path = Option.getOrUndefined(ambient.path);
-	const absolute = (file) => {
-		if (UNC.test(file)) return void 0;
-		if (DRIVE.test(file)) return file;
-		if (path === void 0) return file.startsWith("/") ? file : void 0;
-		if (path.isAbsolute(file)) return file;
-		return cwd === void 0 ? void 0 : path.resolve(cwd, file);
-	};
-	const mode = setting !== "auto" ? setting : Option.exists(runtime.terminal, (terminal) => terminal.name === "vscode") ? "vscode" : yield* Effect.gen(function* () {
-		if (Option.isNone(ambient.fs) || path === void 0 || cwd === void 0) return "file";
-		const root = yield* findRoot(ambient.fs.value, path, cwd);
-		const base = Option.getOrElse(root, () => cwd);
-		return (yield* isDirectory(ambient.fs.value, path.join(base, ".vscode"))) ? "vscode" : "file";
-	});
-	return {
-		mode,
-		target: makeTarget(mode, absolute)
-	};
-});
-/**
-* Editor-aware links for file targets: where a link to a file opens.
-*
-* @remarks
-* The mode is decided once, when the layer is built. `auto` is `vscode` when `CurrentRuntimeEnv.terminal` is
-* `vscode` (`TERM_PROGRAM=vscode`) or a `.vscode/` directory sits at the project root, and `file` otherwise. The
-* root is the nearest directory, from the working directory up, that holds `.git` or `pnpm-workspace.yaml`; the
-* climb is bounded, at most 64 directories above the working directory, and stops where `Path.dirname` reaches the
-* filesystem root. With no root, the working directory itself is checked.
-*
-* Whether a link is written at all is a separate question, answered by {@link CliLinks.linker}.
-*
-* @public
-*/
-var CliLinks = class CliLinks extends Context.Service()("@effected/cli/CliLinks") {
-	/**
-	* The links for the working directory, reading the filesystem for a `.vscode/` directory.
-	*
-	* @remarks
-	* A layer-returning function mints a fresh layer per call: call it once and bind the result to a constant.
-	*
-	* @param options - the setting, the environment variable that overrides it, and the working directory
-	*/
-	static layer = (options = {}) => Layer.effect(CliLinks, Effect.gen(function* () {
-		const fs = yield* FileSystem.FileSystem;
-		const path = yield* Path.Path;
-		return yield* build(options, {
-			fs: Option.some(fs),
-			path: Option.some(path)
-		});
-	}));
-	/**
-	* Links fixed to a mode, with no filesystem: a relative path has no link, since there is no working directory.
-	*
-	* @param mode - `vscode`, `file` or `off`
-	*/
-	static layerTest = (mode) => Layer.succeed(CliLinks, {
-		mode,
-		target: makeTarget(mode, (file) => file.startsWith("/") || DRIVE.test(file) ? file : void 0)
-	});
-	/**
-	* The function that writes a link: a target and a label in, the label out, wrapped in OSC 8 when it should be.
-	*
-	* @remarks
-	* It writes the hyperlink `ESC ] 8 ; ; URL ESC \ label ESC ] 8 ; ; ESC \` only when the stream's terminal can
-	* render it (`hyperlinks`) and the audience is not an agent, which never gets an escape of any kind; in every other
-	* case, and whenever the target has no URL, it returns the label unchanged. The URL has its control characters
-	* removed again here, so a hostile target cannot end the sequence early or start another, and a URL whose scheme is
-	* not one a link may have (`javascript:`, `data:`, and the like; the same list markdown uses) is the label alone. It is pure and cheap,
-	* which {@link RenderContext}'s `link` requires.
-	*
-	* @param options - the links, whether hyperlinks are available, and the audience
-	*/
-	static linker = (options) => (target, label) => {
-		if (!options.hyperlinks || options.audience === "agent") return label;
-		const url = options.links.target(target);
-		if (Option.isNone(url)) return label;
-		const written = encodeForOsc8(cleanUrl(url.value));
-		if (!isAllowedLinkUrl(written)) return label;
-		return `\u001B]8;;${written}\u001B\\${label}\u001B]8;;\u001B\\`;
-	};
-};
-/**
-* The links for {@link CliEnv.layer}: the same as {@link CliLinks.layer}, except that `FileSystem` and `Path` are
-* taken from the environment if it has them, not required.
-*
-* Without them there is no `.vscode/` to look for and no working directory to resolve a relative path against, so
-* `auto` is `vscode` only on the terminal signal. This keeps the requirements of `CliEnv.layer` and of every
-* `CliRuntime.main` overload unchanged.
-*
-* @internal
-*/
-const ambientLinksLayer = (options = {}) => Layer.effect(CliLinks, Effect.gen(function* () {
-	const fs = yield* Effect.serviceOption(FileSystem.FileSystem);
-	const path = yield* Effect.serviceOption(Path.Path);
-	return yield* build(options, {
-		fs,
-		path
-	});
-}));
-
-export { CliLinks, ambientLinksLayer };

package/CliLog.js

@@ -1,367 +0,0 @@
-import { sanitize } from "./Fmt.js";
-import { paintStyle } from "./internal/ansi.js";
-import { CliTheme } from "./CliTheme.js";
-import { scanAudience } from "./internal/scanAudience.js";
-import { TrustedLine, neutralizeJson } from "./internal/logSafety.js";
-import { makeCliLogger } from "./CliLogger.js";
-import { Level, passes } from "./internal/diagnostics.js";
-import { makeFileSink } from "./internal/fileSink.js";
-import { Cause, Config, Console, Context, Effect, Layer, LogLevel, Logger, Option, Path, References } from "effect";
-import { Audience, CurrentRuntimeEnv, TerminalEnv } from "@effected/env";
-import { CommandNeutralizer } from "@effected/github-commands";
-
-// src/CliLog.ts
-/** The most spaces a numeric `indent` writes. */
-const MAX_INDENT = 64;
-/** An indent as written before the glyph: spaces for a number, a string with nothing in it that is not text. */
-const indentOf = (indent) => {
-	if (indent === void 0) return "";
-	if (typeof indent === "number") return Number.isFinite(indent) && indent > 0 ? " ".repeat(Math.min(MAX_INDENT, Math.floor(indent))) : "";
-	return sanitize(indent).replace(/\r\n|\r|\n/g, "");
-};
-/** The accepted spellings of a level, lower-cased, to the level they mean. A `Map`, so no inherited key matches. */
-const LEVELS = /* @__PURE__ */ new Map([
-	["all", "All"],
-	["trace", "Trace"],
-	["debug", "Debug"],
-	["info", "Info"],
-	["warn", "Warn"],
-	["warning", "Warn"],
-	["error", "Error"],
-	["fatal", "Fatal"],
-	["none", "None"]
-]);
-/** A level's spelling, in any case, to the level it means. */
-const parseLevel = (text) => Option.fromUndefinedOr(LEVELS.get(text.toLowerCase()));
-const LEVEL_STYLES = {
-	FATAL: {
-		fg: "red",
-		bold: true
-	},
-	ERROR: { fg: "red" },
-	WARN: { fg: "yellow" },
-	INFO: { fg: "cyan" },
-	DEBUG: { fg: "blue" },
-	TRACE: { dim: true }
-};
-/** The diagnostics level: the option when given, else the env var, and the raw text when that is not a level. */
-const readLevel = (explicit, envVar) => Effect.gen(function* () {
-	if (explicit !== void 0) return {
-		level: explicit,
-		invalid: void 0
-	};
-	if (envVar === void 0) return {
-		level: "None",
-		invalid: void 0
-	};
-	const raw = yield* Config.option(Config.String(envVar)).pipe(Effect.orElseSucceed(() => Option.none()));
-	if (Option.isNone(raw) || raw.value === "") return {
-		level: "None",
-		invalid: void 0
-	};
-	const level = parseLevel(raw.value);
-	if (Option.isSome(level)) return {
-		level: level.value,
-		invalid: void 0
-	};
-	return {
-		level: "None",
-		invalid: `${envVar}=${raw.value} is not a log level (${[...LEVELS.keys()].join("|")}); ignoring it`
-	};
-});
-/**
-* Whether a record's line is neutralized: the `neutralize` option when it is a boolean, else whether the logging
-* fiber's `CurrentRuntimeEnv`, or `fallback` where the fiber has none, says GitHub Actions.
-*/
-const actionsDecision = (neutralize, fallback) => (fiber) => {
-	if (neutralize !== "auto") return neutralize;
-	const inFiber = Context.getOption(fiber.context, CurrentRuntimeEnv);
-	const runtime = Option.isSome(inFiber) ? inFiber : fallback;
-	return Option.contains(Option.flatMap(runtime, (env) => env.ci), "github-actions");
-};
-/**
-* Diagnostics kept apart from a program's output: a level, a format and a place to write.
-*
-* @remarks
-* Two kinds of line must never be silenced by a diagnostics default: the failure report
-* `CliRuntime.reportFailures` writes through `CliLogger`, and the `CliMessage` lines. This package therefore
-* never makes the diagnostics level a global switch. The diagnostics logger filters on its **own** threshold,
-* {@link CliLog.Level}, and writes to stderr only.
-*
-* `CliLog.layer` **owns the whole logger set**. It builds a `CliLogger` for ordinary log lines and the
-* diagnostics sink itself and replaces whatever was installed, without reading it, so there is no order to get
-* wrong. Use it instead of `CliLogger.layer`, not with it: `CliLogger.layer` alone is the no-diagnostics path,
-* and a `CliLogger.layer` layered on top would replace this layer's set.
-*
-* Effect drops a record below `MinimumLogLevel` before any logger runs, so to let a debug record reach the
-* diagnostics logger `MinimumLogLevel` has to be lowered. `CliLog.layer` does that only when the
-* diagnostics level is below the ambient minimum, and in the same step floors the `CliLogger` it built at the
-* minimum it had, so it never prints a record the diagnostics level alone let through. A failure report is
-* written outside the scope core's `--log-level` flag sets, so `--log-level none` does not silence it either.
-*
-* `format: "auto"`, the default, decides by the audience alone, at build time and at runtime alike: NDJSON for an
-* agent or a CI, the pretty line for a human, whatever stderr's terminal state. A human piping stderr therefore gets
-* plain lines (without escapes unless stderr is a colour terminal); pass `format: "json"` for machine-readable logs.
-*
-* The text a program logs is sanitised before anything is painted in the pretty line (the message, the component and an
-* error's cause lose their escape sequences and control characters), and under GitHub Actions, where
-* `CurrentRuntimeEnv` in the logging fiber's context says so, a line the runner would read as a workflow command is
-* neutralized. An NDJSON record is not safe merely because `JSON.stringify` escapes control characters: the runner's
-* legacy parser reads `##[` anywhere in a line, so under Actions it is written as the JSON escape `#\u0023[`, which
-* decodes to the identical text. The file sink's lines are not read by the runner and are written as they are.
-*
-* `CurrentRuntimeEnv` is read from the logging fiber's context, and where that has none, from the `runtimeEnv` option,
-* else from the layer's own build context (captured if present, never required), so a host that builds the layer over
-* its environment, or names it with `runtimeEnv`, neutralizes every record. A record with none of the three (a program
-* with no `CurrentRuntimeEnv` anywhere) is sanitised but not neutralized, unless the `neutralize` option says otherwise.
-*
-* Core's `--log-level` flag sets `MinimumLogLevel` inside the command. While it is set to something other than
-* the value this layer installed, the diagnostics logger follows the flag instead of its own level: it writes
-* every record that reaches it. The `CliLogger` prints the same record too, so a record at or above the ambient
-* minimum is written twice, once plain and once to the diagnostics sink. Stderr is therefore not pure NDJSON while
-* diagnostics are on: a parser reads the lines that start with `{`.
-*
-* One edge: a `--log-level` value that EQUALS the level this layer installed cannot be told from no flag, so the
-* sink keeps filtering on its own level rather than following the flag. The plain `CliLogger` prints those records
-* regardless.
-*
-* @example
-* ```ts
-* import { CliRuntime } from "@effected/cli"
-* import { NodeRuntime, NodeServices } from "@effect/platform-node"
-*
-* // `env.log` makes `main` install `CliLog.layer`: set MYTOOL_LOG_LEVEL=debug to get diagnostics on stderr.
-* NodeRuntime.runMain(
-*   CliRuntime.main(program, {
-*     platform: NodeServices.layer,
-*     env: { audienceEnvVar: "MYTOOL_AUDIENCE", log: { envVar: "MYTOOL_LOG_LEVEL" } },
-*   }),
-* )
-* ```
-*
-* @public
-*/
-var CliLog = class CliLog {
-	constructor() {}
-	/**
-	* The diagnostics threshold. Defaults to `None`, silent.
-	*
-	* @remarks
-	* `CliLog.layer` sets it from the environment variable. A scope may raise it to narrow the output; it
-	* cannot lower it below the level the layer installed, because Effect has already dropped those records.
-	*/
-	static Level = Level;
-	/**
-	* Read a log level the way `CliLog.layer` reads its environment variable: `Option.some` of the level, or
-	* `Option.none()` when the text is not one.
-	*
-	* @remarks
-	* Case-insensitive, and not trimmed. The spellings are `all`, `trace`, `debug`, `info`, `warn` (or `warning`),
-	* `error`, `fatal` and `none`. For a host that reads a level from its own flag or config and wants the same answer
-	* the layer would give.
-	*
-	* @example
-	* ```ts
-	* CliLog.parseLevel("WARNING") // Option.some("Warn")
-	* CliLog.parseLevel("loud") // Option.none()
-	* ```
-	*
-	* @param text - the level's spelling
-	*/
-	static parseLevel(text) {
-		return parseLevel(text);
-	}
-	static layer(options = {}) {
-		const file = "file" in options ? options.file : void 0;
-		const format = options.format ?? "auto";
-		return Layer.unwrap(Effect.gen(function* () {
-			const audience = format === "auto" ? yield* Audience : void 0;
-			const terminal = format === "json" ? void 0 : yield* TerminalEnv;
-			const { level, invalid } = yield* readLevel(options.level, options.envVar);
-			const ambient = yield* References.MinimumLogLevel;
-			const captured = yield* Effect.serviceOption(CurrentRuntimeEnv);
-			const fallback = options.runtimeEnv === void 0 ? captured : Option.some(options.runtimeEnv);
-			const underActionsIn = actionsDecision(options.neutralize ?? "auto", fallback);
-			const color = terminal?.stderr.color ?? "none";
-			const isPretty = (record) => {
-				if (format !== "auto") return format === "pretty";
-				const inForce = Context.getOption(record.fiber.context, Audience);
-				return (Option.isSome(inForce) ? inForce.value.kind : audience?.kind) === "human";
-			};
-			const lowered = LogLevel.isLessThan(level, ambient) ? level : ambient;
-			const isLowered = lowered !== ambient;
-			const render = (record) => {
-				const underActions = underActionsIn(record.fiber);
-				if (!isPretty(record)) {
-					const json = Logger.formatJson.log(record);
-					return underActions ? neutralizeJson(json) : json;
-				}
-				const annotations = record.fiber.getRef(References.CurrentLogAnnotations);
-				const component = annotations.component === void 0 ? "" : ` [${sanitize(String(annotations.component))}]`;
-				const message = sanitize(Array.isArray(record.message) ? record.message.map(String).join(" ") : String(record.message));
-				const name = record.logLevel.toUpperCase();
-				const levelText = paintStyle(LEVEL_STYLES[name] ?? {}, color, name);
-				const cause = record.cause.reasons.length > 0 ? `\n${sanitize(Cause.pretty(record.cause))}` : "";
-				const line = `${record.date.toISOString().slice(11, 23)} ${levelText}${component} ${message}${cause}`;
-				return underActions ? CommandNeutralizer.text(line) : line;
-			};
-			const sink = Logger.make((record) => {
-				if (!passes(record, lowered)) return;
-				record.fiber.getRef(Console.Console).error(render(record));
-			});
-			const floor = (inner) => isLowered ? Logger.make((record) => {
-				const current = record.fiber.getRef(References.MinimumLogLevel);
-				const threshold = current === lowered ? ambient : current;
-				if (LogLevel.isGreaterThanOrEqualTo(record.logLevel, threshold)) inner.log(record);
-			}) : inner;
-			const cliLogger = floor(makeCliLogger(options.logger, underActionsIn));
-			const extras = (options.extraLoggers ?? []).map(floor);
-			if (invalid !== void 0) yield* Effect.logWarning(invalid).pipe(Effect.provideService(Logger.CurrentLoggers, /* @__PURE__ */ new Set([cliLogger])));
-			return Layer.mergeAll(Layer.succeed(CliLog.Level, level), isLowered ? Layer.succeed(References.MinimumLogLevel, lowered) : Layer.empty, Layer.effect(Logger.CurrentLoggers, Effect.gen(function* () {
-				const loggers = [
-					...options.plainLogger === false ? [] : [cliLogger],
-					sink,
-					...extras
-				];
-				if (file !== void 0) {
-					const target = "path" in file ? Option.some(file.path) : yield* Config.option(Config.String(file.envVar)).pipe(Effect.orElseSucceed(() => Option.none()));
-					if (Option.isSome(target) && target.value !== "") {
-						const location = yield* Path.Path;
-						loggers.push(yield* makeFileSink(location.resolve(target.value), lowered, underActionsIn));
-					}
-				}
-				return new Set(loggers);
-			})));
-		}));
-	}
-	/**
-	* Log a status line: its glyph painted through the theme, then `text`, at a level that follows the status.
-	*
-	* @remarks
-	* The line goes through the logger, so it is a diagnostic like any `Effect.log*` call: filtered by the level in
-	* force (`--log-level`, `CliLog.Level`), routed by `CliLogger`'s `stderrFrom` (stderr by default) and neutralized
-	* under GitHub Actions. What differs is the glyph: the logger sanitises every line a program logs, which strips a
-	* colour a program painted itself, so a glyph on the log channel was always drawn bare. Here the kit paints it and
-	* marks the line as its own, so the plain `CliLogger` line keeps the colour, while `text` is still sanitised:
-	* escape sequences and control characters in it are removed, as in every line the kit writes.
-	*
-	* The glyph is painted with stderr's theme (where diagnostics go) through {@link CliTheme.forAudience}, so an agent
-	* gets it unpainted, and an `Audience` is read only when provided, so it stays out of the requirements. ASCII glyphs
-	* give the status's ASCII form. A diagnostics record carries the line as its message as any record does: the `CliLog`
-	* sink's pretty line sanitises it (the glyph is drawn bare there), and NDJSON keeps it, JSON-escaped.
-	*
-	* The level defaults to the status's rank in `vocab`: `Error` at or above `failure`'s, `Warn` at or above
-	* `warning`'s, `Info` below, so a custom status follows its own rank. Pass `level` to choose it, and `indent` (a
-	* number of spaces, or a string, sanitised) to start the line inside an indented block: `    ✗ error   x: red`.
-	*
-	* @example
-	* ```ts
-	* import { CliLog, Status } from "@effected/cli"
-	*
-	* // ✗ in the failure colour, then the message: on stderr, filtered by the log level.
-	* const reportError = (resource: string, message: string) =>
-	*   CliLog.status(Status.core, "failure", `${resource}: ${message}`)
-	* ```
-	*
-	* @param vocab - the vocabulary the status belongs to
-	* @param name - the status
-	* @param text - the text after the glyph, sanitised
-	* @param options - the level to log at, and the indent before the glyph
-	*/
-	static status = (vocab, name, text, options) => Effect.gen(function* () {
-		const audience = yield* Effect.serviceOption(Audience);
-		const theme = CliTheme.forAudience((yield* CliTheme).forStream("stderr"), Option.isSome(audience) ? audience.value.kind : void 0);
-		const line = `${indentOf(options?.indent)}${theme.status(vocab, name, sanitize(text))}`;
-		const core = vocab;
-		const rank = vocab.def(name).rank;
-		const level = options?.level ?? (rank >= core.def("failure").rank ? "Error" : rank >= core.def("warning").rank ? "Warn" : "Info");
-		yield* Effect.logWithLevel(level)(line).pipe(Effect.provideService(TrustedLine, true));
-	});
-	/**
-	* Mark the log records an effect emits as coming from `name`.
-	*
-	* @remarks
-	* Shown as `[name]` in pretty output and as `annotations.component` in NDJSON.
-	*
-	* @param name - the component
-	*/
-	static component = (name) => (self) => Effect.annotateLogs(self, "component", name);
-};
-/**
-* The audience while the platform builds, from what needs no platform: a flag in `argv` (the rule `CliAudience` reads
-* argv with), else the override variable, else detection from the environment. No terminal is consulted. Silent: the
-* environment layer warns about an invalid override value itself, once.
-*/
-const buildTimeAudience = (argv, audienceEnvVar, detected) => {
-	const { given, conflict } = scanAudience(argv ?? []);
-	const [flagged] = given;
-	if (!conflict && flagged !== void 0) return Effect.succeed(flagged);
-	return Effect.map(Audience, (audience) => audience.kind).pipe(Effect.provide(Audience.layer(audienceEnvVar === void 0 ? void 0 : { envVar: audienceEnvVar }).pipe(Layer.provide(Layer.succeed(CurrentRuntimeEnv, detected)))), Effect.provideService(Logger.CurrentLoggers, /* @__PURE__ */ new Set()));
-};
-/** What the build-time loggers decide from, read once: the format and the runtime environment to neutralize by. */
-const buildTimeDecision = (options, audienceEnvVar) => Effect.gen(function* () {
-	const detected = yield* Effect.provide(CurrentRuntimeEnv, CurrentRuntimeEnv.layer);
-	const format = options.format ?? "auto";
-	return {
-		ndjson: format === "json" || format === "auto" && (yield* buildTimeAudience(options.argv, audienceEnvVar, detected)) !== "human",
-		runtimeEnv: options.runtimeEnv ?? detected
-	};
-});
-/**
-* The logger the platform is built under by `CliRuntime.main` with `env.log`: the log level and env var apply to
-* what the platform logs while it builds, too.
-*
-* @remarks
-* With `format: "json"`, or `auto` when the build-time audience (`argv`, the override variable, detection) is an
-* agent or a CI, it is the full `CliLog.layer` in NDJSON (that format needs neither the audience nor the terminal,
-* which the platform has not built yet), without the file sink, whose `FileSystem` the platform provides. Otherwise it
-* is the plain `CliLogger`, with `MinimumLogLevel` lowered to the resolved level. Either way it neutralizes under
-* GitHub Actions from the detected environment. The level is resolved silently: the program's own `CliLog.layer` warns
-* about an invalid value, once.
-*
-* @internal
-*/
-const platformLogLayer = (options, audienceEnvVar) => Layer.unwrap(Effect.gen(function* () {
-	const { level } = yield* readLevel(options.level, options.envVar);
-	const ambient = yield* References.MinimumLogLevel;
-	const { ndjson, runtimeEnv } = yield* buildTimeDecision(options, audienceEnvVar);
-	if (ndjson) return CliLog.layer({
-		level,
-		format: "json",
-		...options.plainLogger === void 0 ? {} : { plainLogger: options.plainLogger },
-		...options.logger === void 0 ? {} : { logger: options.logger },
-		...options.extraLoggers === void 0 ? {} : { extraLoggers: options.extraLoggers },
-		...options.neutralize === void 0 ? {} : { neutralize: options.neutralize },
-		runtimeEnv
-	});
-	return Layer.merge(Logger.layer([makeCliLogger(options.logger, actionsDecision(options.neutralize ?? "auto", Option.some(runtimeEnv)))]), LogLevel.isLessThan(level, ambient) ? Layer.succeed(References.MinimumLogLevel, level) : Layer.empty);
-}));
-/**
-* The logger `CliRuntime.main` builds the environment layer under: one line per record, in the build-time format.
-*
-* @remarks
-* What the environment layer logs is a configuration error (an invalid audience override, which interpolates the
-* variable's value), so it is never silenced and never written twice: NDJSON alone for an agent or a CI (`json`, or
-* `auto` for that build-time audience), a plain `CliLogger` line otherwise, whatever `plainLogger` and the diagnostics
-* level say, and neutralized under GitHub Actions like the platform's lines. It goes to stderr alone, whatever
-* `stderrFrom` the program's `CliLogger` options raise, and never to `extraLoggers` or the file sink. Only this
-* logger is pinned to stderr: the platform's build-time logger keeps the host's `stderrFrom`. It floors at `Warning` and installs no
-* `MinimumLogLevel`, so `CliLog.layer`'s own build, which shares this context, reads the ambient minimum.
-*
-* @internal
-*/
-const envBuildLogLayer = (options, audienceEnvVar) => Layer.unwrap(Effect.gen(function* () {
-	const { ndjson, runtimeEnv } = yield* buildTimeDecision(options, audienceEnvVar);
-	const underActions = actionsDecision(options.neutralize ?? "auto", Option.some(runtimeEnv));
-	if (!ndjson) return Logger.layer([makeCliLogger({
-		...options.logger,
-		stderrFrom: "All"
-	}, underActions)]);
-	return Logger.layer([Logger.make((record) => {
-		if (!LogLevel.isGreaterThanOrEqualTo(record.logLevel, "Warn")) return;
-		const json = Logger.formatJson.log(record);
-		record.fiber.getRef(Console.Console).error(underActions(record.fiber) ? neutralizeJson(json) : json);
-	})]);
-}));
-
-export { CliLog, envBuildLogLayer, platformLogLayer };

package/CliLogger.js

@@ -1,91 +0,0 @@
-import { sanitize } from "./Fmt.js";
-import { TrustedLine, sanitizeParts, underActionsIn } from "./internal/logSafety.js";
-import { Console, LogLevel, Logger, References } from "effect";
-import { CommandNeutralizer } from "@effected/github-commands";
-
-// src/CliLogger.ts
-const defaultRender = (message) => Array.isArray(message) ? message.map(String).join(" ") : String(message);
-/**
-* A `Logger` that renders CLI output rather than service logs: no timestamp, level or fiber id, with every level
-* going to stderr by default so stdout carries only what the program writes.
-*
-* @remarks
-* Effect's default logger emits `[00:33:56.619] INFO (#2): message`. That is
-* the right shape for a long-running service being scraped and the wrong one
-* for a tool a person is watching: the timestamp, level and fiber id are noise
-* in front of output a human is reading, and they make a formatted block — a
-* permissions table, a summary — unreadable.
-*
-* **A program that never installs a CLI logger looks correct in review and
-* ships timestamps to its users**, so install this one at the program's
-* boundary.
-*
-* It writes through the `Console` reference read off the logging fiber,
-* synchronously, as core's own default logger does: `Logger.make` takes a
-* synchronous callback, and a `Stdio` sink write is an `Effect` a logger cannot
-* `yield*`. `Console.Console` is a `Context.Reference`, so it never appears in
-* `R`, and a test swaps the reference rather than stubbing a global.
-*
-* @example
-* ```ts
-* import { CliLogger } from "@effected/cli"
-* import { Console, Effect } from "effect"
-*
-* const program = Effect.gen(function* () {
-*   yield* Effect.log("synced 3 repos")    // stderr, no timestamp — a diagnostic
-*   yield* Console.log("3 repos synced")   // stdout — the program's actual output
-*   yield* Effect.logError("one failed")   // stderr
-* })
-*
-* program.pipe(Effect.provide(CliLogger.layer()))
-* ```
-*
-* `stderrFrom` defaults to `"All"`: a CLI's stdout is its product, so every
-* log level is a diagnostic unless a consumer narrows the threshold. Write
-* program output with `Console.log`, never `Effect.log`. Pass
-* `stderrFrom: "Error"` for a tool whose output *is* its log lines.
-*
-* @public
-*/
-var CliLogger = class CliLogger {
-	constructor() {}
-	/**
-	* The logger itself, for composing into an existing `Logger.layer` set.
-	*
-	* @remarks
-	* Prefer {@link CliLogger.layer}. Reach for this only when you are building
-	* the logger set yourself and want this one among several.
-	*/
-	static make = (options = {}) => makeCliLogger(options);
-	/**
-	* Replace the default logger with this one.
-	*
-	* @remarks
-	* `Logger.layer` **replaces** rather than merges, so nothing is emitted twice.
-	*
-	* Merge this into the layer you provide to the whole program rather than
-	* providing it beneath: merged, it also covers lines emitted during layer
-	* construction, which is exactly where a startup failure prints.
-	*/
-	static layer = (options = {}) => Logger.layer([CliLogger.make(options)]);
-};
-/**
-* `CliLogger.make`, with the neutralizing decision as a parameter: `CliLog.layer` passes its own (the fiber's
-* `CurrentRuntimeEnv`, else the one captured at build, or its `neutralize` option), so its plain line and its
-* diagnostics line are neutralized alike.
-*
-* @internal
-*/
-const makeCliLogger = (options = {}, underActions = underActionsIn) => {
-	const custom = options.render;
-	const render = custom ?? defaultRender;
-	const stderrFrom = options.stderrFrom ?? "All";
-	return Logger.make(({ fiber, logLevel, message }) => {
-		const console = fiber.getRef(Console.Console);
-		const write = fiber.getRef(References.LogToStderr) || LogLevel.isGreaterThanOrEqualTo(logLevel, stderrFrom) ? console.error : console.log;
-		const rendered = fiber.getRef(TrustedLine) ? render(message) : custom === void 0 ? sanitize(render(message)) : render(sanitizeParts(message));
-		write(underActions(fiber) ? CommandNeutralizer.text(rendered) : rendered);
-	});
-};
-
-export { CliLogger, makeCliLogger };