@codefast/cli 0.3.13-canary.3 → 0.3.13

package/dist/lib/tag/presentation/present-tag-sync-result.presenter.mjs

@@ -0,0 +1,233 @@
+import { CliLoggerToken } from "../../core/operational/contracts/tokens.mjs";
+import { presentTagSyncCliResult } from "./tag-sync.presenter.mjs";
+import { inject, injectable } from "@codefast/di";
+//#region src/lib/tag/presentation/present-tag-sync-result.presenter.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(CliLoggerToken)]);
+let _PresentTagSyncResultPresenterImpl;
+(class {
+	logger;
+	static {
+		({c: [_PresentTagSyncResultPresenterImpl, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(logger) {
+		this.logger = logger;
+	}
+	present(result, rootDir) {
+		return presentTagSyncCliResult(this.logger, result, rootDir);
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _PresentTagSyncResultPresenterImpl as PresentTagSyncResultPresenterImpl };

package/dist/lib/tag/presentation/resolve-tag-cli-target.presenter.mjs

@@ -0,0 +1,9 @@
+import path from "node:path";
+//#region src/lib/tag/presentation/resolve-tag-cli-target.presenter.ts
+function resolveTagCliTargetPath(input) {
+	if (input.rawTarget === void 0) return;
+	const candidate = path.isAbsolute(input.rawTarget) ? path.resolve(input.rawTarget) : path.resolve(input.currentWorkingDirectory, input.rawTarget);
+	return input.fs.canonicalPathSync(candidate);
+}
+//#endregion
+export { resolveTagCliTargetPath };

package/dist/lib/tag/presentation/resolve-tag-workspace-root.presenter.mjs

@@ -0,0 +1,12 @@
+import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
+//#region src/lib/tag/presentation/resolve-tag-workspace-root.presenter.ts
+function resolveTagWorkspaceRootPath(input) {
+	try {
+		return input.resolveStrictRepoRoot();
+	} catch (caughtRepoRootError) {
+		input.logger.out(`[tag] workspace root auto-detection failed (${messageFromCaughtUnknown(caughtRepoRootError)}), using cwd=${input.currentWorkingDirectory}`);
+		return input.currentWorkingDirectory;
+	}
+}
+//#endregion
+export { resolveTagWorkspaceRootPath };

package/dist/lib/tag/presentation/tag-cli-schema.presenter.mjs

@@ -0,0 +1,12 @@
+import { z } from "zod";
+//#region src/lib/tag/presentation/tag-cli-schema.presenter.ts
+const tagSyncRunRequestSchema = z.object({
+	rootDir: z.string().min(1),
+	write: z.boolean(),
+	json: z.boolean().optional(),
+	targetPath: z.string().optional(),
+	skipPackages: z.array(z.string()).optional(),
+	config: z.unknown().optional()
+});
+//#endregion
+export { tagSyncRunRequestSchema };

package/dist/lib/tag/presentation/tag-sync.presenter.mjs

@@ -0,0 +1,78 @@
+import "../../core/domain/cli-exit-codes.domain.mjs";
+import { exitCodeForTagSyncResult } from "../application/tag-sync-cli-result.mjs";
+import { TAG_COLORS, withTagColor } from "./colors.presenter.mjs";
+//#region src/lib/tag/presentation/tag-sync.presenter.ts
+function targetDisplayName(target) {
+	return target.packageName ?? target.rootRelativeTargetPath;
+}
+function warningsAndErrorsFromResult(result) {
+	const entries = [];
+	for (const targetResult of result.targetResults) if (targetResult.runError) entries.push(targetResult.runError);
+	if (result.hookError) entries.push(result.hookError);
+	return entries;
+}
+function formatProgress(event) {
+	if (event.type === "target-started") return `[tag] Processing ${targetDisplayName(event.target)}...`;
+	const changedFiles = event.result.result?.filesChanged ?? 0;
+	return `[tag] Done ${targetDisplayName(event.target)} (${changedFiles} changes)`;
+}
+function formatTargetTable(targets, rootDir) {
+	const packageColumnWidth = Math.max(7, ...targets.map((target) => (target.packageName ?? "-").length));
+	const pathColumnWidth = Math.max(4, ...targets.map((target) => target.rootRelativeTargetPath.length));
+	const lines = [];
+	lines.push(`[tag] Root: ${rootDir}`);
+	lines.push(`[tag] Resolved targets: ${targets.length}`);
+	lines.push("[tag] Targets:");
+	lines.push(`  ${"package".padEnd(packageColumnWidth)}   ${"path".padEnd(pathColumnWidth)}   source`);
+	lines.push(`  ${"-".repeat(packageColumnWidth)}   ${"-".repeat(pathColumnWidth)}   ${"-".repeat(6)}`);
+	for (const target of targets) lines.push(`  ${(target.packageName ?? "-").padEnd(packageColumnWidth)}   ${target.rootRelativeTargetPath.padEnd(pathColumnWidth)}   ${target.source}`);
+	return lines.join("\n");
+}
+function formatWarningsAndErrors(result) {
+	const entries = warningsAndErrorsFromResult(result);
+	if (entries.length === 0) return null;
+	const lines = [withTagColor("⚠️ Warnings & Errors", TAG_COLORS.YELLOW)];
+	for (const entry of entries) lines.push(withTagColor(`- ${entry}`, TAG_COLORS.RED));
+	return lines.join("\n");
+}
+function formatSummary(result) {
+	const isDryRun = result.mode === "dry-run";
+	const summaryPrefix = isDryRun ? "[tag:dry-run]" : "[tag]";
+	const versionSuffix = result.versionSummary === "mixed" && result.distinctVersions.length > 0 ? ` [${result.distinctVersions.join(", ")}]` : "";
+	const summaryColor = result.targetResults.some((targetResult) => targetResult.runError !== null) || result.hookError !== null ? TAG_COLORS.RED : isDryRun ? TAG_COLORS.YELLOW : TAG_COLORS.GREEN;
+	const lines = [withTagColor(`${summaryPrefix} version=${result.versionSummary}${versionSuffix} files=${result.filesChanged}/${result.filesScanned} declarations=${result.taggedDeclarations}`, summaryColor)];
+	if (result.skippedPackages.length > 0) lines.push(`[tag] Skipped: ${result.skippedPackages.length} package(s)`);
+	return lines.join("\n");
+}
+/**
+* Prints tag sync output and returns a process exit code (0 success, 1 when empty targets or hook/run errors).
+*/ function presentTagSyncCliResult(logger, tagResult, rootDir) {
+	logger.out(formatTargetTable(tagResult.selectedTargets, rootDir));
+	if (tagResult.selectedTargets.length === 0) {
+		logger.err("No packages found in workspace. Check your pnpm-workspace.yaml or provide an explicit target path.");
+		return 1;
+	}
+	const warningsAndErrorsSection = formatWarningsAndErrors(tagResult);
+	if (warningsAndErrorsSection) logger.err(warningsAndErrorsSection);
+	logger.out(formatSummary(tagResult));
+	return exitCodeForTagSyncResult(tagResult);
+}
+function createTagProgressListener(onProgressLine) {
+	return {
+		onTargetStarted: (target) => {
+			onProgressLine(formatProgress({
+				type: "target-started",
+				target
+			}));
+		},
+		onTargetCompleted: (target, result) => {
+			onProgressLine(formatProgress({
+				type: "target-completed",
+				target,
+				result
+			}));
+		}
+	};
+}
+//#endregion
+export { createTagProgressListener, formatProgress, formatSummary, formatTargetTable, formatWarningsAndErrors, presentTagSyncCliResult };

package/dist/lib/tag/tag.feature.module.mjs

@@ -0,0 +1,19 @@
+import { COMMAND_TOKEN } from "../kernel/di/command.token.mjs";
+import { TagCommand as _TagCommand } from "../../commands/tag.mjs";
+import { TagModule } from "./tag.module.mjs";
+import { TagPresentationModule } from "./tag.presentation.module.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/tag/tag.feature.module.ts
+const TagFeatureModule = Module.create("cli-tag-feature", (moduleBuilder) => {
+	moduleBuilder.import(TagPresentationModule, TagModule);
+	moduleBuilder.bind(_TagCommand).to(_TagCommand).singleton();
+});
+function registerTagFeature(runtimeContainer) {
+	runtimeContainer.load(TagFeatureModule);
+	runtimeContainer.bind(COMMAND_TOKEN).to(_TagCommand).singleton().whenNamed("tag");
+}
+function resolveTagCommand(runtimeContainer) {
+	return runtimeContainer.resolve(_TagCommand);
+}
+//#endregion
+export { TagFeatureModule, registerTagFeature, resolveTagCommand };

package/dist/lib/tag/tag.module.mjs

@@ -0,0 +1,21 @@
+import { CliLoggerToken } from "../core/operational/contracts/tokens.mjs";
+import { withOptionalPortTelemetry } from "../core/infra/logging-decorator.adapter.mjs";
+import { InfraModule } from "../core/infra/infra.module.mjs";
+import { RunTagSyncUseCaseToken, TagSinceWriterPortToken, TagTargetResolverPortToken, TagVersionResolverPortToken, TypeScriptTreeWalkPortToken } from "./contracts/tokens.mjs";
+import { RunTagSyncUseCaseImpl as _RunTagSyncUseCaseImpl } from "./application/use-cases/run-tag-sync.use-case.mjs";
+import { TagSinceWriterAdapter as _TagSinceWriterAdapter } from "./infra/tag-since-writer.adapter.mjs";
+import { TagTargetResolverAdapter as _TagTargetResolverAdapter } from "./infra/tag-target-resolver.adapter.mjs";
+import { TypeScriptTreeWalkAdapter as _TypeScriptTreeWalkAdapter } from "./infra/typescript-tree-walk.adapter.mjs";
+import { TagVersionResolverAdapter as _TagVersionResolverAdapter } from "./infra/tag-version-resolver.adapter.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/tag/tag.module.ts
+const TagModule = Module.create("cli-tag", (moduleBuilder) => {
+	moduleBuilder.import(InfraModule);
+	moduleBuilder.bind(TagTargetResolverPortToken).to(_TagTargetResolverAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("TagTargetResolverPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(TypeScriptTreeWalkPortToken).to(_TypeScriptTreeWalkAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("TypeScriptTreeWalkPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(TagSinceWriterPortToken).to(_TagSinceWriterAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("TagSinceWriterPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(TagVersionResolverPortToken).to(_TagVersionResolverAdapter).onActivation((ctx, implementation) => withOptionalPortTelemetry("TagVersionResolverPort", implementation, ctx.resolve(CliLoggerToken))).singleton();
+	moduleBuilder.bind(RunTagSyncUseCaseToken).to(_RunTagSyncUseCaseImpl).singleton();
+});
+//#endregion
+export { TagModule };

package/dist/lib/tag/tag.presentation.module.mjs

@@ -0,0 +1,15 @@
+import { PresentationModule } from "../core/presentation/presentation.module.mjs";
+import { CreateTagProgressListenerPresenterToken, PrepareTagOrchestratorToken, PresentTagSyncResultPresenterToken } from "./contracts/tokens.mjs";
+import { CreateTagProgressListenerPresenterImpl as _CreateTagProgressListenerPresenterImpl } from "./presentation/create-tag-progress-listener.presenter.mjs";
+import { PrepareTagOrchestrator as _PrepareTagOrchestrator } from "./presentation/prepare-tag.orchestrator.mjs";
+import { PresentTagSyncResultPresenterImpl as _PresentTagSyncResultPresenterImpl } from "./presentation/present-tag-sync-result.presenter.mjs";
+import { Module } from "@codefast/di";
+//#region src/lib/tag/tag.presentation.module.ts
+const TagPresentationModule = Module.create("cli-tag-presentation", (moduleBuilder) => {
+	moduleBuilder.import(PresentationModule);
+	moduleBuilder.bind(PrepareTagOrchestratorToken).to(_PrepareTagOrchestrator).singleton();
+	moduleBuilder.bind(PresentTagSyncResultPresenterToken).to(_PresentTagSyncResultPresenterImpl).singleton();
+	moduleBuilder.bind(CreateTagProgressListenerPresenterToken).to(_CreateTagProgressListenerPresenterImpl).singleton();
+});
+//#endregion
+export { TagPresentationModule };

package/dist/program.mjs

@@ -0,0 +1,39 @@
+import { createCliRuntimeContainer, resolveCliCommands } from "./lib/core/infra/composition-root.mjs";
+import process from "node:process";
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+//#region src/program.ts
+function readVersion() {
+	try {
+		const dir = path.dirname(fileURLToPath(import.meta.url));
+		const raw = readFileSync(path.join(dir, "..", "package.json"), "utf-8");
+		const pkgVersion = JSON.parse(raw).version;
+		return typeof pkgVersion === "string" && pkgVersion.length > 0 ? pkgVersion : "unknown";
+	} catch {
+		return "unknown";
+	}
+}
+function createProgram(commands) {
+	const program = new Command();
+	program.name("codefast").description("Codefast monorepo developer CLI").version(readVersion()).option("--no-color", "Disable ANSI color output").configureHelp({ sortSubcommands: true }).showHelpAfterError("(use --help for usage)");
+	for (const cliCommand of commands) cliCommand.register(program);
+	return program;
+}
+async function runCli(argv) {
+	const runtimeContainer = createCliRuntimeContainer();
+	try {
+		if (process.env.NODE_ENV !== "production") {
+			runtimeContainer.validate();
+			await runtimeContainer.initializeAsync();
+		}
+		await createProgram(resolveCliCommands(runtimeContainer)).parseAsync(argv, { from: "node" });
+		const code = process.exitCode ?? 0;
+		return typeof code === "number" ? code : Number(code) || 0;
+	} finally {
+		await runtimeContainer.dispose();
+	}
+}
+//#endregion
+export { createProgram, runCli };

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@codefast/cli",
-  "version": "0.3.13-canary.3",
-  "description": "Developer CLI for the Codefast monorepo (mirror, arrange)",
+  "version": "0.3.13",
+  "description": "Developer CLI for the Codefast monorepo (arrange, mirror, tag)",
   "keywords": [
     "cli",
     "codefast",
@@ -22,7 +22,7 @@
     "directory": "packages/cli"
   },
   "bin": {
-    "codefast": "./dist/bin.js"
+    "codefast": "./dist/bin.mjs"
   },
   "files": [
     "dist",
@@ -32,10 +32,7 @@
   ],
   "type": "module",
   "imports": {
-    "#*": [
-      "./dist/*.js",
-      "./dist/*/index.js",
-      "./dist/*",
+    "#/*": [
       "./src/*",
       "./src/*.ts",
       "./src/*.tsx",
@@ -52,29 +49,29 @@
     "picomatch": "^4.0.4",
     "typescript": "^6.0.2",
     "yaml": "^2.8.3",
-    "zod": "^4.3.6"
+    "zod": "^4.3.6",
+    "@codefast/di": "0.3.13"
   },
   "devDependencies": {
-    "@swc/core": "^1.15.24",
-    "@swc/jest": "^0.2.39",
-    "@types/jest": "^30.0.0",
     "@types/node": "^25.6.0",
     "@types/picomatch": "^4.0.3",
     "@typescript/native-preview": "7.0.0-dev.20260411.1",
-    "jest": "^30.3.0",
-    "@codefast/typescript-config": "0.3.13-canary.3"
+    "@vitest/coverage-v8": "^4.1.4",
+    "esbuild": "^0.27.7",
+    "unplugin-swc": "^1.5.9",
+    "vite": "^8.0.8",
+    "vitest": "^4.1.4",
+    "@codefast/typescript-config": "0.3.13"
   },
   "engines": {
     "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "rm -rf dist && tsgo -p tsconfig.build.json",
+    "build": "tsdown",
     "check-types": "tsgo --noEmit",
     "clean": "rm -rf dist",
-    "test": "jest",
-    "check-architecture": "jest src/__tests__/architecture.test.ts",
-    "test:coverage": "jest --coverage",
-    "test:coverage:ci": "jest --coverage --ci",
-    "test:watch": "jest --watch"
+    "test": "vitest run",
+    "test:coverage": "vitest run --coverage",
+    "test:watch": "vitest"
   }
 }

package/dist/bin.d.ts

@@ -1,3 +0,0 @@
-#!/usr/bin/env node
-export {};
-//# sourceMappingURL=bin.d.ts.map

package/dist/bin.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"bin.d.ts","sourceRoot":"","sources":["../src/bin.ts"],"names":[],"mappings":""}

package/dist/commands/arrange.d.ts

@@ -1,3 +0,0 @@
-import type { Command } from "commander";
-export declare function registerArrangeCommand(program: Command): void;
-//# sourceMappingURL=arrange.d.ts.map

package/dist/commands/arrange.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"arrange.d.ts","sourceRoot":"","sources":["../../src/commands/arrange.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAoBzC,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAgH7D"}

package/dist/commands/arrange.js

@@ -1,108 +0,0 @@
-import process from "node:process";
-import { Option } from "commander";
-import { ArrangeAnalyzeDirectoryRequestSchema } from "#lib/arrange/application/requests/analyze-directory.request";
-import { ArrangeSyncRunRequestSchema } from "#lib/arrange/application/requests/arrange-sync.request";
-import { ArrangeSuggestGroupsRequestSchema } from "#lib/arrange/application/requests/suggest-groups.request";
-import { createCliContainer } from "#lib/core/infra/container.adapter";
-import { consumeCliAppError } from "#lib/core/presentation/cli-executor.presenter";
-import { parseWithCliSchema } from "#lib/core/presentation/parse-cli-schema.presenter";
-import { runAsyncExitCodeUseCaseAfterParse, runSyncUseCaseAfterParse, } from "#lib/core/presentation/run-cli-use-case-after-parse.presenter";
-function withClassNameOption() {
-    return new Option("--with-classname, --with-class-name", "Append className as final cn() argument").default(false);
-}
-export function registerArrangeCommand(program) {
-    const arrange = program
-        .command("arrange")
-        .description("Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)");
-    arrange
-        .command("analyze")
-        .description("Report long strings, nested cn in tv(), and related findings")
-        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
-        .action(async (target) => {
-        const cli = createCliContainer();
-        const prelude = await cli.arrange.prepareTargetWorkspaceAndConfig({
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: target,
-        });
-        if (!consumeCliAppError(cli.logger, prelude)) {
-            return;
-        }
-        const { resolvedTarget } = prelude.value;
-        const parsed = parseWithCliSchema(ArrangeAnalyzeDirectoryRequestSchema, {
-            analyzeRootPath: resolvedTarget,
-        });
-        runSyncUseCaseAfterParse(cli, parsed, (input) => cli.arrange.analyzeDirectory(input), (report) => cli.arrange.presentAnalyzeReport(resolvedTarget, report));
-    });
-    arrange
-        .command("preview")
-        .description("Dry-run: print suggested replacements without writing files")
-        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
-        .addOption(withClassNameOption())
-        .option("--cn-import <spec>", "Override module specifier when adding cn import")
-        .action(async (target, opts) => {
-        const cli = createCliContainer();
-        const prelude = await cli.arrange.prepareTargetWorkspaceAndConfig({
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: target,
-        });
-        if (!consumeCliAppError(cli.logger, prelude)) {
-            return;
-        }
-        const { resolvedTarget, rootDir, config } = prelude.value;
-        const parsed = parseWithCliSchema(ArrangeSyncRunRequestSchema, {
-            rootDir,
-            targetPath: resolvedTarget,
-            write: false,
-            withClassName: opts.withClassName,
-            cnImport: opts.cnImport,
-            config: config.arrange ?? {},
-        });
-        await runAsyncExitCodeUseCaseAfterParse(cli, parsed, (input) => cli.arrange.runArrangeSync(input));
-    });
-    arrange
-        .command("apply")
-        .description("Apply grouping and cn-in-tv unwrap edits to files")
-        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
-        .addOption(withClassNameOption())
-        .option("--cn-import <spec>", "Override module specifier when adding cn import")
-        .action(async (target, opts) => {
-        const cli = createCliContainer();
-        const prelude = await cli.arrange.prepareTargetWorkspaceAndConfig({
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: target,
-        });
-        if (!consumeCliAppError(cli.logger, prelude)) {
-            return;
-        }
-        const { resolvedTarget, rootDir, config } = prelude.value;
-        const parsed = parseWithCliSchema(ArrangeSyncRunRequestSchema, {
-            rootDir,
-            targetPath: resolvedTarget,
-            write: true,
-            withClassName: opts.withClassName,
-            cnImport: opts.cnImport,
-            config: config.arrange ?? {},
-        });
-        await runAsyncExitCodeUseCaseAfterParse(cli, parsed, (input) => cli.arrange.runArrangeSync(input));
-    });
-    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())
-        .action((tokens, opts) => {
-        const cli = createCliContainer();
-        const parsed = parseWithCliSchema(ArrangeSuggestGroupsRequestSchema, {
-            inlineClasses: tokens.join(" ").trim(),
-            emitTvStyleArray: !!opts.tv,
-            trailingClassName: !!opts.withClassName,
-        });
-        if (!consumeCliAppError(cli.logger, parsed)) {
-            return;
-        }
-        const output = cli.arrange.suggestCnGroups(parsed.value);
-        cli.logger.out(output.primaryLine);
-        cli.logger.out(output.bucketsCommentLine);
-    });
-}

package/dist/commands/mirror.d.ts

@@ -1,3 +0,0 @@
-import { Command } from "commander";
-export declare function registerMirrorCommand(program: Command): void;
-//# sourceMappingURL=mirror.d.ts.map

package/dist/commands/mirror.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../src/commands/mirror.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAOpC,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAoC5D"}