@codefast/cli 0.3.14-canary.1 → 0.3.14-canary.2

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

@@ -1,17 +1,14 @@
-import { formatArrangeAnalyzeJsonOutput } from "../lib/arrange/application/arrange-analyze-json.format.mjs";
-import { formatArrangeGroupJsonOutput } from "../lib/arrange/application/arrange-group-json.format.mjs";
-import { exitCodeForArrangeSyncResult } from "../lib/arrange/application/arrange-sync-cli-result.mjs";
-import { formatArrangeSyncJsonOutput } from "../lib/arrange/application/arrange-sync-json.format.mjs";
-import { AnalyzeDirectoryUseCaseToken, PrepareArrangeOrchestratorToken, PresentAnalyzeReportPresenterToken, RunArrangeSyncUseCaseToken, SuggestCnGroupsUseCaseToken } from "../lib/arrange/contracts/tokens.mjs";
-import { arrangeAnalyzeDirectoryRequestSchema, arrangeSuggestGroupsRequestSchema, arrangeSyncRunRequestSchema } from "../lib/arrange/presentation/arrange-cli-schema.presenter.mjs";
-import { presentArrangeSyncResult } from "../lib/arrange/presentation/arrange-sync.presenter.mjs";
-import { CliLoggerToken } from "../lib/core/operational/contracts/tokens.mjs";
-import { parseWithCliSchema } from "../lib/core/presentation/parse-cli-schema.presenter.mjs";
-import { consumeCliAppError } from "../lib/core/presentation/cli-executor.presenter.mjs";
-import process from "node:process";
+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 { inject, injectable } from "@codefast/di";
-//#region src/commands/arrange.ts
+//#region src/lib/arrange/adapters/primary/cli/arrange.command.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -227,30 +224,36 @@ function withClassNameOption() {
 }
 _dec = injectable([
 	inject(CliLoggerToken),
-	inject(PrepareArrangeOrchestratorToken),
+	inject(CliRuntimeToken),
+	inject(PrepareArrangeWorkspaceUseCaseToken),
 	inject(AnalyzeDirectoryUseCaseToken),
 	inject(RunArrangeSyncUseCaseToken),
 	inject(SuggestCnGroupsUseCaseToken),
-	inject(PresentAnalyzeReportPresenterToken)
+	inject(PresentAnalyzeReportPresenterToken),
+	inject(GroupFilePreviewPortToken)
 ]);
 let _ArrangeCommand;
 (class {
 	logger;
-	prepareTargetWorkspaceAndConfig;
+	runtime;
+	prepareWorkspace;
 	analyzeDirectory;
 	runArrangeSync;
 	suggestCnGroups;
 	presentAnalyzeReport;
+	groupFilePreview;
 	static {
 		({c: [_ArrangeCommand, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(logger, prepareTargetWorkspaceAndConfig, analyzeDirectory, runArrangeSync, suggestCnGroups, presentAnalyzeReport) {
+	constructor(logger, runtime, prepareWorkspace, analyzeDirectory, runArrangeSync, suggestCnGroups, presentAnalyzeReport, groupFilePreview) {
 		this.logger = logger;
-		this.prepareTargetWorkspaceAndConfig = prepareTargetWorkspaceAndConfig;
+		this.runtime = runtime;
+		this.prepareWorkspace = prepareWorkspace;
 		this.analyzeDirectory = analyzeDirectory;
 		this.runArrangeSync = runArrangeSync;
 		this.suggestCnGroups = suggestCnGroups;
 		this.presentAnalyzeReport = presentAnalyzeReport;
+		this.groupFilePreview = groupFilePreview;
 	}
 	name = "arrange";
 	description = "Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)";
@@ -262,25 +265,22 @@ let _ArrangeCommand;
 		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));
 	}
 	async executeAnalyze(target, options) {
-		const prelude = await this.prepareTargetWorkspaceAndConfig.execute({
-			currentWorkingDirectory: process.cwd(),
+		const prelude = await this.prepareWorkspace.execute({
+			currentWorkingDirectory: this.runtime.cwd(),
 			rawTarget: target
 		});
 		if (!consumeCliAppError(this.logger, prelude)) return;
 		const { resolvedTarget } = prelude.value;
-		const parsed = parseWithCliSchema(arrangeAnalyzeDirectoryRequestSchema, {
-			analyzeRootPath: resolvedTarget,
-			json: options?.json
-		});
+		const parsed = parseWithCliSchema(arrangeAnalyzeDirectoryRequestSchema, { analyzeRootPath: resolvedTarget });
 		if (!consumeCliAppError(this.logger, parsed)) return;
 		const outcome = this.analyzeDirectory.execute(parsed.value);
 		if (!consumeCliAppError(this.logger, outcome)) return;
-		if (parsed.value.json) this.logger.out(formatArrangeAnalyzeJsonOutput(resolvedTarget, outcome.value));
+		if (options?.json) this.logger.out(formatArrangeAnalyzeJsonOutput(resolvedTarget, outcome.value));
 		else this.presentAnalyzeReport.present(resolvedTarget, outcome.value);
 	}
 	async executePreviewOrApply(write, target, opts) {
-		const prelude = await this.prepareTargetWorkspaceAndConfig.execute({
-			currentWorkingDirectory: process.cwd(),
+		const prelude = await this.prepareWorkspace.execute({
+			currentWorkingDirectory: this.runtime.cwd(),
 			rawTarget: target
 		});
 		if (!consumeCliAppError(this.logger, prelude)) return;
@@ -289,7 +289,6 @@ let _ArrangeCommand;
 			rootDir,
 			targetPath: resolvedTarget,
 			write,
-			json: opts.json,
 			withClassName: opts.withClassName,
 			cnImport: opts.cnImport,
 			config: config.arrange ?? {}
@@ -297,21 +296,21 @@ let _ArrangeCommand;
 		if (!consumeCliAppError(this.logger, parsed)) return;
 		const outcome = await this.runArrangeSync.execute(parsed.value);
 		if (!consumeCliAppError(this.logger, outcome)) return;
-		if (parsed.value.json) {
+		if (!write) for (const plan of outcome.value.previewPlans) this.groupFilePreview.printGroupFilePreviewFromWork(plan);
+		if (opts.json) {
 			this.logger.out(formatArrangeSyncJsonOutput(outcome.value, write));
-			process.exitCode = exitCodeForArrangeSyncResult(outcome.value);
-		} else process.exitCode = presentArrangeSyncResult(this.logger, outcome.value, write);
+			this.runtime.setExitCode(exitCodeForArrangeSyncResult(outcome.value));
+		} else this.runtime.setExitCode(presentArrangeSyncResult(this.logger, outcome.value, write));
 	}
 	async executeGroup(tokens, opts) {
 		const parsed = parseWithCliSchema(arrangeSuggestGroupsRequestSchema, {
 			inlineClasses: tokens.join(" ").trim(),
 			emitTvStyleArray: !!opts.tv,
-			trailingClassName: !!opts.withClassName,
-			json: opts.json
+			trailingClassName: !!opts.withClassName
 		});
 		if (!consumeCliAppError(this.logger, parsed)) return;
 		const output = this.suggestCnGroups.execute(parsed.value);
-		if (parsed.value.json) this.logger.out(formatArrangeGroupJsonOutput(output));
+		if (opts.json) this.logger.out(formatArrangeGroupJsonOutput(output));
 		else {
 			this.logger.out(output.primaryLine);
 			this.logger.out(output.bucketsCommentLine);

package/dist/lib/arrange/adapters/primary/cli/arrange.presentation.module.mjs

@@ -0,0 +1,14 @@
+import { GroupFilePreviewPortToken } from "../../../contracts/tokens.mjs";
+import { PresentAnalyzeReportPresenterToken } from "./presentation.tokens.mjs";
+import { PresentAnalyzeReportPresenterImpl as _PresentAnalyzeReportPresenterImpl } from "../../../presentation/arrange-analyze.presenter.mjs";
+import { GroupFilePreviewPresenterAdapter as _GroupFilePreviewPresenterAdapter } from "../../../presentation/group-file-preview.presenter.mjs";
+import { PresentationModule } from "../../../../core/presentation/presentation.module.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/arrange/adapters/primary/cli/arrange.presentation.module.ts
+const ArrangePresentationModule = Module.create("cli-arrange-presentation", (moduleBuilder) => {
+	moduleBuilder.import(PresentationModule);
+	moduleBuilder.bind(PresentAnalyzeReportPresenterToken).to(_PresentAnalyzeReportPresenterImpl).singleton();
+	moduleBuilder.bind(GroupFilePreviewPortToken).to(_GroupFilePreviewPresenterAdapter).singleton();
+});
+//#endregion
+export { ArrangePresentationModule };

package/dist/lib/arrange/adapters/primary/cli/presentation.tokens.mjs

@@ -0,0 +1,5 @@
+import { token } from "@codefast/di";
+//#region src/lib/arrange/adapters/primary/cli/presentation.tokens.ts
+const PresentAnalyzeReportPresenterToken = token("PresentAnalyzeReportPresenter");
+//#endregion
+export { PresentAnalyzeReportPresenterToken };

package/dist/lib/arrange/{infra → adapters/secondary}/domain-source-parser.adapter.mjs

@@ -1,8 +1,8 @@
-import { CliLoggerToken } from "../../core/operational/contracts/tokens.mjs";
-import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
-import { parseDomainSourceFile } from "./ts-ast-translator.adapter.mjs";
+import { CliLoggerToken } from "../../../core/contracts/tokens.mjs";
+import { messageFromCaughtUnknown } from "../../../core/domain/caught-unknown-message.value-object.mjs";
+import { parseDomainSourceFile } from "../../infrastructure/typescript-ast-translator.adapter.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/infra/domain-source-parser.adapter.ts
+//#region src/lib/arrange/adapters/secondary/domain-source-parser.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -235,8 +235,5 @@ let _DomainSourceParserAdapter;
 		_initClass();
 	}
 });
-/**
-* Default instance without diagnostics logging (tests and legacy imports).
-*/ const domainSourceParserAdapter = new _DomainSourceParserAdapter();
 //#endregion
-export { _DomainSourceParserAdapter as DomainSourceParserAdapter, domainSourceParserAdapter };
+export { _DomainSourceParserAdapter as DomainSourceParserAdapter };

package/dist/lib/arrange/{infra → adapters/secondary}/file-walker.adapter.mjs

@@ -1,8 +1,8 @@
-import { CliLoggerToken } from "../../core/operational/contracts/tokens.mjs";
-import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
-import { walkTsxFiles } from "../../shared/source-code/infra/tsx-file-walk.adapter.mjs";
+import { CliFsToken, CliLoggerToken } from "../../../core/contracts/tokens.mjs";
+import { messageFromCaughtUnknown } from "../../../core/domain/caught-unknown-message.value-object.mjs";
+import { walkTsxFiles } from "../../../shared/source-code/infrastructure/typescript-source-file-walker.service.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/arrange/infra/file-walker.adapter.ts
+//#region src/lib/arrange/adapters/secondary/file-walker.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -213,21 +213,23 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([inject(CliLoggerToken)]);
+_dec = injectable([inject(CliLoggerToken), inject(CliFsToken)]);
 let _FileWalkerAdapter;
 (class {
 	logger;
+	fs;
 	static {
 		({c: [_FileWalkerAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(logger) {
+	constructor(logger, fs) {
 		this.logger = logger;
+		this.fs = fs;
 	}
-	walkTypeScriptFiles(rootDirectoryPath, fs) {
+	walkTypeScriptFiles(rootDirectoryPath) {
 		try {
-			return walkTsxFiles(rootDirectoryPath, fs);
+			return walkTsxFiles(rootDirectoryPath, this.fs);
 		} catch (caughtError) {
-			this.logger?.err(`[file-walker] ${messageFromCaughtUnknown(caughtError)}`);
+			this.logger.err(`[file-walker] ${messageFromCaughtUnknown(caughtError)}`);
 			throw caughtError;
 		}
 	}

package/dist/lib/arrange/adapters/secondary/workspace-resolver.adapter.mjs

@@ -0,0 +1,233 @@
+import { CliFsToken } from "../../../core/contracts/tokens.mjs";
+import { findRepoRoot } from "../../../infrastructure/workspace/repo-root-resolver.service.mjs";
+import { inject, injectable } from "@codefast/di";
+//#region src/lib/arrange/adapters/secondary/workspace-resolver.adapter.ts
+function toPrimitive(input, hint) {
+	if (typeof input !== "object" || input === null) return input;
+	var prim = input[Symbol.toPrimitive];
+	if (prim !== void 0) {
+		var res = prim.call(input, hint || "default");
+		if (typeof res !== "object") return res;
+		throw new TypeError("@@toPrimitive must return a primitive value.");
+	}
+	return (hint === "string" ? String : Number)(input);
+}
+function toPropertyKey(arg) {
+	var key = toPrimitive(arg, "string");
+	return typeof key === "symbol" ? key : String(key);
+}
+function checkInRHS(value) {
+	if (Object(value) !== value) throw TypeError("right-hand side of 'in' should be an object, got " + (value !== null ? typeof value : "null"));
+	return value;
+}
+function setFunctionName(fn, name, prefix) {
+	if (typeof name === "symbol") {
+		name = name.description;
+		name = name ? "[" + name + "]" : "";
+	}
+	try {
+		Object.defineProperty(fn, "name", {
+			configurable: true,
+			value: prefix ? prefix + " " + name : name
+		});
+	} catch (_) {}
+	return fn;
+}
+function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis, instanceBrand, parentClass) {
+	var symbolMetadata = Symbol.metadata || Symbol.for("Symbol.metadata");
+	var defineProperty = Object.defineProperty;
+	var create = Object.create;
+	var metadata;
+	var existingNonFields = [create(null), create(null)];
+	var hasClassDecs = classDecs.length;
+	var _;
+	function createRunInitializers(initializers, useStaticThis, hasValue) {
+		return function(thisArg, value) {
+			if (useStaticThis) {
+				value = thisArg;
+				thisArg = targetClass;
+			}
+			for (var i = 0; i < initializers.length; i++) value = initializers[i].apply(thisArg, hasValue ? [value] : []);
+			return hasValue ? value : thisArg;
+		};
+	}
+	function assertCallable(fn, hint1, hint2, throwUndefined) {
+		if (typeof fn !== "function") {
+			if (throwUndefined || fn !== void 0) throw new TypeError(hint1 + " must " + (hint2 || "be") + " a function" + (throwUndefined ? "" : " or undefined"));
+		}
+		return fn;
+	}
+	function applyDec(Class, decInfo, decoratorsHaveThis, name, kind, initializers, ret, isStatic, isPrivate, isField, hasPrivateBrand) {
+		function assertInstanceIfPrivate(target) {
+			if (!hasPrivateBrand(target)) throw new TypeError("Attempted to access private element on non-instance");
+		}
+		var decs = [].concat(decInfo[0]);
+		var decVal = decInfo[3];
+		var isClass = !ret;
+		var isAccessor = kind === 1;
+		var isGetter = kind === 3;
+		var isSetter = kind === 4;
+		var isMethod = kind === 2;
+		function bindPropCall(name, useStaticThis, before) {
+			return function(_this, value) {
+				if (useStaticThis) {
+					value = _this;
+					_this = Class;
+				}
+				if (before) before(_this);
+				return desc[name].call(_this, value);
+			};
+		}
+		var desc1 = {};
+		var init = [];
+		var key = isGetter ? "get" : isSetter || isAccessor ? "set" : "value";
+		if (!isClass) {
+			if (isPrivate) {
+				if (isField || isAccessor) desc1 = {
+					get: setFunctionName(function() {
+						return decVal(this);
+					}, name, "get"),
+					set: function(value) {
+						decInfo[4](this, value);
+					}
+				};
+				else desc1[key] = decVal;
+				if (!isField) setFunctionName(desc1[key], name, isMethod ? "" : key);
+			} else if (!isField) desc1 = Object.getOwnPropertyDescriptor(Class, name);
+			if (!isField && !isPrivate) {
+				_ = existingNonFields[+isStatic][name];
+				if (_ && (_ ^ kind) !== 7) throw new Error("Decorating two elements with the same name (" + desc1[key].name + ") is not supported yet");
+				existingNonFields[+isStatic][name] = kind < 3 ? 1 : kind;
+			}
+		}
+		var newValue = Class;
+		for (var i = decs.length - 1; i >= 0; i -= decoratorsHaveThis ? 2 : 1) {
+			var dec = assertCallable(decs[i], "A decorator", "be", true);
+			var decThis = decoratorsHaveThis ? decs[i - 1] : void 0;
+			var decoratorFinishedRef = {};
+			var ctx = {
+				kind: [
+					"field",
+					"accessor",
+					"method",
+					"getter",
+					"setter",
+					"class"
+				][kind],
+				name,
+				metadata,
+				addInitializer: (function(decoratorFinishedRef, initializer) {
+					if (decoratorFinishedRef.v) throw new TypeError("attempted to call addInitializer after decoration was finished");
+					assertCallable(initializer, "An initializer", "be", true);
+					initializers.push(initializer);
+				}).bind(null, decoratorFinishedRef)
+			};
+			if (isClass) {
+				_ = dec.call(decThis, newValue, ctx);
+				decoratorFinishedRef.v = 1;
+				if (assertCallable(_, "class decorators", "return")) newValue = _;
+				continue;
+			}
+			ctx.static = isStatic;
+			ctx.private = isPrivate;
+			_ = ctx.access = { has: isPrivate ? hasPrivateBrand.bind() : function(target) {
+				return name in target;
+			} };
+			if (!isSetter) _.get = isPrivate ? isMethod ? function(_this) {
+				assertInstanceIfPrivate(_this);
+				return desc1.value;
+			} : bindPropCall("get", 0, assertInstanceIfPrivate) : function(target) {
+				return target[name];
+			};
+			if (!isMethod && !isGetter) _.set = isPrivate ? bindPropCall("set", 0, assertInstanceIfPrivate) : function(target, value) {
+				target[name] = value;
+			};
+			newValue = dec.call(decThis, isAccessor ? {
+				get: desc1.get,
+				set: desc1.set
+			} : desc1[key], ctx);
+			decoratorFinishedRef.v = 1;
+			if (isAccessor) {
+				if (typeof newValue === "object" && newValue) {
+					if (_ = assertCallable(newValue.get, "accessor.get")) desc1.get = _;
+					if (_ = assertCallable(newValue.set, "accessor.set")) desc1.set = _;
+					if (_ = assertCallable(newValue.init, "accessor.init")) init.unshift(_);
+				} else if (newValue !== void 0) throw new TypeError("accessor decorators must return an object with get, set, or init properties or undefined");
+			} else if (assertCallable(newValue, (isField ? "field" : "method") + " decorators", "return")) if (isField) init.unshift(newValue);
+			else desc1[key] = newValue;
+		}
+		if (kind < 2) ret.push(createRunInitializers(init, isStatic, 1), createRunInitializers(initializers, isStatic, 0));
+		if (!isField && !isClass) if (isPrivate) if (isAccessor) ret.splice(-1, 0, bindPropCall("get", isStatic), bindPropCall("set", isStatic));
+		else ret.push(isMethod ? desc1[key] : assertCallable.call.bind(desc1[key]));
+		else defineProperty(Class, name, desc1);
+		return newValue;
+	}
+	function applyMemberDecs() {
+		var ret = [];
+		var protoInitializers;
+		var staticInitializers;
+		var pushInitializers = function(initializers) {
+			if (initializers) ret.push(createRunInitializers(initializers));
+		};
+		var applyMemberDecsOfKind = function(isStatic, isField) {
+			for (var i = 0; i < memberDecs.length; i++) {
+				var decInfo = memberDecs[i];
+				var kind = decInfo[1];
+				var kindOnly = kind & 7;
+				if ((kind & 8) == isStatic && !kindOnly == isField) {
+					var name = decInfo[2];
+					var isPrivate = !!decInfo[3];
+					var decoratorsHaveThis = kind & 16;
+					applyDec(isStatic ? targetClass : targetClass.prototype, decInfo, decoratorsHaveThis, isPrivate ? "#" + name : toPropertyKey(name), kindOnly, kindOnly < 2 ? [] : isStatic ? staticInitializers = staticInitializers || [] : protoInitializers = protoInitializers || [], ret, !!isStatic, isPrivate, isField, isStatic && isPrivate ? function(_) {
+						return checkInRHS(_) === targetClass;
+					} : instanceBrand);
+				}
+			}
+		};
+		applyMemberDecsOfKind(8, 0);
+		applyMemberDecsOfKind(0, 0);
+		applyMemberDecsOfKind(8, 1);
+		applyMemberDecsOfKind(0, 1);
+		pushInitializers(protoInitializers);
+		pushInitializers(staticInitializers);
+		return ret;
+	}
+	function defineMetadata(Class) {
+		return defineProperty(Class, symbolMetadata, {
+			configurable: true,
+			enumerable: true,
+			value: metadata
+		});
+	}
+	if (parentClass !== void 0) metadata = parentClass[symbolMetadata];
+	metadata = create(metadata == null ? null : metadata);
+	_ = applyMemberDecs();
+	if (!hasClassDecs) defineMetadata(targetClass);
+	return {
+		e: _,
+		get c() {
+			var initializers = [];
+			return hasClassDecs && [defineMetadata(targetClass = applyDec(targetClass, [classDecs], classDecsHaveThis, targetClass.name, 5, initializers)), createRunInitializers(initializers, 1)];
+		}
+	};
+}
+let _dec, _initClass;
+_dec = injectable([inject(CliFsToken)]);
+let _WorkspaceResolverAdapter;
+(class {
+	fs;
+	static {
+		({c: [_WorkspaceResolverAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(fs) {
+		this.fs = fs;
+	}
+	findRepoRoot(fromDirectory) {
+		return findRepoRoot(this.fs, fromDirectory);
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _WorkspaceResolverAdapter as WorkspaceResolverAdapter };

package/dist/lib/arrange/application/services/arrange-file-processor.service.mjs

@@ -1,6 +1,7 @@
-import { DomainSourceParserPortToken, GroupFilePreviewPortToken } from "../../contracts/tokens.mjs";
-import { CliFsToken } from "../../../core/operational/contracts/tokens.mjs";
-import { groupFile } from "../use-cases/group-file.use-case.mjs";
+import { DomainSourceParserPortToken } from "../../contracts/tokens.mjs";
+import { CliFsToken } from "../../../core/contracts/tokens.mjs";
+import { buildGroupFileUnwrapState, countPersistedGroupFileEdits, groupFileDryRunNoEdits, groupFileEditsTouchJsxCn, groupFilePreviewTotals, groupFileWorkHasNothingToReport, mergeGroupFileBodyText, tryBuildGroupFileWorkPlan } from "../../domain/arrange-grouping.service.mjs";
+import { ensureCnImport } from "../../domain/imports.domain.mjs";
 import { inject, injectable } from "@codefast/di";
 //#region src/lib/arrange/application/services/arrange-file-processor.service.ts
 function toPrimitive(input, hint) {
@@ -213,26 +214,50 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([
-	inject(CliFsToken),
-	inject(DomainSourceParserPortToken),
-	inject(GroupFilePreviewPortToken)
-]);
+_dec = injectable([inject(CliFsToken), inject(DomainSourceParserPortToken)]);
 let _ArrangeFileProcessorServiceImpl;
 (class {
 	fs;
 	domainSourceParser;
-	groupFilePreview;
 	static {
 		({c: [_ArrangeFileProcessorServiceImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fs, domainSourceParser, groupFilePreview) {
+	constructor(fs, domainSourceParser) {
 		this.fs = fs;
 		this.domainSourceParser = domainSourceParser;
-		this.groupFilePreview = groupFilePreview;
 	}
 	processFile(args) {
-		return groupFile(args.filePath, args.options, this.fs, this.domainSourceParser, this.groupFilePreview);
+		const { filePath, options } = args;
+		const sourceText = this.fs.readFileSync(filePath, "utf8");
+		const domainSfInitial = this.domainSourceParser.parseDomainSourceFile(filePath, sourceText);
+		const unwrap = buildGroupFileUnwrapState(domainSfInitial, sourceText);
+		const work = tryBuildGroupFileWorkPlan({
+			filePath,
+			sourceText,
+			domainSfInitial,
+			domainSfGrouped: this.domainSourceParser.parseDomainSourceFile(filePath, unwrap.textAfterUnwrap),
+			withClassName: options.withClassName,
+			unwrap
+		});
+		if (work === null) return groupFileDryRunNoEdits(filePath);
+		if (!options.write) {
+			if (groupFileWorkHasNothingToReport(work)) return groupFileDryRunNoEdits(filePath);
+			return {
+				...groupFilePreviewTotals(work),
+				workPlan: work
+			};
+		}
+		const persistedEditCount = countPersistedGroupFileEdits(work);
+		let newText = mergeGroupFileBodyText(work);
+		if (persistedEditCount > 0) {
+			if (groupFileEditsTouchJsxCn(work)) newText = ensureCnImport(this.domainSourceParser.parseDomainSourceFile(filePath, newText), options.cnImport);
+			this.fs.writeFileSync(filePath, newText, "utf8");
+		}
+		return {
+			filePath,
+			totalFound: persistedEditCount + work.cnInTvNoReplacement,
+			changed: persistedEditCount
+		};
 	}
 	static {
 		_initClass();

package/dist/lib/arrange/application/services/arrange-target-path-resolver.service.mjs

@@ -0,0 +1,21 @@
+import path from "node:path";
+//#region src/lib/arrange/application/services/arrange-target-path-resolver.service.ts
+const PACKAGE_JSON_FILE = "package.json";
+function findNearestPackageDirectory(currentWorkingDirectory, fs) {
+	let currentDir = path.resolve(currentWorkingDirectory);
+	while (true) {
+		const packageJsonPath = path.join(currentDir, PACKAGE_JSON_FILE);
+		if (fs.existsSync(packageJsonPath)) return currentDir;
+		const parentDirectory = path.dirname(currentDir);
+		if (parentDirectory === currentDir) return;
+		currentDir = parentDirectory;
+	}
+}
+function resolveArrangeTargetPath(args) {
+	const explicitTargetPath = args.rawTarget ? path.isAbsolute(args.rawTarget) ? path.resolve(args.rawTarget) : path.resolve(args.currentWorkingDirectory, args.rawTarget) : void 0;
+	if (explicitTargetPath) return args.fs.canonicalPathSync(explicitTargetPath);
+	const resolvedDefaultTarget = findNearestPackageDirectory(args.currentWorkingDirectory, args.fs) ?? args.currentWorkingDirectory;
+	return args.fs.canonicalPathSync(resolvedDefaultTarget);
+}
+//#endregion
+export { resolveArrangeTargetPath };

package/dist/lib/arrange/application/services/arrange-target-scanner.service.mjs

@@ -1,5 +1,5 @@
 import { FileWalkerPortToken } from "../../contracts/tokens.mjs";
-import { CliPathToken } from "../../../core/operational/contracts/tokens.mjs";
+import { CliFsToken, CliPathToken } from "../../../core/contracts/tokens.mjs";
 import { inject, injectable } from "@codefast/di";
 //#region src/lib/arrange/application/services/arrange-target-scanner.service.ts
 function toPrimitive(input, hint) {
@@ -212,21 +212,27 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-_dec = injectable([inject(FileWalkerPortToken), inject(CliPathToken)]);
+_dec = injectable([
+	inject(FileWalkerPortToken),
+	inject(CliPathToken),
+	inject(CliFsToken)
+]);
 let _ArrangeTargetScannerServiceImpl;
 (class {
 	fileWalker;
 	path;
+	fs;
 	static {
 		({c: [_ArrangeTargetScannerServiceImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fileWalker, path) {
+	constructor(fileWalker, path, fs) {
 		this.fileWalker = fileWalker;
 		this.path = path;
+		this.fs = fs;
 	}
 	scanTarget(args) {
 		const resolvedTargetPath = this.path.resolve(args.targetPath);
-		if (args.fs.statSync(resolvedTargetPath).isDirectory()) return this.fileWalker.walkTypeScriptFiles(resolvedTargetPath, args.fs);
+		if (this.fs.statSync(resolvedTargetPath).isDirectory()) return this.fileWalker.walkTypeScriptFiles(resolvedTargetPath);
 		return [resolvedTargetPath];
 	}
 	static {

package/dist/lib/arrange/application/use-cases/analyze-directory.use-case.mjs

@@ -1,8 +1,8 @@
-import { ArrangeTargetScannerToken, DomainSourceParserPortToken } from "../../contracts/tokens.mjs";
-import { CliFsToken } from "../../../core/operational/contracts/tokens.mjs";
-import { appError } from "../../../core/domain/errors.domain.mjs";
+import { ArrangeTargetScannerServiceToken, DomainSourceParserPortToken } from "../../contracts/tokens.mjs";
+import { CliFsToken } from "../../../core/contracts/tokens.mjs";
+import { AppError } from "../../../core/domain/errors.domain.mjs";
 import { err, ok } from "../../../core/domain/result.model.mjs";
-import { messageFromCaughtUnknown } from "../../../core/application/utils/caught-unknown-message.util.mjs";
+import { messageFromCaughtUnknown } from "../../../core/domain/caught-unknown-message.value-object.mjs";
 import { accumulateAnalyzeReportForSourceFile, createEmptyAnalyzeReport } from "../../domain/arrange-analyze.service.mjs";
 import { inject, injectable } from "@codefast/di";
 //#region src/lib/arrange/application/use-cases/analyze-directory.use-case.ts
@@ -218,7 +218,7 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 let _dec, _initClass;
 _dec = injectable([
 	inject(CliFsToken),
-	inject(ArrangeTargetScannerToken),
+	inject(ArrangeTargetScannerServiceToken),
 	inject(DomainSourceParserPortToken)
 ]);
 let _AnalyzeDirectoryUseCaseImpl;
@@ -237,17 +237,14 @@ let _AnalyzeDirectoryUseCaseImpl;
 	execute(request) {
 		const report = createEmptyAnalyzeReport();
 		try {
-			const files = this.targetScanner.scanTarget({
-				targetPath: request.analyzeRootPath,
-				fs: this.fs
-			});
+			const files = this.targetScanner.scanTarget({ targetPath: request.analyzeRootPath });
 			for (const filePath of files) {
 				const sourceText = this.fs.readFileSync(filePath, "utf8");
 				accumulateAnalyzeReportForSourceFile(report, this.domainSourceParser.parseDomainSourceFile(filePath, sourceText), sourceText, filePath);
 			}
 			return ok(report);
 		} catch (caughtError) {
-			return err(appError("INFRA_FAILURE", messageFromCaughtUnknown(caughtError), caughtError));
+			return err(new AppError("INFRA_FAILURE", messageFromCaughtUnknown(caughtError), caughtError));
 		}
 	}
 	static {