@codefast/cli 0.3.13-canary.3 → 0.3.13

package/dist/lib/mirror/presentation/prepare-mirror.orchestrator.mjs

@@ -0,0 +1,263 @@
+import { CliFsToken } from "../../core/operational/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 { findRepoRoot } from "../../infra/workspace/repo-root.adapter.mjs";
+import { TryLoadCodefastConfigPresenterToken } from "../../core/contracts/tokens.mjs";
+import { parseGlobalCliOptions } from "../../core/presentation/global-cli-options.presenter.mjs";
+import { resolveMirrorPackageArgToRelative } from "./resolve-mirror-package-arg.presenter.mjs";
+import { inject, injectable } from "@codefast/di";
+//#region src/lib/mirror/presentation/prepare-mirror.orchestrator.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), inject(TryLoadCodefastConfigPresenterToken)]);
+let _PrepareMirrorOrchestrator;
+(class {
+	fs;
+	tryLoadCodefastConfig;
+	static {
+		({c: [_PrepareMirrorOrchestrator, _initClass]} = _apply_decs_2311(this, [_dec], []));
+	}
+	constructor(fs, tryLoadCodefastConfig) {
+		this.fs = fs;
+		this.tryLoadCodefastConfig = tryLoadCodefastConfig;
+	}
+	async execute(args) {
+		const globalsOutcome = parseGlobalCliOptions(args.globalCliRaw);
+		if (!globalsOutcome.ok) return globalsOutcome;
+		let rootDir;
+		try {
+			rootDir = findRepoRoot(this.fs, args.currentWorkingDirectory);
+		} catch (caughtError) {
+			return err(appError("INFRA_FAILURE", messageFromCaughtUnknown(caughtError), caughtError));
+		}
+		const filterOutcome = resolveMirrorPackageArgToRelative({
+			fs: this.fs,
+			rootDir,
+			packageArg: args.packageArg,
+			currentWorkingDirectory: args.currentWorkingDirectory
+		});
+		if (!filterOutcome.ok) return filterOutcome;
+		const loadedOutcome = await this.tryLoadCodefastConfig.execute(rootDir);
+		if (!loadedOutcome.ok) return loadedOutcome;
+		return ok({
+			globals: globalsOutcome.value,
+			rootDir,
+			config: loadedOutcome.value.config,
+			packageFilter: filterOutcome.value
+		});
+	}
+	static {
+		_initClass();
+	}
+});
+//#endregion
+export { _PrepareMirrorOrchestrator as PrepareMirrorOrchestrator };

package/dist/lib/mirror/presentation/reporter.presenter.mjs

@@ -0,0 +1,111 @@
+import { messageFromCaughtUnknown } from "../../core/application/utils/caught-unknown-message.util.mjs";
+import { printConfigSchemaWarnings } from "../../infra/config-reporter.adapter.mjs";
+import process from "node:process";
+//#region src/lib/mirror/presentation/reporter.presenter.ts
+const Colors = {
+	RESET: "\x1B[0m",
+	BOLD: "\x1B[1m",
+	DIM: "\x1B[2m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m",
+	CYAN: "\x1B[36m",
+	GRAY: "\x1B[90m",
+	MAGENTA: "\x1B[35m",
+	BRIGHT_GREEN: "\x1B[92m",
+	BRIGHT_YELLOW: "\x1B[93m",
+	BRIGHT_CYAN: "\x1B[96m",
+	disable() {
+		for (const key of Object.keys(this)) if (typeof this[key] === "string") this[key] = "";
+	}
+};
+function configureMirrorColors(noColor) {
+	if (!process.stdout.isTTY || noColor) Colors.disable();
+}
+function printMirrorConfigWarnings(logger, warnings) {
+	printConfigSchemaWarnings(logger, warnings);
+}
+function mirrorGlobWarning(logger, message) {
+	const { out } = logger;
+	out(`${Colors.YELLOW}⚠ ${message}${Colors.RESET}`);
+}
+function logSkippedWorkspacePackage(logger, index, total, displayName, reason) {
+	const { out } = logger;
+	out(`${`${Colors.DIM}[${index}/${total}]${Colors.RESET}`} ${Colors.GRAY}○${Colors.RESET} ${Colors.DIM}${displayName}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.GRAY}Skipped: ${reason}${Colors.RESET}`);
+	out("");
+}
+function mirrorBanner(logger) {
+	const { out } = logger;
+	out(`\n${Colors.BOLD}${Colors.CYAN}📦 Mirror — package exports${Colors.RESET}`);
+	out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}\n`);
+}
+function mirrorProcessingMode(logger, mode) {
+	const { out } = logger;
+	if (mode.kind === "single") {
+		out(`${Colors.DIM}Processing single package...${Colors.RESET}\n`);
+		return;
+	}
+	switch (mode.source) {
+		case "default-patterns":
+			out(`${Colors.DIM}Discovering workspace packages using default patterns (packages/*)…${Colors.RESET}\n`);
+			break;
+		case "pnpm-workspace-yaml":
+			out(`${Colors.DIM}Discovering workspace packages from pnpm-workspace.yaml…${Colors.RESET}\n`);
+			break;
+		case "declared-empty":
+			out(`${Colors.DIM}pnpm-workspace.yaml declares an empty workspace package list.${Colors.RESET}\n`);
+			break;
+	}
+}
+function mirrorNoPackages(logger) {
+	logger.out(`${Colors.YELLOW}⚠ No packages found${Colors.RESET}`);
+}
+function logPackageSuccess(logger, index, total, pkgStats, generatedDistAssetCounts, verbose) {
+	const { out } = logger;
+	out(`${`${Colors.DIM}[${index}/${total}]${Colors.RESET}`} ${Colors.BRIGHT_GREEN}✓${Colors.RESET} ${Colors.BOLD}${pkgStats.name}${Colors.RESET}`);
+	if (verbose) {
+		out(`  ${Colors.DIM}├─${Colors.RESET} Path: ${pkgStats.path}`);
+		if (pkgStats.hasTransform) out(`  ${Colors.DIM}├─${Colors.RESET} ${Colors.CYAN}Custom path transformation${Colors.RESET}`);
+		if (pkgStats.cssConfigStatus) out(`  ${Colors.DIM}├─${Colors.RESET} ${Colors.CYAN}${pkgStats.cssConfigStatus === "disabled" ? "CSS disabled" : "CSS configured"}${Colors.RESET}`);
+	}
+	const breakdown = [];
+	if (generatedDistAssetCounts.jsCount > 0) breakdown.push(`${Colors.GREEN}${generatedDistAssetCounts.jsCount} modules${Colors.RESET}`);
+	if (generatedDistAssetCounts.cssCount > 0) breakdown.push(`${Colors.MAGENTA}${generatedDistAssetCounts.cssCount} CSS${Colors.RESET}`);
+	if (pkgStats.customExports > 0) breakdown.push(`${Colors.YELLOW}${pkgStats.customExports} custom${Colors.RESET}`);
+	if (breakdown.length > 0) out(`  ${Colors.DIM}└─${Colors.RESET} ${breakdown.join(" + ")} = ${Colors.BRIGHT_CYAN}${pkgStats.totalExports} exports${Colors.RESET}`);
+	else out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.BRIGHT_CYAN}${pkgStats.totalExports} exports${Colors.RESET}`);
+	out("");
+}
+function logPrunedStaleExport(logger, exportSpecifier) {
+	logger.out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.GRAY}Pruned stale export: ${exportSpecifier}${Colors.RESET}`);
+}
+function logPackageError(logger, index, total, displayName, errValue, verbose) {
+	const { out, err: errLine } = logger;
+	out(`${Colors.DIM}[${index}/${total}]${Colors.RESET} ${Colors.YELLOW}✗${Colors.RESET} ${Colors.BOLD}${displayName}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} ${Colors.YELLOW}Error: ${messageFromCaughtUnknown(errValue)}${Colors.RESET}\n`);
+	if (verbose) errLine(errValue instanceof Error && errValue.stack ? errValue.stack : messageFromCaughtUnknown(errValue));
+}
+function mirrorSummarySeparator(logger) {
+	logger.out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}`);
+}
+function mirrorSummary(logger, stats, elapsedSeconds) {
+	const { out } = logger;
+	out(`${Colors.BOLD}📊 Summary${Colors.RESET} ${Colors.DIM}(completed in ${elapsedSeconds.toFixed(2)}s)${Colors.RESET}\n`);
+	out(`  ${Colors.BOLD}Packages:${Colors.RESET}`);
+	out(`  ${Colors.DIM}├─${Colors.RESET} Processed: ${Colors.GREEN}${stats.packagesProcessed}${Colors.RESET}`);
+	if (stats.packagesSkipped > 0) out(`  ${Colors.DIM}├─${Colors.RESET} Skipped: ${Colors.GRAY}${stats.packagesSkipped}${Colors.RESET}`);
+	if (stats.packagesErrored > 0) out(`  ${Colors.DIM}├─${Colors.RESET} Errors: ${Colors.YELLOW}${stats.packagesErrored}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} Total found: ${stats.packagesFound}\n`);
+	out(`  ${Colors.BOLD}Exports:${Colors.RESET}`);
+	out(`  ${Colors.DIM}├─${Colors.RESET} JS Modules: ${Colors.CYAN}${stats.totalJsModules}${Colors.RESET}`);
+	out(`  ${Colors.DIM}├─${Colors.RESET} CSS Files: ${Colors.MAGENTA}${stats.totalCssExports}${Colors.RESET}`);
+	out(`  ${Colors.DIM}└─${Colors.RESET} Total: ${Colors.BRIGHT_CYAN}${stats.totalExports}${Colors.RESET}\n`);
+	out(`${Colors.DIM}${"═".repeat(60)}${Colors.RESET}\n`);
+}
+function mirrorFatalError(logger, caughtError) {
+	const { out, err: errLine } = logger;
+	out(`${Colors.YELLOW}Fatal error: ${messageFromCaughtUnknown(caughtError)}${Colors.RESET}`);
+	errLine(caughtError instanceof Error && caughtError.stack ? caughtError.stack : messageFromCaughtUnknown(caughtError));
+}
+//#endregion
+export { configureMirrorColors, logPackageError, logPackageSuccess, logPrunedStaleExport, logSkippedWorkspacePackage, mirrorBanner, mirrorFatalError, mirrorGlobWarning, mirrorNoPackages, mirrorProcessingMode, mirrorSummary, mirrorSummarySeparator, printMirrorConfigWarnings };

package/dist/lib/mirror/presentation/resolve-mirror-package-arg.presenter.mjs

@@ -0,0 +1,20 @@
+import { appError } from "../../core/domain/errors.domain.mjs";
+import { err, ok } from "../../core/domain/result.model.mjs";
+import path from "node:path";
+//#region src/lib/mirror/presentation/resolve-mirror-package-arg.presenter.ts
+function normalizePathSegments(relPath) {
+	return relPath.split(path.sep).join("/").replace(/\\/g, "/");
+}
+function resolveMirrorPackageArgToRelative(input) {
+	const { fs, rootDir, packageArg, currentWorkingDirectory } = input;
+	if (!packageArg) return ok(void 0);
+	const rootReal = fs.canonicalPathSync(path.resolve(rootDir));
+	const cwdReal = fs.canonicalPathSync(currentWorkingDirectory);
+	const resolved = path.isAbsolute(packageArg) ? path.resolve(packageArg) : path.resolve(cwdReal, packageArg);
+	const targetReal = fs.canonicalPathSync(resolved);
+	const normalized = normalizePathSegments(path.relative(rootReal, targetReal));
+	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") return err(appError("VALIDATION_ERROR", `Package path must be a subdirectory under monorepo root: ${rootDir}`));
+	return ok(normalized);
+}
+//#endregion
+export { resolveMirrorPackageArgToRelative };

package/dist/lib/shared/source-code/domain/text-edit.model.mjs

@@ -0,0 +1,28 @@
+//#region src/lib/shared/source-code/domain/text-edit.model.ts
+/**
+* Pure string utilities for applying non-overlapping text edits and reading line indentation.
+*/ /**
+* Returns only the leading whitespace (tabs / spaces) of the line containing `pos`.
+*/ function indentOfLineContaining(source, pos) {
+	const searchPos = Math.max(0, Math.min(pos, source.length));
+	const prevLineBreak = Math.max(source.lastIndexOf("\n", searchPos - 1), source.lastIndexOf("\r", searchPos - 1));
+	const lineStart = prevLineBreak === -1 ? 0 : prevLineBreak + 1;
+	let lineEnd = source.length;
+	for (let i = lineStart; i < source.length; i++) {
+		const ch = source[i];
+		if (ch === "\n" || ch === "\r") {
+			lineEnd = i;
+			break;
+		}
+	}
+	const line = source.slice(lineStart, lineEnd);
+	return /^[\t ]*/.exec(line)?.[0] ?? "";
+}
+function applyEditsDescending(sourceText, edits) {
+	const sorted = [...edits].sort((editA, editB) => editB.start - editA.start);
+	let out = sourceText;
+	for (const edit of sorted) out = out.slice(0, edit.start) + edit.replacement + out.slice(edit.end);
+	return out;
+}
+//#endregion
+export { applyEditsDescending, indentOfLineContaining };

package/dist/lib/shared/source-code/infra/tsx-file-walk.adapter.mjs

@@ -0,0 +1,33 @@
+import path from "node:path";
+//#region src/lib/shared/source-code/infra/tsx-file-walk.adapter.ts
+const DEFAULT_SKIP_DIRS = new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".turbo",
+	".next",
+	".cache",
+	"out",
+	"build",
+	"coverage",
+	".vercel",
+	".output"
+]);
+function walkTsxFiles(rootDirectoryPath, fs) {
+	const result = [];
+	const visit = (entryPath) => {
+		if (fs.statSync(entryPath).isDirectory()) {
+			for (const childName of fs.readdirSync(entryPath)) {
+				if (DEFAULT_SKIP_DIRS.has(childName)) continue;
+				visit(path.join(entryPath, childName));
+			}
+			return;
+		}
+		if (entryPath.endsWith(".d.ts")) return;
+		if (entryPath.endsWith(".tsx") || entryPath.endsWith(".ts")) result.push(entryPath);
+	};
+	visit(rootDirectoryPath);
+	return result;
+}
+//#endregion
+export { DEFAULT_SKIP_DIRS, walkTsxFiles };

package/dist/lib/tag/application/ports/tag-since-writer.port.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/application/ports/tag-version-resolver.port.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/application/ports/target-resolver.port.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/application/ports/typescript-tree-walk.port.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/application/requests/tag-sync.request.mjs

@@ -0,0 +1 @@
+export {};

package/dist/lib/tag/application/tag-sync-cli-result.mjs

@@ -0,0 +1,11 @@
+import "../../core/domain/cli-exit-codes.domain.mjs";
+//#region src/lib/tag/application/tag-sync-cli-result.ts
+/**
+* Exit code for `codefast tag` / `annotate`, aligned with {@link presentTagSyncCliResult}
+* (empty workspace, run errors, or hook failure → non-zero).
+*/ function exitCodeForTagSyncResult(result) {
+	if (result.selectedTargets.length === 0) return 1;
+	return result.targetResults.some((targetResult) => targetResult.runError !== null) || result.hookError !== null ? 1 : 0;
+}
+//#endregion
+export { exitCodeForTagSyncResult };

package/dist/lib/tag/application/tag-sync-json.format.mjs

@@ -0,0 +1,14 @@
+import "../../core/domain/cli-exit-codes.domain.mjs";
+import { exitCodeForTagSyncResult } from "./tag-sync-cli-result.mjs";
+//#region src/lib/tag/application/tag-sync-json.format.ts
+function formatTagSyncJsonOutput(tagResult, rootDir) {
+	const payload = {
+		schemaVersion: 1,
+		ok: exitCodeForTagSyncResult(tagResult) === 0,
+		rootDir,
+		result: tagResult
+	};
+	return JSON.stringify(payload);
+}
+//#endregion
+export { formatTagSyncJsonOutput };