@codefast/cli 0.3.14 → 0.3.15

package/dist/{lib → domains}/mirror/application/use-cases/run-mirror-sync.use-case.mjs

@@ -1,11 +1,12 @@
-import { CliFsToken, CliLoggerToken } 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/domain/caught-unknown-message.value-object.mjs";
-import { MirrorSyncReporterPortToken, SyncWorkspacePackagePortToken, WorkspaceServicePortToken } from "../../contracts/tokens.mjs";
-import { formatMirrorSyncJsonOutput } from "../mirror-sync-json.format.mjs";
+import { WorkspacePackageLayoutPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { AppError } from "../../../../shell/domain/errors.domain.mjs";
+import { err, ok } from "../../../../shell/domain/result.model.mjs";
+import { messageFromCaughtUnknown } from "../../../../shell/domain/caught-unknown-message.value-object.mjs";
+import { normalizePath } from "../../domain/path-normalizer.value-object.mjs";
+import { MirrorPackagePathPortToken, SyncWorkspacePackagePortToken } from "../../composition/tokens.mjs";
+import path from "node:path";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/mirror/application/use-cases/run-mirror-sync.use-case.ts
+//#region src/domains/mirror/application/use-cases/run-mirror-sync.use-case.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -217,41 +218,46 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 }
 let _dec, _initClass;
 _dec = injectable([
-	inject(CliFsToken),
-	inject(CliLoggerToken),
-	inject(WorkspaceServicePortToken),
-	inject(MirrorSyncReporterPortToken),
+	inject(MirrorPackagePathPortToken),
+	inject(WorkspacePackageLayoutPortToken),
 	inject(SyncWorkspacePackagePortToken)
 ]);
-let _RunMirrorSyncUseCaseImpl;
+let _RunMirrorSyncUseCase;
 (class {
-	fs;
-	logger;
-	workspaceService;
-	mirrorReporter;
+	mirrorPackagePath;
+	workspacePackageLayout;
 	syncWorkspacePackage;
 	static {
-		({c: [_RunMirrorSyncUseCaseImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+		({c: [_RunMirrorSyncUseCase, _initClass]} = _apply_decs_2311(this, [_dec], []));
 	}
-	constructor(fs, logger, workspaceService, mirrorReporter, syncWorkspacePackage) {
-		this.fs = fs;
-		this.logger = logger;
-		this.workspaceService = workspaceService;
-		this.mirrorReporter = mirrorReporter;
+	constructor(mirrorPackagePath, workspacePackageLayout, syncWorkspacePackage) {
+		this.mirrorPackagePath = mirrorPackagePath;
+		this.workspacePackageLayout = workspacePackageLayout;
 		this.syncWorkspacePackage = syncWorkspacePackage;
 	}
-	async execute(request) {
-		const config = request.config ?? {};
-		const json = !!request.json;
-		if (!json) {
-			this.mirrorReporter.configureMirrorColors(!!request.noColor);
-			this.mirrorReporter.mirrorBanner(this.logger);
-		}
+	async execute(input) {
+		const config = input.config ?? {};
+		const { listener } = input;
+		listener?.onBanner();
 		const startTime = performance.now();
-		const verbose = !!request.verbose;
 		try {
+			let targetPackages = [];
+			if (input.packageFilter) {
+				const filterOutcome = this.mirrorPackagePath.resolvePackageFilterUnderRoot(input.rootDir, input.packageFilter);
+				if (!filterOutcome.ok) return filterOutcome;
+				targetPackages = [filterOutcome.value];
+				listener?.onProcessingMode({ kind: "single" });
+			} else {
+				const layoutOutcome = await this.workspacePackageLayout.listPackageDirectoryPathsAbsolute(input.rootDir, false);
+				const { relPaths, multiSource } = this.mirrorTargetsFromWorkspaceLayout(input.rootDir, layoutOutcome);
+				targetPackages = relPaths;
+				listener?.onProcessingMode({
+					kind: "multi",
+					source: multiSource
+				});
+			}
 			const stats = {
-				packagesFound: 0,
+				packagesFound: targetPackages.length,
 				packagesProcessed: 0,
 				packagesSkipped: 0,
 				packagesErrored: 0,
@@ -260,43 +266,52 @@ let _RunMirrorSyncUseCaseImpl;
 				totalCssExports: 0,
 				packageDetails: []
 			};
-			let targetPackages = [];
-			if (request.packageFilter) {
-				targetPackages = [this.workspaceService.resolvePackageFilterUnderRoot(request.rootDir, request.packageFilter)];
-				if (!json) this.mirrorReporter.mirrorProcessingMode(this.logger, { kind: "single" });
-			} else {
-				const { relPaths, multiSource } = await this.workspaceService.findWorkspacePackageRelPaths(request.rootDir, json ? () => {} : (message) => this.mirrorReporter.logWorkspaceGlobWarning(this.logger, message));
-				targetPackages = relPaths;
-				if (!json) this.mirrorReporter.mirrorProcessingMode(this.logger, {
-					kind: "multi",
-					source: multiSource
-				});
-			}
-			stats.packagesFound = targetPackages.length;
 			if (targetPackages.length === 0) {
-				if (!json) this.mirrorReporter.mirrorNoPackages(this.logger);
-				const elapsedEmpty = (performance.now() - startTime) / 1e3;
-				if (json) this.logger.out(formatMirrorSyncJsonOutput(stats, elapsedEmpty));
+				listener?.onNoPackages();
+				listener?.onComplete(stats, (performance.now() - startTime) / 1e3);
 				return ok(stats);
 			}
-			let nextPackageOrdinal = 1;
+			let ordinal = 1;
 			for (const pkgPath of targetPackages) {
-				const pkgStats = await this.syncWorkspacePackage.syncExportsForWorkspacePackage(request.rootDir, pkgPath, nextPackageOrdinal++, targetPackages.length, config, verbose, stats, json);
+				const pkgStats = await this.syncWorkspacePackage.syncExportsForWorkspacePackage(input.rootDir, pkgPath, config);
 				stats.packageDetails.push(pkgStats);
+				listener?.onPackageComplete(pkgStats, ordinal, targetPackages.length);
+				ordinal++;
+				this.accumulateStats(stats, pkgStats);
 			}
 			const elapsed = (performance.now() - startTime) / 1e3;
-			if (!json) {
-				this.mirrorReporter.mirrorSummarySeparator(this.logger);
-				this.mirrorReporter.mirrorSummary(this.logger, stats, elapsed);
-			} else this.logger.out(formatMirrorSyncJsonOutput(stats, elapsed));
+			listener?.onComplete(stats, elapsed);
 			return ok(stats);
 		} catch (caughtError) {
 			return err(new AppError("INFRA_FAILURE", messageFromCaughtUnknown(caughtError), caughtError));
 		}
 	}
+	accumulateStats(stats, pkgStats) {
+		if (pkgStats.skipped) stats.packagesSkipped++;
+		else if (pkgStats.error !== null) stats.packagesErrored++;
+		else {
+			stats.packagesProcessed++;
+			stats.totalExports += pkgStats.totalExports;
+			stats.totalJsModules += pkgStats.jsModules;
+			stats.totalCssExports += pkgStats.cssExports;
+		}
+	}
+	mirrorTargetsFromWorkspaceLayout(rootDir, layoutOutcome) {
+		if (layoutOutcome.layoutSource === "declared-empty") return {
+			relPaths: [],
+			multiSource: "declared-empty"
+		};
+		const multiSource = layoutOutcome.layoutSource;
+		const relPaths = layoutOutcome.packageDirectoryPathsAbsolute.map((absolutePath) => normalizePath(path.relative(rootDir, absolutePath))).filter((relativePath) => relativePath.length > 0);
+		relPaths.sort((left, right) => left.localeCompare(right));
+		return {
+			relPaths,
+			multiSource
+		};
+	}
 	static {
 		_initClass();
 	}
 });
 //#endregion
-export { _RunMirrorSyncUseCaseImpl as RunMirrorSyncUseCaseImpl };
+export { _RunMirrorSyncUseCase as RunMirrorSyncUseCase };

package/dist/{lib/mirror/contracts → domains/mirror/composition}/tokens.mjs

@@ -1,11 +1,12 @@
 import { token } from "@codefast/di";
-//#region src/lib/mirror/contracts/tokens.ts
-const WorkspaceServicePortToken = token("WorkspaceServicePort");
+//#region src/domains/mirror/composition/tokens.ts
 const PackageRepositoryPortToken = token("PackageRepositoryPort");
+const MirrorPackagePathPortToken = token("MirrorPackagePathPort");
 const FileSystemServicePortToken = token("FileSystemServicePort");
 const MirrorSyncReporterPortToken = token("MirrorSyncReporterPort");
 const SyncWorkspacePackagePortToken = token("SyncWorkspacePackagePort");
 const RunMirrorSyncUseCaseToken = token("RunMirrorSyncUseCase");
 const PrepareMirrorSyncUseCaseToken = token("PrepareMirrorSyncUseCase");
+const PresentMirrorSyncProgressPresenterToken = token("PresentMirrorSyncProgressPresenter");
 //#endregion
-export { FileSystemServicePortToken, MirrorSyncReporterPortToken, PackageRepositoryPortToken, PrepareMirrorSyncUseCaseToken, RunMirrorSyncUseCaseToken, SyncWorkspacePackagePortToken, WorkspaceServicePortToken };
+export { FileSystemServicePortToken, MirrorPackagePathPortToken, MirrorSyncReporterPortToken, PackageRepositoryPortToken, PrepareMirrorSyncUseCaseToken, PresentMirrorSyncProgressPresenterToken, RunMirrorSyncUseCaseToken, SyncWorkspacePackagePortToken };

package/dist/{lib → domains}/mirror/domain/constants.domain.mjs

@@ -1,4 +1,4 @@
-//#region src/lib/mirror/domain/constants.domain.ts
+//#region src/domains/mirror/domain/constants.domain.ts
 const DIST_DIR = "dist";
 const PACKAGE_JSON = "package.json";
 const VALID_JS_EXTENSIONS = new Set([

package/dist/{lib → domains}/mirror/domain/errors.domain.mjs

@@ -1,4 +1,4 @@
-//#region src/lib/mirror/domain/errors.domain.ts
+//#region src/domains/mirror/domain/errors.domain.ts
 const MirrorErrorCode = {
 	FATAL: "FATAL",
 	PACKAGE_WRITE: "PACKAGE_WRITE"

package/dist/{lib/mirror/application/services/generate-mirror-exports.service.mjs → domains/mirror/domain/generate-mirror-exports.domain-service.mjs}

@@ -1,5 +1,5 @@
-import { PACKAGE_JSON_EXPORT, VALID_DTS_EXTENSIONS, VALID_JS_EXTENSIONS } from "../../domain/constants.domain.mjs";
-//#region src/lib/mirror/application/services/generate-mirror-exports.service.ts
+import { PACKAGE_JSON_EXPORT, VALID_DTS_EXTENSIONS, VALID_JS_EXTENSIONS } from "./constants.domain.mjs";
+//#region src/domains/mirror/domain/generate-mirror-exports.domain-service.ts
 function resolvePackageScopedConfig(configMap, pkgMeta) {
 	if (!configMap) return;
 	return configMap[pkgMeta.packageName];

package/dist/{lib → domains}/mirror/domain/package-display-name.policy.mjs

@@ -1,4 +1,4 @@
-//#region src/lib/mirror/domain/package-display-name.policy.ts
+//#region src/domains/mirror/domain/package-display-name.policy.ts
 /**
 * Domain rule: prefer `package.json#name` when it is present, otherwise use folder basename.
 */ function resolvePackageDisplayName(packageJson, folderBasename) {

package/dist/{lib → domains}/mirror/domain/path-normalizer.value-object.mjs

@@ -1,5 +1,5 @@
 import path from "node:path";
-//#region src/lib/mirror/domain/path-normalizer.value-object.ts
+//#region src/domains/mirror/domain/path-normalizer.value-object.ts
 function normalizePath(pathString) {
 	return pathString.split(path.sep).join("/").replace(/\\/g, "/");
 }

package/dist/{lib/mirror/adapters/secondary → domains/mirror/infrastructure/adapters}/file-system-service.adapter.mjs

@@ -1,9 +1,9 @@
-import { CliFsToken } from "../../../core/contracts/tokens.mjs";
-import { isDirentList } from "../../infrastructure/dirent-list.guard.mjs";
+import { CliFilesystemPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { isDirentList } from "../guards/dirent-list.guard.mjs";
 import { normalizePath } from "../../domain/path-normalizer.value-object.mjs";
 import path from "node:path";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/mirror/adapters/secondary/file-system-service.adapter.ts
+//#region src/domains/mirror/infrastructure/adapters/file-system-service.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -214,10 +214,7 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
-function isKnownReadDirError(caughtError) {
-	return typeof caughtError === "object" && caughtError !== null && "code" in caughtError && (caughtError.code === "ENOENT" || caughtError.code === "EACCES");
-}
-_dec = injectable([inject(CliFsToken)]);
+_dec = injectable([inject(CliFilesystemPortToken)]);
 let _FileSystemServiceAdapter;
 (class {
 	fs;
@@ -239,7 +236,7 @@ let _FileSystemServiceAdapter;
 				return normalizePath(path.relative(dirPath, fullPath));
 			});
 		} catch (caughtError) {
-			if (isKnownReadDirError(caughtError)) return [];
+			if (this.isKnownReadDirError(caughtError)) return [];
 			throw caughtError;
 		}
 	}
@@ -253,6 +250,9 @@ let _FileSystemServiceAdapter;
 			return false;
 		}
 	}
+	isKnownReadDirError(caughtError) {
+		return typeof caughtError === "object" && caughtError !== null && "code" in caughtError && (caughtError.code === "ENOENT" || caughtError.code === "EACCES");
+	}
 	static {
 		_initClass();
 	}

package/dist/domains/mirror/infrastructure/adapters/mirror-package-path-resolver.adapter.mjs

@@ -0,0 +1,252 @@
+import { CliFilesystemPortToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { AppError } from "../../../../shell/domain/errors.domain.mjs";
+import { err, ok } from "../../../../shell/domain/result.model.mjs";
+import { normalizePath } from "../../domain/path-normalizer.value-object.mjs";
+import path from "node:path";
+import { inject, injectable } from "@codefast/di";
+//#region src/domains/mirror/infrastructure/adapters/mirror-package-path-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(CliFilesystemPortToken)]);
+let _MirrorPackagePathResolverAdapter;
+(class {
+	fileSystem;
+	static {
+		({c: [_MirrorPackagePathResolverAdapter, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(fileSystem) {
+		this.fileSystem = fileSystem;
+	}
+	resolveFromCliArg(args) {
+		const { rootDir, packageArg, currentWorkingDirectory } = args;
+		if (!packageArg) return ok(void 0);
+		const rootReal = this.fileSystem.canonicalPathSync(path.resolve(rootDir));
+		const cwdReal = this.fileSystem.canonicalPathSync(currentWorkingDirectory);
+		const resolved = path.isAbsolute(packageArg) ? path.resolve(packageArg) : path.resolve(cwdReal, packageArg);
+		const targetReal = this.fileSystem.canonicalPathSync(resolved);
+		const normalized = normalizePath(path.relative(rootReal, targetReal));
+		if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") return err(new AppError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
+		return ok(normalized);
+	}
+	resolvePackageFilterUnderRoot(rootDir, packageFilter) {
+		const rootResolved = path.resolve(rootDir);
+		const rootReal = this.fileSystem.canonicalPathSync(rootResolved);
+		const resolved = path.isAbsolute(packageFilter) ? this.fileSystem.canonicalPathSync(path.resolve(packageFilter)) : this.fileSystem.canonicalPathSync(path.join(rootReal, packageFilter));
+		const normalized = normalizePath(path.relative(rootReal, resolved));
+		if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") return err(new AppError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
+		return ok(normalized);
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _MirrorPackagePathResolverAdapter as MirrorPackagePathResolverAdapter };

package/dist/{lib/mirror/adapters/secondary → domains/mirror/infrastructure/adapters}/mirror-sync-reporter.adapter.mjs

@@ -1,7 +1,7 @@
-import { CliRuntimeToken } from "../../../core/contracts/tokens.mjs";
-import { configureMirrorColors, logPackageError, logPackageSuccess, logPrunedStaleExport, logSkippedWorkspacePackage, mirrorBanner, mirrorGlobWarning, mirrorNoPackages, mirrorProcessingMode, mirrorSummary, mirrorSummarySeparator } from "../../infrastructure/mirror-console-reporter.presenter.mjs";
+import { CliRuntimeToken } from "../../../../shell/application/cli-runtime.tokens.mjs";
+import { messageFromCaughtUnknown } from "../../../../shell/domain/caught-unknown-message.value-object.mjs";
 import { inject, injectable } from "@codefast/di";
-//#region src/lib/mirror/adapters/secondary/mirror-sync-reporter.adapter.ts
+//#region src/domains/mirror/infrastructure/adapters/mirror-sync-reporter.adapter.ts
 function toPrimitive(input, hint) {
 	if (typeof input !== "object" || input === null) return input;
 	var prim = input[Symbol.toPrimitive];
@@ -212,6 +212,18 @@ function _apply_decs_2311(targetClass, classDecs, memberDecs, classDecsHaveThis,
 	};
 }
 let _dec, _initClass;
+const ANSI = {
+	reset: "\x1B[0m",
+	bold: "\x1B[1m",
+	dim: "\x1B[2m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m",
+	cyan: "\x1B[36m",
+	gray: "\x1B[90m",
+	magenta: "\x1B[35m",
+	brightGreen: "\x1B[92m",
+	brightCyan: "\x1B[96m"
+};
 _dec = injectable([inject(CliRuntimeToken)]);
 let _MirrorSyncReporterAdapter;
 (class {
@@ -222,19 +234,86 @@ let _MirrorSyncReporterAdapter;
 	constructor(runtime) {
 		this.runtime = runtime;
 	}
+	colorsAreEnabled = true;
 	configureMirrorColors(noColor) {
-		configureMirrorColors(noColor, this.runtime.isStdoutTty());
-	}
-	mirrorBanner = mirrorBanner;
-	mirrorProcessingMode = mirrorProcessingMode;
-	mirrorNoPackages = mirrorNoPackages;
-	logWorkspaceGlobWarning = mirrorGlobWarning;
-	logSkippedWorkspacePackage = logSkippedWorkspacePackage;
-	logPackageSuccess = logPackageSuccess;
-	logPrunedStaleExport = logPrunedStaleExport;
-	logPackageError = logPackageError;
-	mirrorSummarySeparator = mirrorSummarySeparator;
-	mirrorSummary = mirrorSummary;
+		this.colorsAreEnabled = this.runtime.isStdoutTty() && !noColor;
+	}
+	mirrorBanner(logger) {
+		logger.out(`\n${this.paint("📦 Mirror — package exports", ANSI.bold + ANSI.cyan)}`);
+		logger.out(`${this.paint("═".repeat(60), ANSI.dim)}\n`);
+	}
+	mirrorProcessingMode(logger, mode) {
+		if (mode.kind === "single") {
+			logger.out(`${this.paint("Processing single package...", ANSI.dim)}\n`);
+			return;
+		}
+		if (mode.source === "default-patterns") {
+			logger.out(`${this.paint("Discovering workspace packages using default patterns (packages/*)…", ANSI.dim)}\n`);
+			return;
+		}
+		if (mode.source === "pnpm-workspace-yaml") {
+			logger.out(`${this.paint("Discovering workspace packages from pnpm-workspace.yaml…", ANSI.dim)}\n`);
+			return;
+		}
+		logger.out(`${this.paint("pnpm-workspace.yaml declares an empty workspace package list.", ANSI.dim)}\n`);
+	}
+	mirrorNoPackages(logger) {
+		logger.out(this.paint("⚠ No packages found", ANSI.yellow));
+	}
+	logSkippedWorkspacePackage(logger, index, total, displayName, reason) {
+		const progress = this.paint(`[${index}/${total}]`, ANSI.dim);
+		logger.out(`${progress} ${this.paint("○", ANSI.gray)} ${this.paint(displayName, ANSI.dim)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} ${this.paint(`Skipped: ${reason}`, ANSI.gray)}`);
+		logger.out("");
+	}
+	logPackageSuccess(logger, index, total, pkgStats, generatedDistAssetCounts, verbose) {
+		const progress = this.paint(`[${index}/${total}]`, ANSI.dim);
+		logger.out(`${progress} ${this.paint("✓", ANSI.brightGreen)} ${this.paint(pkgStats.name, ANSI.bold)}`);
+		if (verbose) {
+			logger.out(`  ${this.paint("├─", ANSI.dim)} Path: ${pkgStats.path}`);
+			if (pkgStats.hasTransform) logger.out(`  ${this.paint("├─", ANSI.dim)} ${this.paint("Custom path transformation", ANSI.cyan)}`);
+			if (pkgStats.cssConfigStatus) {
+				const status = pkgStats.cssConfigStatus === "disabled" ? "CSS disabled" : "CSS configured";
+				logger.out(`  ${this.paint("├─", ANSI.dim)} ${this.paint(status, ANSI.cyan)}`);
+			}
+		}
+		const breakdown = [];
+		if (generatedDistAssetCounts.jsCount > 0) breakdown.push(this.paint(`${generatedDistAssetCounts.jsCount} modules`, ANSI.green));
+		if (generatedDistAssetCounts.cssCount > 0) breakdown.push(this.paint(`${generatedDistAssetCounts.cssCount} CSS`, ANSI.magenta));
+		if (pkgStats.customExports > 0) breakdown.push(this.paint(`${pkgStats.customExports} custom`, ANSI.yellow));
+		const totalExportsText = this.paint(`${pkgStats.totalExports} exports`, ANSI.brightCyan);
+		if (breakdown.length === 0) logger.out(`  ${this.paint("└─", ANSI.dim)} ${totalExportsText}`);
+		else logger.out(`  ${this.paint("└─", ANSI.dim)} ${breakdown.join(" + ")} = ${totalExportsText}`);
+		logger.out("");
+	}
+	logPrunedStaleExport(logger, exportSpecifier) {
+		logger.out(`  ${this.paint("└─", ANSI.dim)} ${this.paint(`Pruned stale export: ${exportSpecifier}`, ANSI.gray)}`);
+	}
+	logPackageError(logger, index, total, displayName, errorValue, verbose) {
+		logger.out(`${this.paint(`[${index}/${total}]`, ANSI.dim)} ${this.paint("✗", ANSI.yellow)} ${this.paint(displayName, ANSI.bold)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} ${this.paint(`Error: ${messageFromCaughtUnknown(errorValue)}`, ANSI.yellow)}\n`);
+		if (verbose) logger.err(errorValue instanceof Error && errorValue.stack ? errorValue.stack : messageFromCaughtUnknown(errorValue));
+	}
+	mirrorSummarySeparator(logger) {
+		logger.out(this.paint("═".repeat(60), ANSI.dim));
+	}
+	mirrorSummary(logger, stats, elapsedSeconds) {
+		logger.out(`${this.paint("📊 Summary", ANSI.bold)} ${this.paint(`(completed in ${elapsedSeconds.toFixed(2)}s)`, ANSI.dim)}\n`);
+		logger.out(`  ${this.paint("Packages:", ANSI.bold)}`);
+		logger.out(`  ${this.paint("├─", ANSI.dim)} Processed: ${this.paint(String(stats.packagesProcessed), ANSI.green)}`);
+		if (stats.packagesSkipped > 0) logger.out(`  ${this.paint("├─", ANSI.dim)} Skipped: ${this.paint(String(stats.packagesSkipped), ANSI.gray)}`);
+		if (stats.packagesErrored > 0) logger.out(`  ${this.paint("├─", ANSI.dim)} Errors: ${this.paint(String(stats.packagesErrored), ANSI.yellow)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} Total found: ${stats.packagesFound}\n`);
+		logger.out(`  ${this.paint("Exports:", ANSI.bold)}`);
+		logger.out(`  ${this.paint("├─", ANSI.dim)} JS Modules: ${this.paint(String(stats.totalJsModules), ANSI.cyan)}`);
+		logger.out(`  ${this.paint("├─", ANSI.dim)} CSS Files: ${this.paint(String(stats.totalCssExports), ANSI.magenta)}`);
+		logger.out(`  ${this.paint("└─", ANSI.dim)} Total: ${this.paint(String(stats.totalExports), ANSI.brightCyan)}\n`);
+		logger.out(`${this.paint("═".repeat(60), ANSI.dim)}\n`);
+	}
+	paint(text, openSequence) {
+		if (!this.colorsAreEnabled) return text;
+		return `${openSequence}${text}${ANSI.reset}`;
+	}
 	static {
 		_initClass();
 	}