@codefast/cli 0.3.14 → 0.3.15

package/dist/{lib/arrange/adapters/primary → domains/arrange/presentation}/cli/arrange.command.mjs

@@ -1,14 +1,11 @@
-import { AnalyzeDirectoryUseCaseToken, GroupFilePreviewPortToken, PrepareArrangeWorkspaceUseCaseToken, RunArrangeSyncUseCaseToken, SuggestCnGroupsUseCaseToken } from "../../../contracts/tokens.mjs";
-import { PresentAnalyzeReportPresenterToken } from "./presentation.tokens.mjs";
-import { arrangeAnalyzeDirectoryRequestSchema, arrangeSuggestGroupsRequestSchema, arrangeSyncRunRequestSchema } from "../../../presentation/arrange-cli.schema.mjs";
-import { exitCodeForArrangeSyncResult, formatArrangeGroupJsonOutput, formatArrangeSyncJsonOutput, presentArrangeSyncResult } from "../../../presentation/arrange-sync.presenter.mjs";
-import { CliLoggerToken, CliRuntimeToken } from "../../../../core/contracts/tokens.mjs";
-import { formatArrangeAnalyzeJsonOutput } from "../../../presentation/arrange-analyze.presenter.mjs";
-import { parseWithCliSchema } from "../../../../core/presentation/cli-schema.parser.mjs";
-import { consumeCliAppError } from "../../../../core/presentation/cli-executor.presenter.mjs";
-import { Option } from "commander";
+import { AnalyzeDirectoryUseCaseToken, PrepareArrangeWorkspaceUseCaseToken, PresentAnalyzeReportPresenterToken, PresentArrangeSyncResultPresenterToken, PresentGroupFilePreviewPresenterToken, RunArrangeSyncUseCaseToken, SuggestCnGroupsUseCaseToken } from "../../composition/tokens.mjs";
+import { CliExecutorToken, CliLoggerPortToken, CliRuntimeToken, CliSchemaParsingToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import "../../../../shell/domain/cli-exit-codes.domain.mjs";
+import { arrangeAnalyzeDirectoryRequestSchema, arrangeSuggestGroupsRequestSchema, arrangeSyncRunRequestSchema } from "../presenters/arrange-cli.schema.mjs";
+import { CLI_COMMAND_SLOT_NAME } from "../../../../shell/contracts/cli-command-slots.mjs";
+import { readOptionalPositionalArg } from "../../../../shell/domain/cli-positional-arg.value-object.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/adapters/primary/cli/arrange.command.ts
+//#region src/domains/arrange/presentation/cli/arrange.command.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -219,18 +216,18 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-function withClassNameOption() {
-	return new Option("--with-classname, --with-class-name", "Append className as final cn() argument").default(false);
-}
 _dec = injectable([
-	inject(CliLoggerToken),
+	inject(CliLoggerPortToken),
 	inject(CliRuntimeToken),
 	inject(PrepareArrangeWorkspaceUseCaseToken),
 	inject(AnalyzeDirectoryUseCaseToken),
 	inject(RunArrangeSyncUseCaseToken),
 	inject(SuggestCnGroupsUseCaseToken),
 	inject(PresentAnalyzeReportPresenterToken),
-	inject(GroupFilePreviewPortToken)
+	inject(PresentGroupFilePreviewPresenterToken),
+	inject(PresentArrangeSyncResultPresenterToken),
+	inject(CliSchemaParsingToken),
+	inject(CliExecutorToken)
 ]);
 let _ArrangeCommand;
 (class {
@@ -241,11 +238,14 @@ let _ArrangeCommand;
 	runArrangeSync;
 	suggestCnGroups;
 	presentAnalyzeReport;
-	groupFilePreview;
+	presentGroupFilePreview;
+	presentArrangeSyncResult;
+	schemaValidation;
+	cliExecutor;
 	static {
 		({c: [_ArrangeCommand, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(logger, runtime, prepareWorkspace, analyzeDirectory, runArrangeSync, suggestCnGroups, presentAnalyzeReport, groupFilePreview) {
+	constructor(logger, runtime, prepareWorkspace, analyzeDirectory, runArrangeSync, suggestCnGroups, presentAnalyzeReport, presentGroupFilePreview, presentArrangeSyncResult, schemaValidation, cliExecutor) {
 		this.logger = logger;
 		this.runtime = runtime;
 		this.prepareWorkspace = prepareWorkspace;
@@ -253,69 +253,210 @@ let _ArrangeCommand;
 		this.runArrangeSync = runArrangeSync;
 		this.suggestCnGroups = suggestCnGroups;
 		this.presentAnalyzeReport = presentAnalyzeReport;
-		this.groupFilePreview = groupFilePreview;
+		this.presentGroupFilePreview = presentGroupFilePreview;
+		this.presentArrangeSyncResult = presentArrangeSyncResult;
+		this.schemaValidation = schemaValidation;
+		this.cliExecutor = cliExecutor;
 	}
-	name = "arrange";
-	description = "Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)";
-	register(program) {
-		const arrange = program.command(this.name).description(this.description);
-		arrange.command("analyze").description("Report long strings, nested cn in tv(), and related findings").argument("[target]", "Directory or file (default: nearest package directory from cwd)").option("--json", "Print one JSON object on stdout instead of a human report", false).action((target, options) => this.executeAnalyze(target, options));
-		arrange.command("preview").description("Dry-run: print suggested replacements without writing files").argument("[target]", "Directory or file (default: nearest package directory from cwd)").addOption(withClassNameOption()).option("--cn-import <spec>", "Override module specifier when adding cn import").option("--json", "Print one JSON object on stdout (suppresses human progress)", false).action((target, opts) => this.executePreviewOrApply(false, target, opts));
-		arrange.command("apply").description("Apply grouping and cn-in-tv unwrap edits to files").argument("[target]", "Directory or file (default: nearest package directory from cwd)").addOption(withClassNameOption()).option("--cn-import <spec>", "Override module specifier when adding cn import").option("--json", "Print one JSON object on stdout (suppresses human progress)", false).action((target, opts) => this.executePreviewOrApply(true, target, opts));
-		arrange.command("group").description("Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)").argument("[tokens...]", "Class tokens (quote a single string if it contains spaces)").option("--tv", "Emit tv()-style array instead of cn() call", false).addOption(withClassNameOption()).option("--json", "Print one JSON object on stdout instead of plain lines", false).action((tokens, opts) => this.executeGroup(tokens, opts));
+	get definition() {
+		return {
+			name: CLI_COMMAND_SLOT_NAME.arrange,
+			description: "Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)",
+			children: [
+				{
+					name: "analyze",
+					description: "Report long strings, nested cn in tv(), and related findings",
+					route: [{
+						kind: "optionalPositional",
+						argumentTemplate: "[target]",
+						helpBlurb: "Directory or file (default: nearest package directory from cwd)"
+					}, {
+						kind: "booleanFlag",
+						flagPhrase: "--json",
+						helpBlurb: "Print one JSON object on stdout instead of a human report",
+						whenUnsetUses: false
+					}],
+					action: async (positionalPieces, typedLocalCarrier) => {
+						await this.performAnalyzeSubtree(readOptionalPositionalArg(positionalPieces[0]), { jsonCandidate: typedLocalCarrier.json });
+					}
+				},
+				{
+					name: "preview",
+					description: "Dry-run: print suggested replacements without writing files",
+					route: [
+						{
+							kind: "optionalPositional",
+							argumentTemplate: "[target]",
+							helpBlurb: "Directory or file (default: nearest package directory from cwd)"
+						},
+						{
+							kind: "synonymousBooleanAliases",
+							commaJoinedFlags: "--with-classname, --with-class-name",
+							helpBlurb: "Append className as final cn() argument"
+						},
+						{
+							kind: "stringPlaceholderFlag",
+							flagPhraseWithPlaceholder: "--cn-import <spec>",
+							helpBlurb: "Override module specifier when adding cn import"
+						},
+						{
+							kind: "booleanFlag",
+							flagPhrase: "--json",
+							helpBlurb: "Print one JSON object on stdout (suppresses human progress)",
+							whenUnsetUses: false
+						}
+					],
+					action: async (positionalPieces, typedLocalCarrier) => {
+						await this.performApplyOrPreviewSubtree(false, readOptionalPositionalArg(positionalPieces[0]), typedLocalCarrier);
+					}
+				},
+				{
+					name: "apply",
+					description: "Apply grouping and cn-in-tv unwrap edits to files",
+					route: [
+						{
+							kind: "optionalPositional",
+							argumentTemplate: "[target]",
+							helpBlurb: "Directory or file (default: nearest package directory from cwd)"
+						},
+						{
+							kind: "synonymousBooleanAliases",
+							commaJoinedFlags: "--with-classname, --with-class-name",
+							helpBlurb: "Append className as final cn() argument"
+						},
+						{
+							kind: "stringPlaceholderFlag",
+							flagPhraseWithPlaceholder: "--cn-import <spec>",
+							helpBlurb: "Override module specifier when adding cn import"
+						},
+						{
+							kind: "booleanFlag",
+							flagPhrase: "--json",
+							helpBlurb: "Print one JSON object on stdout (suppresses human progress)",
+							whenUnsetUses: false
+						}
+					],
+					action: async (positionalPieces, typedLocalCarrier) => {
+						await this.performApplyOrPreviewSubtree(true, readOptionalPositionalArg(positionalPieces[0]), typedLocalCarrier);
+					}
+				},
+				{
+					name: "group",
+					description: "Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)",
+					route: [
+						{
+							kind: "greedyPositional",
+							argumentTemplate: "[tokens...]",
+							helpBlurb: "Class tokens (quote a single string if it contains spaces)"
+						},
+						{
+							kind: "booleanFlag",
+							flagPhrase: "--tv",
+							helpBlurb: "Emit tv()-style array instead of cn() call",
+							whenUnsetUses: false
+						},
+						{
+							kind: "synonymousBooleanAliases",
+							commaJoinedFlags: "--with-classname, --with-class-name",
+							helpBlurb: "Append className as final cn() argument"
+						},
+						{
+							kind: "booleanFlag",
+							flagPhrase: "--json",
+							helpBlurb: "Print one JSON object on stdout instead of plain lines",
+							whenUnsetUses: false
+						}
+					],
+					action: async (positionalPieces, typedLocalCarrier) => {
+						const rawTokenSeries = positionalPieces[0];
+						const classTokenSeries = Array.isArray(rawTokenSeries) ? rawTokenSeries.filter((segment) => typeof segment === "string") : [];
+						await this.performGroupSubtree(classTokenSeries, typedLocalCarrier);
+					}
+				}
+			]
+		};
 	}
-	async executeAnalyze(target, options) {
+	async performAnalyzeSubtree(targetSlice, optionCarrier) {
 		const prelude = await this.prepareWorkspace.execute({
 			currentWorkingDirectory: this.runtime.cwd(),
-			rawTarget: target
+			rawTarget: targetSlice
 		});
-		if (!consumeCliAppError(this.logger, prelude)) return;
+		if (!this.cliExecutor.consumeCliAppError(prelude)) return;
 		const { resolvedTarget } = prelude.value;
-		const parsed = parseWithCliSchema(arrangeAnalyzeDirectoryRequestSchema, { analyzeRootPath: resolvedTarget });
-		if (!consumeCliAppError(this.logger, parsed)) return;
+		const parsed = this.schemaValidation.parseWithSchema(arrangeAnalyzeDirectoryRequestSchema, { analyzeRootPath: resolvedTarget });
+		if (!this.cliExecutor.consumeCliAppError(parsed)) return;
 		const outcome = this.analyzeDirectory.execute(parsed.value);
-		if (!consumeCliAppError(this.logger, outcome)) return;
-		if (options?.json) this.logger.out(formatArrangeAnalyzeJsonOutput(resolvedTarget, outcome.value));
+		if (!this.cliExecutor.consumeCliAppError(outcome)) return;
+		if (optionCarrier.jsonCandidate) this.logger.out(this.formatArrangeAnalyzeJsonOutput(resolvedTarget, outcome.value));
 		else this.presentAnalyzeReport.present(resolvedTarget, outcome.value);
 	}
-	async executePreviewOrApply(write, target, opts) {
+	async performApplyOrPreviewSubtree(writeCandidate, targetSlice, typedLocalCarrier) {
 		const prelude = await this.prepareWorkspace.execute({
 			currentWorkingDirectory: this.runtime.cwd(),
-			rawTarget: target
+			rawTarget: targetSlice
 		});
-		if (!consumeCliAppError(this.logger, prelude)) return;
+		if (!this.cliExecutor.consumeCliAppError(prelude)) return;
 		const { resolvedTarget, rootDir, config } = prelude.value;
-		const parsed = parseWithCliSchema(arrangeSyncRunRequestSchema, {
+		const parsed = this.schemaValidation.parseWithSchema(arrangeSyncRunRequestSchema, {
 			rootDir,
 			targetPath: resolvedTarget,
-			write,
-			withClassName: opts.withClassName,
-			cnImport: opts.cnImport,
+			write: writeCandidate,
+			withClassName: typedLocalCarrier.withClassName,
+			cnImport: typedLocalCarrier.cnImport,
 			config: config.arrange ?? {}
 		});
-		if (!consumeCliAppError(this.logger, parsed)) return;
+		if (!this.cliExecutor.consumeCliAppError(parsed)) return;
 		const outcome = await this.runArrangeSync.execute(parsed.value);
-		if (!consumeCliAppError(this.logger, outcome)) return;
-		if (!write) for (const plan of outcome.value.previewPlans) this.groupFilePreview.printGroupFilePreviewFromWork(plan);
-		if (opts.json) {
-			this.logger.out(formatArrangeSyncJsonOutput(outcome.value, write));
-			this.runtime.setExitCode(exitCodeForArrangeSyncResult(outcome.value));
-		} else this.runtime.setExitCode(presentArrangeSyncResult(this.logger, outcome.value, write));
+		if (!this.cliExecutor.consumeCliAppError(outcome)) return;
+		if (!writeCandidate) for (const plan of outcome.value.previewPlans) this.presentGroupFilePreview.printGroupFilePreviewFromWork(plan);
+		if (typedLocalCarrier.json) {
+			this.logger.out(this.formatArrangeSyncJsonOutput(outcome.value, writeCandidate));
+			this.runtime.setExitCode(this.exitCodeForArrangeSyncResult(outcome.value));
+		} else {
+			this.presentArrangeSyncResult.present(outcome.value, writeCandidate);
+			this.runtime.setExitCode(this.exitCodeForArrangeSyncResult(outcome.value));
+		}
 	}
-	async executeGroup(tokens, opts) {
-		const parsed = parseWithCliSchema(arrangeSuggestGroupsRequestSchema, {
-			inlineClasses: tokens.join(" ").trim(),
-			emitTvStyleArray: !!opts.tv,
-			trailingClassName: !!opts.withClassName
+	async performGroupSubtree(classTokenSeries, typedLocalCarrier) {
+		const parsed = this.schemaValidation.parseWithSchema(arrangeSuggestGroupsRequestSchema, {
+			inlineClasses: classTokenSeries.join(" ").trim(),
+			emitTvStyleArray: !!typedLocalCarrier.tv,
+			trailingClassName: !!typedLocalCarrier.withClassName
 		});
-		if (!consumeCliAppError(this.logger, parsed)) return;
+		if (!this.cliExecutor.consumeCliAppError(parsed)) return;
 		const output = this.suggestCnGroups.execute(parsed.value);
-		if (opts.json) this.logger.out(formatArrangeGroupJsonOutput(output));
+		if (typedLocalCarrier.json) this.logger.out(this.formatArrangeGroupJsonOutput(output));
 		else {
 			this.logger.out(output.primaryLine);
 			this.logger.out(output.bucketsCommentLine);
 		}
 	}
+	formatArrangeAnalyzeJsonOutput(analyzeRootPath, report) {
+		return JSON.stringify({
+			schemaVersion: 1,
+			analyzeRootPath,
+			report
+		});
+	}
+	formatArrangeSyncJsonOutput(result, write) {
+		const { previewPlans: _plans, ...serializableResult } = result;
+		return JSON.stringify({
+			schemaVersion: 1,
+			ok: result.hookError === null,
+			write,
+			result: serializableResult
+		});
+	}
+	formatArrangeGroupJsonOutput(output) {
+		return JSON.stringify({
+			schemaVersion: 1,
+			primaryLine: output.primaryLine,
+			bucketsCommentLine: output.bucketsCommentLine
+		});
+	}
+	exitCodeForArrangeSyncResult(result) {
+		return result.hookError !== null ? 1 : 0;
+	}
 	static {
 		_initClass();
 	}

package/dist/{lib/arrange/presentation → domains/arrange/presentation/presenters}/arrange-analyze.presenter.mjs

@@ -1,8 +1,8 @@
-import "../domain/constants.domain.mjs";
-import { CliLoggerToken } from "../../core/contracts/tokens.mjs";
+import { CliLoggerPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import "../../domain/constants.domain.mjs";
 import path from "node:path";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/presentation/arrange-analyze.presenter.ts
+//#region src/domains/arrange/presentation/presenters/arrange-analyze.presenter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -213,47 +213,40 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-function printAnalyzeReport(analyzeRootDirectoryPath, analyzeReport, logger) {
-	logger.out(`Path: ${path.resolve(analyzeRootDirectoryPath)}`);
-	logger.out(`.ts/.tsx files: ${analyzeReport.files}`);
-	logger.out(`cn(...) call sites: ${analyzeReport.cnCallExpressions}`);
-	logger.out(`tv(...) call sites: ${analyzeReport.tvCallExpressions}`);
-	logger.out(`\nLong cn(...) string literals (≥18 tokens — consider splitting arguments): ${analyzeReport.longCnStringLiterals.length}`);
-	for (const findingEntry of analyzeReport.longCnStringLiterals.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
-	if (analyzeReport.longCnStringLiterals.length > 40) logger.out(`  … and ${analyzeReport.longCnStringLiterals.length - 40} more`);
-	logger.out(`\nLong tv({...}) string literals in base/variants/… (≥18 tokens): ${analyzeReport.longTvStringLiterals.length}`);
-	for (const findingEntry of analyzeReport.longTvStringLiterals.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
-	if (analyzeReport.longTvStringLiterals.length > 40) logger.out(`  … and ${analyzeReport.longTvStringLiterals.length - 40} more`);
-	logger.out(`\nJSX className="..." or className={'...'} (static strings, ≥18 tokens): ${analyzeReport.longJsxClassNameLiterals.length}`);
-	for (const findingEntry of analyzeReport.longJsxClassNameLiterals.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
-	if (analyzeReport.longJsxClassNameLiterals.length > 40) logger.out(`  … and ${analyzeReport.longJsxClassNameLiterals.length - 40} more`);
-	logger.out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${analyzeReport.cnInsideTvCalls.length}`);
-	for (const findingEntry of analyzeReport.cnInsideTvCalls.slice(0, 40)) logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
-	if (analyzeReport.cnInsideTvCalls.length > 40) logger.out(`  … and ${analyzeReport.cnInsideTvCalls.length - 40} more`);
-}
-_dec = injectable([inject(CliLoggerToken)]);
-let _PresentAnalyzeReportPresenterImpl;
+_dec = injectable([inject(CliLoggerPortToken)]);
+let _PresentAnalyzeReportPresenter;
 (class {
 	logger;
 	static {
-		({c: [_PresentAnalyzeReportPresenterImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_PresentAnalyzeReportPresenter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
 	constructor(logger) {
 		this.logger = logger;
 	}
 	present(resolvedTargetPath, report) {
-		printAnalyzeReport(resolvedTargetPath, report, this.logger);
+		this.printAnalyzeReport(resolvedTargetPath, report);
+	}
+	printAnalyzeReport(analyzeRootDirectoryPath, analyzeReport) {
+		this.logger.out(`Path: ${path.resolve(analyzeRootDirectoryPath)}`);
+		this.logger.out(`.ts/.tsx files: ${analyzeReport.files}`);
+		this.logger.out(`cn(...) call sites: ${analyzeReport.cnCallExpressions}`);
+		this.logger.out(`tv(...) call sites: ${analyzeReport.tvCallExpressions}`);
+		this.logger.out(`\nLong cn(...) string literals (≥18 tokens — consider splitting arguments): ${analyzeReport.longCnStringLiterals.length}`);
+		for (const findingEntry of analyzeReport.longCnStringLiterals.slice(0, 40)) this.logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+		if (analyzeReport.longCnStringLiterals.length > 40) this.logger.out(`  … and ${analyzeReport.longCnStringLiterals.length - 40} more`);
+		this.logger.out(`\nLong tv({...}) string literals in base/variants/… (≥18 tokens): ${analyzeReport.longTvStringLiterals.length}`);
+		for (const findingEntry of analyzeReport.longTvStringLiterals.slice(0, 40)) this.logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+		if (analyzeReport.longTvStringLiterals.length > 40) this.logger.out(`  … and ${analyzeReport.longTvStringLiterals.length - 40} more`);
+		this.logger.out(`\nJSX className="..." or className={'...'} (static strings, ≥18 tokens): ${analyzeReport.longJsxClassNameLiterals.length}`);
+		for (const findingEntry of analyzeReport.longJsxClassNameLiterals.slice(0, 40)) this.logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+		if (analyzeReport.longJsxClassNameLiterals.length > 40) this.logger.out(`  … and ${analyzeReport.longJsxClassNameLiterals.length - 40} more`);
+		this.logger.out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${analyzeReport.cnInsideTvCalls.length}`);
+		for (const findingEntry of analyzeReport.cnInsideTvCalls.slice(0, 40)) this.logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
+		if (analyzeReport.cnInsideTvCalls.length > 40) this.logger.out(`  … and ${analyzeReport.cnInsideTvCalls.length - 40} more`);
 	}
 	static {
 		_initClass();
 	}
 });
-function formatArrangeAnalyzeJsonOutput(analyzeRootPath, report) {
-	return JSON.stringify({
-		schemaVersion: 1,
-		analyzeRootPath,
-		report
-	});
-}
 //#endregion
-export { _PresentAnalyzeReportPresenterImpl as PresentAnalyzeReportPresenterImpl, formatArrangeAnalyzeJsonOutput };
+export { _PresentAnalyzeReportPresenter as PresentAnalyzeReportPresenter };

package/dist/{lib/arrange/presentation → domains/arrange/presentation/presenters}/arrange-cli.schema.mjs

@@ -1,5 +1,5 @@
 import { z } from "zod";
-//#region src/lib/arrange/presentation/arrange-cli.schema.ts
+//#region src/domains/arrange/presentation/presenters/arrange-cli.schema.ts
 const arrangeAnalyzeDirectoryRequestSchema = z.object({ analyzeRootPath: z.string().min(1, "analyzeRootPath is required") });
 const arrangeSyncRunRequestSchema = z.object({
 	rootDir: z.string().min(1),

package/dist/{lib/tag/presentation/present-tag-sync-result.presenter.mjs → domains/arrange/presentation/presenters/arrange-sync.presenter.mjs}

@@ -1,7 +1,6 @@
-import { CliLoggerToken } from "../../core/contracts/tokens.mjs";
-import { presentTagSyncCliResult } from "./tag-sync.presenter.mjs";
+import { CliLoggerPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/tag/presentation/present-tag-sync-result.presenter.ts
+//#region src/domains/arrange/presentation/presenters/arrange-sync.presenter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -212,22 +211,26 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([inject(CliLoggerToken)]);
-let _PresentTagSyncResultPresenterImpl;
+_dec = injectable([inject(CliLoggerPortToken)]);
+let _PresentArrangeSyncResultPresenter;
 (class {
 	logger;
 	static {
-		({c: [_PresentTagSyncResultPresenterImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_PresentArrangeSyncResultPresenter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
 	constructor(logger) {
 		this.logger = logger;
 	}
-	present(result, rootDir) {
-		return presentTagSyncCliResult(this.logger, result, rootDir);
+	present(result, write) {
+		this.logger.out(`\nTotal: ${result.filePaths.length} file(s), ${result.totalFound} site(s) (cn/tv/JSX className) to review.`);
+		if (write) this.logger.out(`Applied: ${result.totalChanged} site(s) updated.`);
+		else this.logger.out(`(Run "apply" to write changes, or "pnpm cli:arrange-apply" / "pnpm exec codefast arrange apply")`);
+		if (write ? result.totalChanged > 0 : result.totalFound > 0) this.logger.out("Note: class order may change across concern groups — smoke-test the UI if you rely on cascade order.");
+		if (result.hookError !== null) this.logger.err(result.hookError);
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _PresentTagSyncResultPresenterImpl as PresentTagSyncResultPresenterImpl };
+export { _PresentArrangeSyncResultPresenter as PresentArrangeSyncResultPresenter };

package/dist/{lib/arrange/presentation → domains/arrange/presentation/presenters}/group-file-preview.presenter.mjs

@@ -1,7 +1,7 @@
-import { CliLoggerToken } from "../../core/contracts/tokens.mjs";
-import { lineOf } from "../domain/ast/ast-helpers.helper.mjs";
+import { CliLoggerPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { lineOf } from "../../domain/ast/ast-helpers.helper.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/presentation/group-file-preview.presenter.ts
+//#region src/domains/arrange/presentation/presenters/group-file-preview.presenter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -212,60 +212,60 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-function printGroupFilePreview(logger, args) {
-	const { filePath, reportTotal, cnInTvNoReplacement, cnInTvCalls, unwrapReplacementByCall, sourceText, domainSf, unwrapEdits, plannedGroupEdits } = args;
-	let header = `\n── ${filePath} (${reportTotal} site(s)`;
-	if (cnInTvNoReplacement > 0) header += `; plus ${cnInTvNoReplacement} cn() inside tv left unchanged (0 args)`;
-	header += `) ──`;
-	logger.out(header);
-	for (const call of cnInTvCalls) {
-		const replacement = unwrapReplacementByCall.get(call);
-		if (replacement === void 0) {
-			logger.out(`  Line ${lineOf(domainSf, call)} [tv ⊃ cn]: cn(...) has no arguments — skipped`);
-			continue;
-		}
-		const start = call.pos;
-		const end = call.end;
-		if (sourceText.slice(start, end) === replacement) continue;
-		logger.out(`  Line ${lineOf(domainSf, call)} [tv ⊃ cn → string/array]:`);
-		logger.out(`  ${replacement.split("\n").join("\n  ")}`);
-	}
-	if (unwrapEdits.length > 0 && plannedGroupEdits.length > 0) logger.out("  ([cn] / [tv] / [JSX className] lines below reflect content after unwrap of cn inside tv.)");
-	for (const plan of plannedGroupEdits) {
-		logger.out(`  Line ${lineOf(plan.lineSf, plan.reportNode)} [${plan.label}]:`);
-		logger.out(`  ${plan.replacement.split("\n").join("\n  ")}`);
-		logger.out(`  // Buckets: ${JSON.stringify(plan.bucketSummary)}`);
-	}
-}
-function printGroupFilePreviewFromWork(logger, work) {
-	printGroupFilePreview(logger, {
-		filePath: work.filePath,
-		reportTotal: work.reportTotal,
-		cnInTvNoReplacement: work.cnInTvNoReplacement,
-		cnInTvCalls: work.cnInTvCalls,
-		unwrapReplacementByCall: work.unwrapReplacementByCall,
-		sourceText: work.sourceText,
-		domainSf: work.domainSfForLineNumbers,
-		unwrapEdits: work.unwrapEdits,
-		plannedGroupEdits: work.plannedGroupEdits
-	});
-}
-_dec = injectable([inject(CliLoggerToken)]);
-let _GroupFilePreviewPresenterAdapter;
+_dec = injectable([inject(CliLoggerPortToken)]);
+let _PresentGroupFilePreviewPresenter;
 (class {
 	logger;
 	static {
-		({c: [_GroupFilePreviewPresenterAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_PresentGroupFilePreviewPresenter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
 	constructor(logger) {
 		this.logger = logger;
 	}
 	printGroupFilePreviewFromWork(work) {
-		printGroupFilePreviewFromWork(this.logger, work);
+		this.printGroupFilePreviewFromPlan(work);
+	}
+	printGroupFilePreviewFromPlan(work) {
+		this.printGroupFilePreviewBody({
+			filePath: work.filePath,
+			reportTotal: work.reportTotal,
+			cnInTvNoReplacement: work.cnInTvNoReplacement,
+			cnInTvCalls: work.cnInTvCalls,
+			unwrapReplacementByCall: work.unwrapReplacementByCall,
+			sourceText: work.sourceText,
+			domainSf: work.domainSfForLineNumbers,
+			unwrapEdits: work.unwrapEdits,
+			plannedGroupEdits: work.plannedGroupEdits
+		});
+	}
+	printGroupFilePreviewBody(args) {
+		const { filePath, reportTotal, cnInTvNoReplacement, cnInTvCalls, unwrapReplacementByCall, sourceText, domainSf, unwrapEdits, plannedGroupEdits } = args;
+		let header = `\n── ${filePath} (${reportTotal} site(s)`;
+		if (cnInTvNoReplacement > 0) header += `; plus ${cnInTvNoReplacement} cn() inside tv left unchanged (0 args)`;
+		header += `) ──`;
+		this.logger.out(header);
+		for (const call of cnInTvCalls) {
+			const replacement = unwrapReplacementByCall.get(call);
+			if (replacement === void 0) {
+				this.logger.out(`  Line ${lineOf(domainSf, call)} [tv ⊃ cn]: cn(...) has no arguments — skipped`);
+				continue;
+			}
+			const start = call.pos;
+			const end = call.end;
+			if (sourceText.slice(start, end) === replacement) continue;
+			this.logger.out(`  Line ${lineOf(domainSf, call)} [tv ⊃ cn → string/array]:`);
+			this.logger.out(`  ${replacement.split("\n").join("\n  ")}`);
+		}
+		if (unwrapEdits.length > 0 && plannedGroupEdits.length > 0) this.logger.out("  ([cn] / [tv] / [JSX className] lines below reflect content after unwrap of cn inside tv.)");
+		for (const plan of plannedGroupEdits) {
+			this.logger.out(`  Line ${lineOf(plan.lineSf, plan.reportNode)} [${plan.label}]:`);
+			this.logger.out(`  ${plan.replacement.split("\n").join("\n  ")}`);
+			this.logger.out(`  // Buckets: ${JSON.stringify(plan.bucketSummary)}`);
+		}
 	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _GroupFilePreviewPresenterAdapter as GroupFilePreviewPresenterAdapter };
+export { _PresentGroupFilePreviewPresenter as PresentGroupFilePreviewPresenter };

package/dist/domains/config/composition/tokens.mjs

@@ -0,0 +1,7 @@
+import { token } from "@codefast/di";
+//#region src/domains/config/composition/tokens.ts
+const CodefastConfigSchemaPortToken = token("CodefastConfigSchemaPort");
+const ConfigLoaderPortToken = token("ConfigLoaderPort");
+const ConfigWarningReporterPortToken = token("ConfigWarningReporterPort");
+//#endregion
+export { CodefastConfigSchemaPortToken, ConfigLoaderPortToken, ConfigWarningReporterPortToken };

package/dist/{lib/config/infrastructure/config-schema.adapter.mjs → domains/config/domain/codefast-config.schema.mjs}

@@ -1,6 +1,6 @@
 import { z } from "zod";
-//#region src/lib/config/infrastructure/config-schema.adapter.ts
-const hookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
+//#region src/domains/config/domain/codefast-config.schema.ts
+const afterWriteHookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
 const mirrorConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
 	pathTransformations: z.record(z.string(), z.object({ removePrefix: z.string().optional() }).strict()).optional(),
@@ -13,13 +13,13 @@ const mirrorConfigSchema = z.object({
 }).strict();
 const codefastTagConfigSchema = z.object({
 	skipPackages: z.array(z.string()).optional(),
-	onAfterWrite: hookSchema.optional()
+	onAfterWrite: afterWriteHookSchema.optional()
 }).strict();
-const codefastArrangeConfigSchema = z.object({ onAfterWrite: hookSchema.optional() }).strict();
-const codefastConfigSchema = z.object({
+const codefastArrangeConfigSchema = z.object({ onAfterWrite: afterWriteHookSchema.optional() }).strict();
+/** Root `codefast.config` Zod schema — single source of truth for both validation and TS types. */ const codefastConfigRootSchema = z.object({
 	mirror: mirrorConfigSchema.optional(),
 	tag: codefastTagConfigSchema.optional(),
 	arrange: codefastArrangeConfigSchema.optional()
 }).strict();
 //#endregion
-export { codefastConfigSchema };
+export { codefastArrangeConfigSchema, codefastConfigRootSchema, codefastTagConfigSchema, mirrorConfigSchema };