@codefast/cli 0.3.14 → 0.3.16-canary.0

package/dist/mirror/sync-reporter.mjs

@@ -0,0 +1,104 @@
+import { messageFrom } from "../core/errors.mjs";
+import process from "node:process";
+//#region src/mirror/sync-reporter.ts
+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"
+};
+/**
+* Console implementation: ANSI styling and layout for mirror sync.
+*
+* @since 0.3.16-canary.0
+*/
+var MirrorSyncReporter = class {
+	colorsAreEnabled = true;
+	configureMirrorColors(noColor) {
+		this.colorsAreEnabled = !!process.stdout.isTTY && !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: ${messageFrom(errorValue)}`, ANSI.yellow)}\n`);
+		if (verbose) logger.err(errorValue instanceof Error && errorValue.stack ? errorValue.stack : messageFrom(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}`;
+	}
+};
+//#endregion
+export { MirrorSyncReporter };

package/dist/mirror/sync-workspace-package.mjs

@@ -0,0 +1,103 @@
+import { messageFrom } from "../core/errors.mjs";
+import { DIST_DIR, PACKAGE_JSON } from "./domain/constants.mjs";
+import { createPathTransform, generateExports } from "./domain/exports.mjs";
+import { resolvePackageDisplayName } from "./domain/package-display-name.mjs";
+import { writePackageJsonExportsAtomic } from "./write-exports.mjs";
+import { createMirrorDistFilesystem } from "./dist-filesystem-impl.mjs";
+import path from "node:path";
+//#region src/mirror/sync-workspace-package.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function syncExportsForWorkspacePackage(fs, rootDir, packagePathStr, config) {
+	const pathJoin = path.join;
+	const pathResolve = path.resolve;
+	const pathBasename = path.basename;
+	const packageDir = pathResolve(rootDir, packagePathStr);
+	const distDir = pathJoin(packageDir, DIST_DIR);
+	const packageJsonPath = pathJoin(packageDir, PACKAGE_JSON);
+	const folderBasename = pathBasename(packageDir);
+	const distFilesystem = createMirrorDistFilesystem(fs);
+	const pkgStats = {
+		name: folderBasename,
+		path: packageDir,
+		jsModules: 0,
+		cssExports: 0,
+		customExports: 0,
+		totalExports: 0,
+		hasTransform: false,
+		cssConfigStatus: "",
+		skipped: false,
+		skipReason: "",
+		error: null,
+		prunedExportKeys: []
+	};
+	if (!fs.existsSync(packageJsonPath)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "package.json not found";
+		return pkgStats;
+	}
+	let packageJsonParseError;
+	let parsedPackageJson;
+	try {
+		const packageContent = await fs.readFile(packageJsonPath, "utf8");
+		const rawPackageJson = JSON.parse(packageContent);
+		if (rawPackageJson === null || typeof rawPackageJson !== "object" || Array.isArray(rawPackageJson)) throw new SyntaxError("package.json root must be a JSON object");
+		parsedPackageJson = rawPackageJson;
+		pkgStats.name = resolvePackageDisplayName(parsedPackageJson, folderBasename);
+	} catch (caughtError) {
+		pkgStats.name = folderBasename;
+		packageJsonParseError = caughtError;
+	}
+	const packageMeta = { packageName: pkgStats.name };
+	if (isPackageSkipped(config.skipPackages, packageMeta)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "configured to skip";
+		return pkgStats;
+	}
+	if (packageJsonParseError !== void 0) {
+		if (!fs.existsSync(distDir)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "dist/ not found";
+			return pkgStats;
+		}
+		pkgStats.error = messageFrom(packageJsonParseError);
+		return pkgStats;
+	}
+	if (!fs.existsSync(distDir)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "dist/ not found";
+		return pkgStats;
+	}
+	try {
+		const pathTransform = createPathTransform(config, packageMeta);
+		pkgStats.hasTransform = !!pathTransform;
+		const cssConfig = resolvePackageScopedConfig(config.cssExports, packageMeta);
+		if (cssConfig === false) pkgStats.cssConfigStatus = "disabled";
+		else if (cssConfig !== void 0) pkgStats.cssConfigStatus = "configured";
+		const customExports = resolvePackageScopedConfig(config.customExports, packageMeta) || {};
+		const generatedExports = await generateExports(distFilesystem, distDir, pathTransform, cssConfig, customExports);
+		const { prunedKeys } = await writePackageJsonExportsAtomic(fs, packageJsonPath, {
+			generatedExports: generatedExports.exports,
+			managedExportSpecifiers: Object.keys(generatedExports.exports),
+			originalPathBySpecifier: generatedExports.originalPathBySpecifier
+		});
+		pkgStats.jsModules = generatedExports.jsCount;
+		pkgStats.cssExports = generatedExports.cssCount;
+		pkgStats.customExports = Object.keys(customExports).length;
+		pkgStats.totalExports = Object.keys(generatedExports.exports).length;
+		pkgStats.prunedExportKeys = prunedKeys;
+	} catch (caughtError) {
+		pkgStats.error = messageFrom(caughtError);
+	}
+	return pkgStats;
+}
+function resolvePackageScopedConfig(configMap, packageMeta) {
+	if (!configMap) return;
+	return configMap[packageMeta.packageName];
+}
+function isPackageSkipped(skipPackagesList, packageMeta) {
+	return !!skipPackagesList?.includes(packageMeta.packageName);
+}
+//#endregion
+export { syncExportsForWorkspacePackage };

package/dist/mirror/sync.mjs

@@ -0,0 +1,87 @@
+import { AppError, messageFrom } from "../core/errors.mjs";
+import { err, ok } from "../core/result.mjs";
+import { listWorkspacePackageDirectories } from "../core/workspace/resolver.mjs";
+import { normalizePath } from "./domain/path-normalizer.mjs";
+import { resolvePackageFilterUnderRoot } from "./package-path.mjs";
+import { syncExportsForWorkspacePackage } from "./sync-workspace-package.mjs";
+import path from "node:path";
+//#region src/mirror/sync.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function runMirrorSync(fs, input) {
+	const config = input.config ?? {};
+	const { listener } = input;
+	listener?.onBanner();
+	const startTime = performance.now();
+	try {
+		let targetPackages = [];
+		if (input.packageFilter) {
+			const filterOutcome = resolvePackageFilterUnderRoot(fs, input.rootDir, input.packageFilter);
+			if (!filterOutcome.ok) return filterOutcome;
+			targetPackages = [filterOutcome.value];
+			listener?.onProcessingMode({ kind: "single" });
+		} else {
+			const layoutOutcome = await listWorkspacePackageDirectories(input.rootDir, fs, false);
+			const { relPaths, multiSource } = mirrorTargetsFromWorkspaceLayout(input.rootDir, layoutOutcome);
+			targetPackages = relPaths;
+			listener?.onProcessingMode({
+				kind: "multi",
+				source: multiSource
+			});
+		}
+		const stats = {
+			packagesFound: targetPackages.length,
+			packagesProcessed: 0,
+			packagesSkipped: 0,
+			packagesErrored: 0,
+			totalExports: 0,
+			totalJsModules: 0,
+			totalCssExports: 0,
+			packageDetails: []
+		};
+		if (targetPackages.length === 0) {
+			listener?.onNoPackages();
+			listener?.onComplete(stats, (performance.now() - startTime) / 1e3);
+			return ok(stats);
+		}
+		let ordinal = 1;
+		for (const pkgPath of targetPackages) {
+			const pkgStats = await syncExportsForWorkspacePackage(fs, input.rootDir, pkgPath, config);
+			stats.packageDetails.push(pkgStats);
+			listener?.onPackageComplete(pkgStats, ordinal, targetPackages.length);
+			ordinal++;
+			accumulateStats(stats, pkgStats);
+		}
+		const elapsed = (performance.now() - startTime) / 1e3;
+		listener?.onComplete(stats, elapsed);
+		return ok(stats);
+	} catch (caughtError) {
+		return err(new AppError("INFRA_FAILURE", messageFrom(caughtError), caughtError));
+	}
+}
+function 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;
+	}
+}
+function 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
+	};
+}
+//#endregion
+export { runMirrorSync };

package/dist/{lib/mirror/infrastructure/package-json-exports.repository.mjs → mirror/write-exports.mjs}

@@ -1,36 +1,40 @@
-import { messageFromCaughtUnknown } from "../../core/domain/caught-unknown-message.value-object.mjs";
-import { MirrorError, MirrorErrorCode } from "../domain/errors.domain.mjs";
-import { PACKAGE_JSON_EXPORT } from "../domain/constants.domain.mjs";
-//#region src/lib/mirror/infrastructure/package-json-exports.repository.ts
-function containsDistTarget(value) {
-	if (typeof value === "string") return value.startsWith("./dist/");
-	if (Array.isArray(value)) return value.some((entryValue) => containsDistTarget(entryValue));
-	if (value && typeof value === "object") return Object.values(value).some((entryValue) => containsDistTarget(entryValue));
-	return false;
-}
-/**
-* Keep `./package.json` at the very end for aesthetics by default.
-* If a catch-all `./*` exists, move `./package.json` before wildcards so it remains reachable.
-*/ function exportSpecifierRank(exportSpecifier, hasCatchAllWildcard) {
-	if (exportSpecifier === ".") return 0;
-	if (exportSpecifier === "./package.json") return hasCatchAllWildcard ? 2 : 4;
-	if (exportSpecifier.includes("*")) return 3;
-	return 1;
-}
-function compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySpecifier, hasCatchAllWildcard) {
-	const leftRank = exportSpecifierRank(leftSpecifier, hasCatchAllWildcard);
-	const rightRank = exportSpecifierRank(rightSpecifier, hasCatchAllWildcard);
-	if (leftRank !== rightRank) return leftRank - rightRank;
-	const leftOriginalPath = originalPathBySpecifier[leftSpecifier] ?? leftSpecifier;
-	const rightOriginalPath = originalPathBySpecifier[rightSpecifier] ?? rightSpecifier;
-	const originalPathComparison = leftOriginalPath.localeCompare(rightOriginalPath);
-	if (originalPathComparison !== 0) return originalPathComparison;
-	return leftSpecifier.localeCompare(rightSpecifier);
-}
+import { messageFrom } from "../core/errors.mjs";
+import { PACKAGE_JSON_EXPORT } from "./domain/constants.mjs";
+import { MirrorError, MirrorErrorCode } from "./domain/errors.mjs";
+//#region src/mirror/write-exports.ts
 /**
 * Writes `exports` into `package.json` via a temp file + rename (atomic on same volume).
 * Preserves a trailing newline after JSON.
-*/ async function writePackageJsonExportsAtomic(fs, packageJsonPath, mergeInput) {
+*
+* @since 0.3.16-canary.0
+*/
+async function writePackageJsonExportsAtomic(fs, packageJsonPath, mergeInput) {
+	function containsDistTarget(value) {
+		if (typeof value === "string") return value.startsWith("./dist/");
+		if (Array.isArray(value)) return value.some((entryValue) => containsDistTarget(entryValue));
+		if (value && typeof value === "object") return Object.values(value).some((entryValue) => containsDistTarget(entryValue));
+		return false;
+	}
+	/**
+	* Keep `./package.json` at the very end for aesthetics by default.
+	* If a catch-all `./*` exists, move `./package.json` before wildcards so it remains reachable.
+	*/
+	function exportSpecifierRank(exportSpecifier, hasCatchAllWildcard) {
+		if (exportSpecifier === ".") return 0;
+		if (exportSpecifier === "./package.json") return hasCatchAllWildcard ? 2 : 4;
+		if (exportSpecifier.includes("*")) return 3;
+		return 1;
+	}
+	function compareExportSpecifiers(leftSpecifier, rightSpecifier, pathBySpecifier, hasCatchAllWildcard) {
+		const leftRank = exportSpecifierRank(leftSpecifier, hasCatchAllWildcard);
+		const rightRank = exportSpecifierRank(rightSpecifier, hasCatchAllWildcard);
+		if (leftRank !== rightRank) return leftRank - rightRank;
+		const leftOriginalPath = pathBySpecifier[leftSpecifier] ?? leftSpecifier;
+		const rightOriginalPath = pathBySpecifier[rightSpecifier] ?? rightSpecifier;
+		const originalPathComparison = leftOriginalPath.localeCompare(rightOriginalPath);
+		if (originalPathComparison !== 0) return originalPathComparison;
+		return leftSpecifier.localeCompare(rightSpecifier);
+	}
 	const raw = await fs.readFile(packageJsonPath, "utf8");
 	const packageJson = JSON.parse(raw);
 	const existingExports = packageJson.exports;
@@ -81,7 +85,7 @@ function compareExportSpecifiers(leftSpecifier, rightSpecifier, originalPathBySp
 		await fs.rename(tmpPath, packageJsonPath);
 	} catch (caughtRenameError) {
 		await fs.unlink(tmpPath).catch(() => {});
-		throw new MirrorError(MirrorErrorCode.PACKAGE_WRITE, `Failed to atomically update ${packageJsonPath}: ${messageFromCaughtUnknown(caughtRenameError)}`, caughtRenameError instanceof Error ? { cause: caughtRenameError } : void 0);
+		throw new MirrorError(MirrorErrorCode.PACKAGE_WRITE, `Failed to atomically update ${packageJsonPath}: ${messageFrom(caughtRenameError)}`, caughtRenameError instanceof Error ? { cause: caughtRenameError } : void 0);
 	}
 	return { prunedKeys };
 }

package/dist/tag/cli-result.mjs

@@ -0,0 +1,11 @@
+import "../core/exit-codes.mjs";
+//#region src/tag/cli-result.ts
+/**
+* @since 0.3.16-canary.0
+*/
+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/presentation/tag-cli.schema.mjs → tag/cli-schema.mjs}

@@ -1,5 +1,8 @@
 import { z } from "zod";
-//#region src/lib/tag/presentation/tag-cli.schema.ts
+//#region src/tag/cli-schema.ts
+/**
+* @since 0.3.16-canary.0
+*/
 const tagSyncRunRequestSchema = z.object({
 	rootDir: z.string().min(1),
 	write: z.boolean(),

package/dist/tag/command.mjs

@@ -0,0 +1,56 @@
+import { parseWithSchema } from "../core/schema-parse.mjs";
+import { logger } from "../core/logger.mjs";
+import { consumeCliAppError } from "../core/cli/result-handle.mjs";
+import { nodeFilesystem } from "../core/filesystem/node.mjs";
+import { readOptionalPositionalArg } from "../core/cli/positional.mjs";
+import { prepareTagSync } from "./prepare.mjs";
+import { runTagSync } from "./sync.mjs";
+import { tagSyncRunRequestSchema } from "./cli-schema.mjs";
+import { exitCodeForTagSyncResult } from "./cli-result.mjs";
+import { TagSyncProgressPresenter, presentTagSyncResult } from "./output.mjs";
+import process from "node:process";
+import { Command } from "commander";
+//#region src/tag/command.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function createTagCommand() {
+	return new Command("tag").description("Add @since <version> JSDoc tags to exported declarations").alias("annotate").argument("[target]", "Directory or file to annotate (default: auto-discover workspace packages)").option("--dry-run", "Show summary without writing files", false).option("--json", "Print one JSON summary on stdout (suppresses human progress)", false).action(async (target, opts) => {
+		const prelude = await prepareTagSync(nodeFilesystem, {
+			currentWorkingDirectory: process.cwd(),
+			rawTarget: readOptionalPositionalArg(target)
+		});
+		if (!consumeCliAppError(prelude)) return;
+		const { rootDir, config, resolvedTargetPath } = prelude.value;
+		const tagConfig = config.tag ?? {};
+		const parsed = parseWithSchema(tagSyncRunRequestSchema, {
+			rootDir,
+			write: !opts.dryRun,
+			json: opts.json,
+			targetPath: resolvedTargetPath,
+			skipPackages: tagConfig.skipPackages,
+			config: tagConfig
+		});
+		if (!consumeCliAppError(parsed)) return;
+		const progressPresenter = new TagSyncProgressPresenter();
+		const tagOutcome = await runTagSync(nodeFilesystem, {
+			...parsed.value,
+			listener: parsed.value.json ? void 0 : progressPresenter
+		});
+		if (!consumeCliAppError(tagOutcome)) return;
+		if (parsed.value.json) {
+			logger.out(formatTagSyncJsonOutput(tagOutcome.value, rootDir));
+			process.exitCode = exitCodeForTagSyncResult(tagOutcome.value);
+		} else process.exitCode = presentTagSyncResult(tagOutcome.value, rootDir);
+	});
+}
+function formatTagSyncJsonOutput(result, rootDir) {
+	return JSON.stringify({
+		schemaVersion: 1,
+		ok: result.hookError === null,
+		cwd: rootDir,
+		result
+	});
+}
+//#endregion
+export { createTagCommand };

package/dist/{lib/tag/presentation/tag-sync.presenter.mjs → tag/output.mjs}

@@ -1,14 +1,53 @@
-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;
+import "../core/exit-codes.mjs";
+import { logger } from "../core/logger.mjs";
+import { exitCodeForTagSyncResult } from "./cli-result.mjs";
+//#region src/tag/output.ts
+/**
+* @since 0.3.16-canary.0
+*/
+var TagSyncProgressPresenter = class TagSyncProgressPresenter {
+	onTargetStarted(target) {
+		logger.out(TagSyncProgressPresenter.formatProgress({
+			type: "target-started",
+			target
+		}));
+	}
+	onTargetCompleted(target, result) {
+		logger.out(TagSyncProgressPresenter.formatProgress({
+			type: "target-completed",
+			target,
+			result
+		}));
+	}
+	static formatProgress(event) {
+		const targetDisplayName = (target) => target.packageName ?? target.rootRelativeTargetPath;
+		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)`;
+	}
+};
+const colorReset = "\x1B[0m";
+const colors = {
+	red: "\x1B[31m",
+	green: "\x1B[32m",
+	yellow: "\x1B[33m"
+};
+/**
+* @since 0.3.16-canary.0
+*/
+function presentTagSyncResult(result, rootDir) {
+	logger.out(formatTargetTable(result.selectedTargets, rootDir));
+	if (result.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(result);
+	if (warningsAndErrorsSection) logger.err(warningsAndErrorsSection);
+	logger.out(formatSummary(result));
+	return exitCodeForTagSyncResult(result);
 }
-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 withColorizedLine(line, colorCode) {
+	return `${colorCode}${line}${colorReset}`;
 }
 function warningsAndErrorsFromResult(result) {
 	const entries = [];
@@ -31,31 +70,18 @@ function formatTargetTable(targets, rootDir) {
 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));
+	const lines = [withColorizedLine("⚠️ Warnings & Errors", colors.yellow)];
+	for (const entry of entries) lines.push(withColorizedLine(`- ${entry}`, 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)];
+	const summaryColor = result.targetResults.some((targetResult) => targetResult.runError !== null) || result.hookError !== null ? colors.red : isDryRun ? colors.yellow : colors.green;
+	const lines = [withColorizedLine(`${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);
-}
 //#endregion
-export { formatProgress, presentTagSyncCliResult };
+export { TagSyncProgressPresenter, presentTagSyncResult };

package/dist/tag/prepare.mjs

@@ -0,0 +1,29 @@
+import { ok } from "../core/result.mjs";
+import { loadCodefastConfig } from "../core/config.mjs";
+import { findRepoRoot } from "../core/workspace/resolver.mjs";
+import { resolveProvidedTagTargetPath } from "./resolve-target-path.mjs";
+//#region src/tag/prepare.ts
+/**
+* @since 0.3.16-canary.0
+*/
+async function prepareTagSync(fs, args) {
+	let rootDir;
+	try {
+		rootDir = findRepoRoot(args.currentWorkingDirectory, fs);
+	} catch {
+		rootDir = args.currentWorkingDirectory;
+	}
+	const loadedOutcome = await loadCodefastConfig(rootDir, fs);
+	if (!loadedOutcome.ok) return loadedOutcome;
+	const resolvedTargetPath = resolveProvidedTagTargetPath(fs, {
+		currentWorkingDirectory: args.currentWorkingDirectory,
+		rawTarget: args.rawTarget
+	});
+	return ok({
+		rootDir,
+		config: loadedOutcome.value.config,
+		resolvedTargetPath
+	});
+}
+//#endregion
+export { prepareTagSync };

package/dist/tag/resolve-target-path.mjs

@@ -0,0 +1,12 @@
+import path from "node:path";
+//#region src/tag/resolve-target-path.ts
+/**
+* @since 0.3.16-canary.0
+*/
+function resolveProvidedTagTargetPath(fs, args) {
+	if (args.rawTarget === void 0) return;
+	const candidate = path.isAbsolute(args.rawTarget) ? path.resolve(args.rawTarget) : path.resolve(args.currentWorkingDirectory, args.rawTarget);
+	return fs.canonicalPathSync(candidate);
+}
+//#endregion
+export { resolveProvidedTagTargetPath };