@effected/cli 0.26.0 → 0.28.0

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@effected/cli",
-	"version": "0.26.0",
+	"version": "0.28.0",
 	"private": false,
 	"description": "The effected command: the tool's command tree on the kit's front-end runtime",
 	"keywords": [
@@ -43,12 +43,19 @@
 	},
 	"dependencies": {
 		"@effect/platform-node": "~4.1.2",
-		"@effected/cli-kit": "^0.26.0",
-		"@effected/env": "^0.10.0",
-		"@effected/glob": "^0.18.0",
-		"@effected/kit": "^0.12.0",
-		"@effected/walker": "^0.25.0",
-		"effect": "~4.1.2"
+		"@effected/cli-kit": "^0.27.1",
+		"@effected/engine": "0.14.0",
+		"@effected/env": "^0.11.0",
+		"@effected/glob": "^0.20.0",
+		"@effected/kit": "^0.13.0",
+		"@effected/walker": "^0.26.0",
+		"effect": "~4.1.2",
+		"ink": "^8.0.0",
+		"react": "^19.3.0"
+	},
+	"peerDependencies": {
+		"@types/node": "^26.6.0",
+		"typescript": "7.1.0-beta || 7.1.1-rc || >=7.1.0 <8"
 	},
 	"engines": {
 		"node": ">=24.11.0"

package/render/ActionDoc.js

@@ -0,0 +1,66 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/ActionDoc.ts
+const formatBytes = (bytes) => {
+	if (bytes < 1024) return `${bytes} B`;
+	return bytes < 1048576 ? `${(bytes / 1024).toFixed(1)} KB` : `${(bytes / 1048576).toFixed(1)} MB`;
+};
+const issueLine = (issue) => `${issue.code}: ${issue.message}`;
+/** One line for an entry, with only the first line of its error: a failed load's message can carry a require stack. */
+const entryLine = (entry) => {
+	if (entry.stats === void 0) return `✗ ${(entry.error ?? "failed").split("\n")[0]}`;
+	const { entry: name, size, duration, outputPath } = entry.stats;
+	return `✓ ${name}: ${formatBytes(size)} (${duration}ms) → ${outputPath}`;
+};
+const summaryOf = ({ build }) => `built ${build.entries.filter((entry) => entry.success).length} entries in ${build.duration}ms`;
+/** A warning as its first line, indented under the entry it belongs to. */
+const warningLines = (entry) => (entry.warnings ?? []).map((warning) => `  ${warning.trim().split("\n")[0]}`);
+/**
+* An action build for a reader: validation's errors, its warnings, a line per entry, then the total.
+*
+* @public
+*/
+var ActionDoc = class ActionDoc {
+	constructor() {}
+	/** The report as plain lines, the total last, for a log. */
+	static lines(result) {
+		return [
+			...result.validation.errors.map(issueLine),
+			...result.validation.warnings.map(issueLine),
+			...result.build.entries.flatMap((entry) => [entryLine(entry), ...warningLines(entry)]),
+			summaryOf(result)
+		];
+	}
+	/**
+	* The report as a `Doc`.
+	*
+	* @remarks
+	* Every line goes in as a `Doc.text` run, which is data: the renderers remove escape and control characters from it,
+	* so an error quoting untrusted text cannot repaint the terminal.
+	*/
+	static render(result) {
+		const rows = [
+			...result.validation.errors.map((issue) => Doc.text(issueLine(issue), "error")),
+			...result.validation.warnings.map((issue) => Doc.text(issueLine(issue), "warning")),
+			...result.build.entries.flatMap((entry) => [Doc.text(entryLine(entry), entry.success ? "success" : "error"), ...warningLines(entry).map((line) => Doc.text(line, "warning"))]),
+			Doc.text(summaryOf(result), result.build.success ? "success" : "error")
+		];
+		return Doc.lines(rows, { wrap: false });
+	}
+	/** The report for a GitHub step summary, in a code block. */
+	static markdown(result) {
+		const body = ActionDoc.lines(result).join("\n");
+		const longest = (body.match(/`+/g) ?? []).reduce((length, run) => Math.max(length, run.length), 2);
+		const fence = "`".repeat(longest + 1);
+		return [
+			"### effected action build",
+			"",
+			fence,
+			body,
+			fence,
+			""
+		].join("\n");
+	}
+};
+
+export { ActionDoc };

package/render/DiffDoc.js

@@ -0,0 +1,51 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/DiffDoc.ts
+/**
+* How many diff rows `DiffDoc.render` shows per schema before it cuts the rest with a "… N more lines" tail: a
+* screenful of context that keeps a many-schema report readable.
+*
+* @public
+*/
+const DEFAULT_MAX_DIFF_LINES = 40;
+const expandTabs = (text) => text.replaceAll("	", "  ");
+/**
+* A schema's line diff as a `Doc`, in git's shape: an `@@ path @@` header, context lines as they are, removes in the
+* `error` token and adds in the `success` token.
+*
+* @remarks
+* Each tab in a line's text is expanded to two spaces, so a tab-indented document keeps its shape. Every line's text
+* goes into the document as a `Doc.text` run, which is data: the renderers remove escape and control characters from it
+* and never read it as markup, so a diff of untrusted text cannot repaint the terminal.
+* A document with more than one hunk separates them with a muted `@@ -a,b +c,d @@` range row. The cap counts every
+* row after the header (diff lines, range rows and `` markers) and the tail names exactly
+* how many were cut. Nothing here loads Ink or React.
+*
+* @public
+*/
+var DiffDoc = class {
+	constructor() {}
+	/**
+	* @param path - the schema file the diff is for, shown in the header
+	* @param diff - the diff
+	* @param options - `maxLines`, the cap on shown rows
+	*/
+	static render(path, diff, options) {
+		const cap = Math.max(0, Math.floor(options?.maxLines ?? 40));
+		const rows = [];
+		diff.hunks.forEach((hunk) => {
+			if (diff.hunks.length > 1) rows.push(Doc.text(`@@ -${hunk.oldStart},${hunk.oldLines} +${hunk.newStart},${hunk.newLines} @@`, "muted"));
+			for (const line of hunk.lines) {
+				const text = expandTabs(line.text);
+				rows.push(line.kind === "add" ? Doc.text(`+${text}`, "success") : line.kind === "remove" ? Doc.text(`-${text}`, "error") : Doc.text(` ${text}`));
+				if (line.noNewline === true) rows.push(Doc.text("\", "muted"));
+			}
+		});
+		const hidden = rows.length - cap;
+		const shown = hidden > 0 ? rows.slice(0, cap) : rows;
+		if (hidden > 0) shown.push(Doc.text(`… ${hidden} more ${hidden === 1 ? "line" : "lines"}`, "muted"));
+		return Doc.lines([Doc.text(`@@ ${path} @@`, "accent"), ...shown], { wrap: false });
+	}
+};
+
+export { DiffDoc };

package/render/InitDoc.js

@@ -0,0 +1,35 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/InitDoc.ts
+/** What is left to do, as lines: the packages to add, the module type, and the build. */
+const nextSteps = (result) => [
+	...result.missingDependencies.length > 0 ? [`add dependencies: ${result.missingDependencies.join(" ")}`] : [],
+	...result.missingDevDependencies.length > 0 ? [`add devDependencies: ${result.missingDevDependencies.join(" ")}`] : [],
+	...result.typeModule ? [] : ["set \"type\": \"module\" in package.json"],
+	"then run: effected action build"
+];
+const fileLine = (result, file) => `${result.overwritten.includes(file) ? "replaced" : "wrote"} ${file}`;
+/**
+* An `action init` for a reader: a line per file written, then what is left to do.
+*
+* @public
+*/
+var InitDoc = class {
+	constructor() {}
+	/** The report as plain lines, for a log. */
+	static lines(result) {
+		return [...result.written.map((file) => fileLine(result, file)), ...nextSteps(result)];
+	}
+	/**
+	* The report as a `Doc`.
+	*
+	* @remarks
+	* Every line goes in as a `Doc.text` run, which is data, so a name echoed back cannot repaint the terminal.
+	*/
+	static render(result) {
+		const rows = [...result.written.map((file) => Doc.text(fileLine(result, file), result.overwritten.includes(file) ? "warning" : "success")), ...nextSteps(result).map((line) => Doc.text(line, "muted"))];
+		return Doc.lines(rows, { wrap: false });
+	}
+};
+
+export { InitDoc };

package/render/IssuesDoc.js

@@ -0,0 +1,73 @@
+import { Doc } from "@effected/cli-kit";
+
+// src/render/IssuesDoc.ts
+/** `file:line:col code text`, leaving out whichever parts the diagnostic does not have. */
+const lineOf = (diagnostic) => {
+	return [
+		...diagnostic.file === void 0 ? [] : [[
+			diagnostic.file,
+			diagnostic.line,
+			diagnostic.column
+		].filter((part) => part !== void 0).join(":")],
+		...diagnostic.code !== void 0 ? [diagnostic.code] : [],
+		diagnostic.text
+	].join(" ");
+};
+const summaryOf = (issues) => `built ${issues.package}: ${issues.errors.length} errors, ${issues.warnings.length} warnings, ${issues.suppressed.length} suppressed`;
+const summaryToken = (issues) => !issues.buildOk || issues.errors.length > 0 ? "error" : issues.warnings.length > 0 ? "warning" : "success";
+const fenceFor = (text) => {
+	const longest = (text.match(/`+/g) ?? []).reduce((length, run) => Math.max(length, run.length), 2);
+	return "`".repeat(longest + 1);
+};
+/**
+* A build's `issues.json` for a reader: errors, then warnings, then one summary line. Suppressed diagnostics are only
+* counted.
+*
+* @public
+*/
+var IssuesDoc = class {
+	constructor() {}
+	/** The report as plain lines, the summary last, for a log. */
+	static lines(issues) {
+		return [
+			...issues.errors.map(lineOf),
+			...issues.warnings.map(lineOf),
+			summaryOf(issues)
+		];
+	}
+	/**
+	* The report as a `Doc`.
+	*
+	* @remarks
+	* Every line goes in as a `Doc.text` run, which is data: the renderers remove escape and control characters from it,
+	* so a diagnostic quoting untrusted text cannot repaint the terminal.
+	*/
+	static render(issues) {
+		const rows = [
+			...issues.errors.map((diagnostic) => Doc.text(lineOf(diagnostic), "error")),
+			...issues.warnings.map((diagnostic) => Doc.text(lineOf(diagnostic), "warning")),
+			Doc.text(summaryOf(issues), summaryToken(issues))
+		];
+		return Doc.lines(rows, { wrap: false });
+	}
+	/** The report for a GitHub step summary: the failure, when there is one, and the diagnostics in a code block. */
+	static markdown(issues) {
+		const diagnostics = [...issues.errors, ...issues.warnings].map(lineOf).join("\n");
+		const fence = fenceFor(diagnostics);
+		return [
+			"### effected package build",
+			"",
+			summaryOf(issues),
+			...issues.failure !== void 0 ? ["", `Failed: ${issues.failure.message}`] : [],
+			...diagnostics !== "" ? [
+				"",
+				fence,
+				diagnostics,
+				fence
+			] : [],
+			""
+		].join("\n");
+	}
+};
+
+export { IssuesDoc };

package/version.js

@@ -6,6 +6,6 @@
 *
 * @public
 */
-const CLI_VERSION = "0.26.0";
+const CLI_VERSION = "0.28.0";
 
 export { CLI_VERSION };