@savvy-web/cli 3.4.3 → 3.5.1

package/README.md

@@ -54,7 +54,7 @@ npx savvy clean --globs dist,.turbo,coverage
 - `savvy clean` — removes build and cache artifacts (`dist`, `.turbo`, `coverage`, `node_modules`, `.rslib` by default) from every workspace package (leaves first) and the repo root (last); `--globs` to customize, `--dry-run` to preview.
 - `savvy commit` — the husky/Claude hook handlers (session-start, pre-commit-message, post-commit-verify).
 - `savvy changeset` — changeset lint, check, transform, version, config validation, and dependency changesets.
-- `savvy lint` — formatters for package.json, the pnpm workspace file and YAML.
+- `savvy lint` — formatters for package.json, the pnpm workspace file and YAML, plus `savvy lint text`, which fails files that contain a NUL byte or invalid UTF-8 (`--staged` checks the git index copy).
 - `savvy repos` — the vendored reference repos declared in `.repos/config.json`: `status` (with `--drift`), `sync`, `pin`, `add`, `note`, `remove`, `rename` and `restore`.
 
 ## Vendored repos are read-only

package/commands/changeset/commands/deps-regen.js

@@ -39,6 +39,16 @@ import { Console, Effect, Option } from "effect";
 * (the regen default) and protocol specifiers (`catalog:`/`workspace:`)
 * are resolved to concrete versions.
 *
+* **Dry-run reporting.** With `--dry-run` nothing is written or deleted, so
+* the human output is phrased as a plan (`Would delete N pure dependency
+* changeset(s):` / `Would write N dependency changeset(s):`) rather than the
+* real run's `✓ Deleted …` / `✓ Wrote …`. A real run reports what
+* `execute()` returned, not what the plan listed: deletes are tolerant, so a
+* planned delete that found nothing or could not remove the file is reported
+* as not removed. `--json`
+* emits the plan's fields plus an explicit `dryRun` boolean in both modes,
+* and a real run adds `execute()`'s `result`.
+*
 * @example
 * ```bash
 * savvy changeset deps regen
@@ -69,22 +79,48 @@ function runDepsRegen(cwd, base, pkg, dryRun, json) {
 			...Option.isSome(base) ? { base: base.value } : {},
 			...Option.isSome(pkg) ? { package: pkg.value } : {}
 		}).pipe(Effect.tapError(() => CliExit.set(1)));
-		if (!dryRun) yield* service.execute(plan);
-		if (json) yield* Console.log(JSON.stringify(plan, null, 2));
-		else yield* renderHumanPlan(plan);
+		const result = dryRun ? void 0 : yield* service.execute(plan);
+		if (json) yield* Console.log(JSON.stringify({
+			...plan,
+			dryRun,
+			...result ? { result } : {}
+		}, null, 2));
+		else yield* renderHumanPlan(plan, result);
 	});
 }
-function renderHumanPlan(plan) {
+/**
+* Render the plan for a person. A dry run (no `result`) changed nothing, so its
+* headings are plan-phrased and carry no `✓`. A real run reports what
+* `execute` actually did: deletes are tolerant, so a planned delete absent from
+* `result.deleted` was already gone or could not be removed, and is reported as
+* not removed, never as deleted.
+*/
+function renderHumanPlan(plan, result) {
 	return Effect.gen(function* () {
+		const dryRun = result === void 0;
 		if (plan.toDelete.length === 0 && plan.toWrite.length === 0) yield* Output.ok("No dependency changes to regenerate");
 		else {
-			if (plan.toDelete.length > 0) {
-				yield* Output.ok(`Deleted ${plan.toDelete.length} pure dependency changeset(s):`);
+			if (dryRun && plan.toDelete.length > 0) {
+				yield* Output.heading(`Would delete ${plan.toDelete.length} pure dependency changeset(s):`);
 				for (const entry of plan.toDelete) yield* Output.detail(`${entry.file}  (${entry.package})`);
 			}
-			if (plan.toWrite.length > 0) {
-				yield* Output.ok(`Wrote ${plan.toWrite.length} fresh dependency changeset(s):`);
-				for (const entry of plan.toWrite) yield* Output.detail(`+ ${entry.file}  (${entry.package} — ${entry.diff.rows.length} row${entry.diff.rows.length === 1 ? "" : "s"})`);
+			if (!dryRun) {
+				const deleted = new Set(result.deleted);
+				const removed = plan.toDelete.filter((entry) => deleted.has(entry.file));
+				const notRemoved = plan.toDelete.filter((entry) => !deleted.has(entry.file));
+				if (removed.length > 0) {
+					yield* Output.ok(`Deleted ${removed.length} pure dependency changeset(s):`);
+					for (const entry of removed) yield* Output.detail(`${entry.file}  (${entry.package})`);
+				}
+				if (notRemoved.length > 0) {
+					yield* Output.skip(`${notRemoved.length} planned deletion(s) not removed (already gone or undeletable):`);
+					for (const entry of notRemoved) yield* Output.detail(`${entry.file}  (${entry.package})`);
+				}
+			}
+			const writes = dryRun ? plan.toWrite : plan.toWrite.filter((entry) => result.written.includes(entry.file));
+			if (writes.length > 0) {
+				yield* dryRun ? Output.heading(`Would write ${writes.length} dependency changeset(s):`) : Output.ok(`Wrote ${writes.length} fresh dependency changeset(s):`);
+				for (const entry of writes) yield* Output.detail(`+ ${entry.file}  (${entry.package} — ${entry.diff.rows.length} row${entry.diff.rows.length === 1 ? "" : "s"})`);
 			}
 		}
 		if (plan.skippedMixed.length > 0) {

package/commands/lint/index.js

@@ -1,11 +1,12 @@
 import { runLintCheck } from "./check.js";
 import { runLintInit } from "./init.js";
 import { fmtCommand } from "./fmt.js";
+import { runLintText, textCommand } from "./text.js";
 import { Command } from "effect/cli";
 
 //#region src/commands/lint/index.ts
 /* v8 ignore start -- CLI registration; each command tested via exported handler */
-const _lintCommand = Command.make("lint").pipe(Command.withSubcommands([fmtCommand]), Command.withDescription("Code-quality: lint-staged config, checks, and in-place formatting"));
+const _lintCommand = Command.make("lint").pipe(Command.withSubcommands([fmtCommand, textCommand]), Command.withDescription("Code-quality: lint-staged config, checks, and in-place formatting"));
 /**
 * The `savvy lint` command group for use in Task B7 root assembly.
 *

package/commands/lint/text.js

@@ -0,0 +1,71 @@
+import { Output } from "../../internal/output.js";
+import { Argument, Command, Flag } from "effect/cli";
+import { CliExit } from "@effected/cli";
+import { Lint } from "@savvy-web/silk-effects";
+import { Effect } from "effect";
+
+//#region src/commands/lint/text.ts
+/**
+* `savvy lint text` — fail when a source file is not grep-visible text.
+*
+* @remarks
+* A NUL byte or invalid UTF-8 makes `grep`/`rg` silently skip a file, so a
+* search returns a false negative instead of an error (savvy-web/systems#388).
+* With file arguments the command checks those files (the lint-staged path,
+* `Lint.TextFiles.create`); with none it checks every git-tracked file matching
+* `Lint.TextFiles.glob`. `--staged` reads each file's bytes from the git
+* index instead of the working tree — what the lint-staged handler passes, so
+* a concurrent Biome `--write` on the worktree cannot race the read, and the
+* check sees exactly what the commit records. The classification itself lives in silk-effects, so
+* this command and the lint-staged handler cannot drift.
+*
+* @example
+* ```bash
+* savvy lint text                  # every tracked source/text file
+* savvy lint text src/a.ts docs/b.md
+* savvy lint text --staged src/a.ts   # the index copy, as lint-staged runs it
+* ```
+*
+* @internal
+*/
+/* v8 ignore start -- CLI option definitions */
+const filesArg = Argument.File("files", { mustExist: true }).pipe(Argument.withDescription("Files to check; omit to check every git-tracked source/text file"), Argument.variadic());
+const stagedFlag = Flag.Boolean("staged").pipe(Flag.withDescription("Read each file's staged content from the git index instead of the working tree"), Flag.withDefault(false));
+/**
+* Check `files` (or, when empty, every tracked file under `cwd`) and print one
+* line per finding; any finding sets exit code 1. Under `--staged`, every file
+* is still checked when one has no index entry: that file's read error is
+* logged to stderr, counted as failed, and also sets exit code 1. Exported for
+* tests.
+*
+* @internal
+*/
+const runLintText = (files, options = {}) => Effect.gen(function* () {
+	const staged = options.staged ?? false;
+	const targets = files.length > 0 ? files : yield* Lint.TextFiles.listTracked(options.cwd ?? ".", { staged });
+	const { findings, unreadable } = staged ? yield* Lint.TextFiles.checkStagedFiles(targets) : {
+		findings: yield* Lint.TextFiles.checkFiles(targets),
+		unreadable: []
+	};
+	for (const error of unreadable) yield* Effect.logError(error.message);
+	if (findings.length === 0 && unreadable.length === 0) {
+		yield* Output.ok(`${targets.length} ${targets.length === 1 ? "file is" : "files are"} grep-visible text`);
+		return findings;
+	}
+	for (const finding of findings) yield* Output.fail(`${finding.location}  ${finding.message}`);
+	const failedFiles = (/* @__PURE__ */ new Set([...findings.map((finding) => finding.path), ...unreadable.map((error) => error.path)])).size;
+	yield* Output.summary({
+		ok: targets.length - failedFiles,
+		fail: failedFiles
+	});
+	yield* CliExit.set(1);
+	return findings;
+});
+/** The `savvy lint text` subcommand. */
+const textCommand = Command.make("text", {
+	files: filesArg,
+	staged: stagedFlag
+}, ({ files, staged }) => runLintText(files, { staged })).pipe(Command.withDescription("Fail when a source file contains a NUL byte or is not valid UTF-8 (grep-invisible)"));
+
+//#endregion
+export { runLintText, textCommand };

package/index.d.ts

@@ -206,7 +206,7 @@ export declare function runLintInit(opts: {
  * errors from Effect's internal types. Task B7 should import and use this directly
  * as `Command.withSubcommands([lintCommand])` — the cast is for declaration emit only.
  */
-export declare const lintCommand: Command.Command<"lint", {}, {}, import("@effected/yaml").YamlParseError, never>;
+export declare const lintCommand: Command.Command<"lint", {}, {}, import("@effected/git").GitCommandError | import("@effected/git").NotARepositoryError | import("effect/PlatformError").PlatformError | import("@effected/git").UnknownRefError | import("@effected/yaml").YamlParseError, import("effect/process/ChildProcessSpawner").ChildProcessSpawner | import("@effected/cli").CliExit | import("effect/FileSystem").FileSystem | import("@effected/git").Git | import("effect/Path").Path | import("effect/Stdio").Stdio>;
 //#endregion
 //#region src/commands/repos/commands/status.d.ts
 /**

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@savvy-web/cli",
-	"version": "3.4.3",
+	"version": "3.5.1",
 	"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",
@@ -40,12 +40,12 @@
 		"@effected/cli": "^0.10.0",
 		"@effected/commands": "^0.10.0",
 		"@effected/engine": "^0.2.0",
-		"@effected/git": "^0.18.1",
+		"@effected/git": "^0.19.0",
 		"@effected/jsonc": "^0.14.0",
 		"@effected/templates": "^0.9.1",
-		"@effected/workspaces": "^0.30.1",
+		"@effected/workspaces": "^0.30.3",
 		"@effected/yaml": "^0.18.0",
-		"@savvy-web/silk-effects": "9.2.2",
+		"@savvy-web/silk-effects": "9.3.1",
 		"effect": "4.0.0-rc.118"
 	}
 }

package/version.js

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