@codefast/cli 0.3.7-canary.0 → 0.3.13-canary.0

package/dist/report-DYxvw34T.mjs

@@ -0,0 +1,24 @@
+import "./constants-AtPhF-Ct.mjs";
+import path from "node:path";
+//#region src/lib/arrange/presentation/report.ts
+function printAnalyzeReport(analyzeRootDirectoryPath, analyzeReport, logger) {
+	const { out } = logger;
+	out(`Path: ${path.resolve(analyzeRootDirectoryPath)}`);
+	out(`.ts/.tsx files: ${analyzeReport.files}`);
+	out(`cn(...) call sites: ${analyzeReport.cnCallExpressions}`);
+	out(`tv(...) call sites: ${analyzeReport.tvCallExpressions}`);
+	out(`\nLong cn(...) string literals (≥18 tokens — consider splitting arguments): ${analyzeReport.longCnStringLiterals.length}`);
+	for (const findingEntry of analyzeReport.longCnStringLiterals.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (analyzeReport.longCnStringLiterals.length > 40) out(`  … and ${analyzeReport.longCnStringLiterals.length - 40} more`);
+	out(`\nLong tv({...}) string literals in base/variants/… (≥18 tokens): ${analyzeReport.longTvStringLiterals.length}`);
+	for (const findingEntry of analyzeReport.longTvStringLiterals.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (analyzeReport.longTvStringLiterals.length > 40) out(`  … and ${analyzeReport.longTvStringLiterals.length - 40} more`);
+	out(`\nJSX className="..." or className={'...'} (static strings, ≥18 tokens): ${analyzeReport.longJsxClassNameLiterals.length}`);
+	for (const findingEntry of analyzeReport.longJsxClassNameLiterals.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+	if (analyzeReport.longJsxClassNameLiterals.length > 40) out(`  … and ${analyzeReport.longJsxClassNameLiterals.length - 40} more`);
+	out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${analyzeReport.cnInsideTvCalls.length}`);
+	for (const findingEntry of analyzeReport.cnInsideTvCalls.slice(0, 40)) out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
+	if (analyzeReport.cnInsideTvCalls.length > 40) out(`  … and ${analyzeReport.cnInsideTvCalls.length - 40} more`);
+}
+//#endregion
+export { printAnalyzeReport as t };

package/dist/reporter-CwIe_tAM.mjs

@@ -0,0 +1,108 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { t as printConfigSchemaWarnings } from "./config-reporter-SCcWDZc1.mjs";
+import process from "node:process";
+//#region src/lib/mirror/presentation/reporter.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 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 { mirrorBanner as a, mirrorNoPackages as c, mirrorSummarySeparator as d, printMirrorConfigWarnings as f, logSkippedWorkspacePackage as i, mirrorProcessingMode as l, logPackageError as n, mirrorFatalError as o, logPackageSuccess as r, mirrorGlobWarning as s, configureMirrorColors as t, mirrorSummary as u };

package/dist/run-target-CJWrqNT4.mjs

@@ -0,0 +1,65 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { n as walkTsxFiles } from "./walk-DjgQn66n.mjs";
+import { t as groupFile } from "./group-file-ClW7XdD6.mjs";
+import { n as ArrangeErrorCode, t as ArrangeError } from "./errors-CpU1ogfA.mjs";
+import path from "node:path";
+//#region src/lib/arrange/application/run-target.ts
+function runOnTarget(target, options, fs, logger) {
+	const { out } = logger;
+	if (!fs.existsSync(target)) throw new ArrangeError(ArrangeErrorCode.TARGET_NOT_FOUND, `Not found: ${target}`);
+	const filePaths = fs.statSync(target).isDirectory() ? walkTsxFiles(target, fs) : [target];
+	const modifiedFiles = [];
+	let totalFound = 0;
+	let totalChanged = 0;
+	for (const filePath of filePaths) {
+		const result = groupFile(filePath, options, fs, logger);
+		totalFound += result.totalFound;
+		totalChanged += result.changed;
+		if (result.changed > 0) modifiedFiles.push(result.filePath);
+	}
+	out(`\nTotal: ${filePaths.length} file(s), ${totalFound} site(s) (cn/tv/JSX className) to review.`);
+	if (options.write) out(`Applied: ${totalChanged} site(s) updated.`);
+	else out(`(Run "apply" to write changes, or "pnpm cli:arrange-apply" / "pnpm exec codefast arrange apply")`);
+	if (options.write ? totalChanged > 0 : totalFound > 0) out("Note: class order may change across concern groups — smoke-test the UI if you rely on cascade order.");
+	return {
+		filePaths,
+		modifiedFiles,
+		totalFound,
+		totalChanged
+	};
+}
+async function runArrangeOnAfterWriteHook(logger, hook, modifiedFiles) {
+	if (!hook || modifiedFiles.length === 0) return;
+	try {
+		await hook({ files: modifiedFiles });
+	} catch (caughtHookError) {
+		logger.err(`[arrange] onAfterWrite hook failed: ${messageFromCaughtUnknown(caughtHookError)}`);
+	}
+}
+/**
+* CLI entry: run arrange preview/apply using config injected by the command layer.
+* @returns Process exit code (`0`, or `1` when the target path is missing).
+*/
+async function runArrangeSync(opts) {
+	opts.rootDir;
+	const { fs, logger } = opts;
+	const resolvedTarget = path.resolve(opts.targetPath);
+	let result;
+	try {
+		result = runOnTarget(resolvedTarget, {
+			write: opts.write,
+			withClassName: !!opts.withClassName,
+			cnImport: opts.cnImport
+		}, fs, logger);
+	} catch (caughtError) {
+		if (caughtError instanceof ArrangeError && caughtError.code === ArrangeErrorCode.TARGET_NOT_FOUND) {
+			logger.err(caughtError.message);
+			return 1;
+		}
+		throw caughtError;
+	}
+	if (opts.write && result.modifiedFiles.length > 0) await runArrangeOnAfterWriteHook(logger, opts.config?.onAfterWrite, result.modifiedFiles);
+	return 0;
+}
+//#endregion
+export { runOnTarget as n, runArrangeSync as t };

package/dist/schema-Or8RAARd.mjs

@@ -0,0 +1,25 @@
+import { z } from "zod";
+//#region src/lib/config/domain/schema.ts
+const hookSchema = z.custom((value) => typeof value === "function", { message: "Expected a function" });
+const mirrorConfigSchema = z.object({
+	skipPackages: z.array(z.string()).optional(),
+	pathTransformations: z.record(z.string(), z.object({ removePrefix: z.string().optional() }).strict()).optional(),
+	customExports: z.record(z.string(), z.record(z.string(), z.string())).optional(),
+	cssExports: z.record(z.string(), z.union([z.boolean(), z.object({
+		enabled: z.boolean().optional(),
+		customExports: z.record(z.string(), z.string()).optional(),
+		forceExportFiles: z.boolean().optional()
+	}).strict()])).optional()
+}).strict();
+const codefastTagConfigSchema = z.object({
+	skipPackages: z.array(z.string()).optional(),
+	onAfterWrite: hookSchema.optional()
+}).strict();
+const codefastArrangeConfigSchema = z.object({ onAfterWrite: hookSchema.optional() }).strict();
+const codefastConfigSchema = z.object({
+	mirror: mirrorConfigSchema.optional(),
+	tag: codefastTagConfigSchema.optional(),
+	arrange: codefastArrangeConfigSchema.optional()
+}).strict();
+//#endregion
+export { mirrorConfigSchema as a, hookSchema as i, codefastConfigSchema as n, codefastTagConfigSchema as r, codefastArrangeConfigSchema as t };

package/dist/sync-e1Sp-shi.mjs

@@ -0,0 +1,157 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { r as PACKAGE_JSON, t as DIST_DIR } from "./constants-Bq5wdyLC.mjs";
+import { n as generateExports, t as createPathTransform } from "./engine-DRTdkc5u.mjs";
+import { t as resolvePackageFilterUnderRoot } from "./package-filter-C_8ryqvz.mjs";
+import { a as mirrorBanner, c as mirrorNoPackages, d as mirrorSummarySeparator, i as logSkippedWorkspacePackage, l as mirrorProcessingMode, n as logPackageError, o as mirrorFatalError, r as logPackageSuccess, t as configureMirrorColors, u as mirrorSummary } from "./reporter-CwIe_tAM.mjs";
+import { n as resolvePackageDisplayName, r as writePackageJsonExportsAtomic } from "./update-pkg-CnGfjWBy.mjs";
+import { t as findWorkspacePackageRelPaths } from "./workspace-packages-K2NYTHJq.mjs";
+import path from "node:path";
+//#region src/lib/mirror/application/sync.ts
+function resolvePackageScopedConfig(configMap, pkgMeta) {
+	if (!configMap) return void 0;
+	return configMap[pkgMeta.packageName];
+}
+function isPackageSkipped(skipPackagesArray, pkgMeta) {
+	if (!skipPackagesArray) return false;
+	return skipPackagesArray.includes(pkgMeta.packageName);
+}
+async function syncExportsForWorkspacePackage(fs, logger, rootDir, packagePathStr, index, total, config, verbose, stats) {
+	const packageDir = path.resolve(rootDir, packagePathStr);
+	const distDir = path.join(packageDir, DIST_DIR);
+	const packageJsonPath = path.join(packageDir, PACKAGE_JSON);
+	const folderBasename = path.basename(packageDir);
+	const pkgStats = {
+		name: folderBasename,
+		path: packageDir,
+		jsModules: 0,
+		cssExports: 0,
+		customExports: 0,
+		totalExports: 0,
+		hasTransform: false,
+		cssConfigStatus: "",
+		skipped: false,
+		skipReason: "",
+		error: null
+	};
+	if (!fs.existsSync(packageJsonPath)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "package.json not found";
+		stats.packagesSkipped++;
+		logSkippedWorkspacePackage(logger, index, total, folderBasename, pkgStats.skipReason);
+		return pkgStats;
+	}
+	let packageJsonParseError;
+	try {
+		const pkgContent = await fs.readFile(packageJsonPath, "utf8");
+		const raw = JSON.parse(pkgContent);
+		if (raw === null || typeof raw !== "object" || Array.isArray(raw)) throw new SyntaxError("package.json root must be a JSON object");
+		pkgStats.name = resolvePackageDisplayName(raw, folderBasename);
+	} catch (caughtError) {
+		pkgStats.name = folderBasename;
+		packageJsonParseError = caughtError;
+	}
+	const pkgMeta = { packageName: pkgStats.name };
+	if (isPackageSkipped(config.skipPackages, pkgMeta)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "configured to skip";
+		stats.packagesSkipped++;
+		logSkippedWorkspacePackage(logger, index, total, pkgStats.name, pkgStats.skipReason);
+		return pkgStats;
+	}
+	if (packageJsonParseError !== void 0) {
+		if (!fs.existsSync(distDir)) {
+			pkgStats.skipped = true;
+			pkgStats.skipReason = "dist/ not found";
+			stats.packagesSkipped++;
+			logSkippedWorkspacePackage(logger, index, total, pkgStats.name, pkgStats.skipReason);
+			return pkgStats;
+		}
+		pkgStats.error = messageFromCaughtUnknown(packageJsonParseError);
+		stats.packagesErrored++;
+		logPackageError(logger, index, total, pkgStats.name, packageJsonParseError, verbose);
+		return pkgStats;
+	}
+	if (!fs.existsSync(distDir)) {
+		pkgStats.skipped = true;
+		pkgStats.skipReason = "dist/ not found";
+		stats.packagesSkipped++;
+		logSkippedWorkspacePackage(logger, index, total, pkgStats.name, pkgStats.skipReason);
+		return pkgStats;
+	}
+	try {
+		const pathTransform = createPathTransform(config, pkgMeta);
+		pkgStats.hasTransform = !!pathTransform;
+		const cssConfig = resolvePackageScopedConfig(config.cssExports, pkgMeta);
+		if (cssConfig === false) pkgStats.cssConfigStatus = "disabled";
+		else if (cssConfig !== void 0) pkgStats.cssConfigStatus = "configured";
+		const customExports = resolvePackageScopedConfig(config.customExports, pkgMeta) || {};
+		const generatedExports = await generateExports(fs, distDir, pathTransform, cssConfig, customExports);
+		await writePackageJsonExportsAtomic(fs, packageJsonPath, generatedExports.exports);
+		pkgStats.jsModules = generatedExports.jsCount;
+		pkgStats.cssExports = generatedExports.cssCount;
+		pkgStats.customExports = Object.keys(customExports).length;
+		pkgStats.totalExports = Object.keys(generatedExports.exports).length;
+		stats.packagesProcessed++;
+		stats.totalExports += pkgStats.totalExports;
+		stats.totalJsModules += pkgStats.jsModules;
+		stats.totalCssExports += pkgStats.cssExports;
+		logPackageSuccess(logger, index, total, pkgStats, generatedExports, verbose);
+	} catch (caughtError) {
+		pkgStats.error = messageFromCaughtUnknown(caughtError);
+		stats.packagesErrored++;
+		logPackageError(logger, index, total, pkgStats.name, caughtError, verbose);
+	}
+	return pkgStats;
+}
+/** @returns Process exit code (0 or 1). */
+async function runMirrorSync(opts) {
+	const { fs, logger } = opts;
+	const config = opts.config ?? {};
+	configureMirrorColors(!!opts.noColor);
+	mirrorBanner(logger);
+	const startTime = performance.now();
+	const verbose = !!opts.verbose;
+	try {
+		const stats = {
+			packagesFound: 0,
+			packagesProcessed: 0,
+			packagesSkipped: 0,
+			packagesErrored: 0,
+			totalExports: 0,
+			totalJsModules: 0,
+			totalCssExports: 0,
+			packageDetails: []
+		};
+		let targetPackages = [];
+		if (opts.packageFilter) {
+			targetPackages = [resolvePackageFilterUnderRoot(opts.rootDir, opts.packageFilter)];
+			mirrorProcessingMode(logger, { kind: "single" });
+		} else {
+			const { relPaths, multiSource } = await findWorkspacePackageRelPaths(opts.rootDir, fs, logger);
+			targetPackages = relPaths;
+			mirrorProcessingMode(logger, {
+				kind: "multi",
+				source: multiSource
+			});
+		}
+		stats.packagesFound = targetPackages.length;
+		if (targetPackages.length === 0) {
+			mirrorNoPackages(logger);
+			return 0;
+		}
+		let nextPackageOrdinal = 1;
+		for (const pkgPath of targetPackages) {
+			const pkgStats = await syncExportsForWorkspacePackage(fs, logger, opts.rootDir, pkgPath, nextPackageOrdinal++, targetPackages.length, config, verbose, stats);
+			stats.packageDetails.push(pkgStats);
+		}
+		const elapsed = (performance.now() - startTime) / 1e3;
+		mirrorSummarySeparator(logger);
+		mirrorSummary(logger, stats, elapsed);
+		return stats.packagesErrored > 0 ? 1 : 0;
+	} catch (caughtError) {
+		mirrorFatalError(logger, caughtError);
+		return 1;
+	}
+}
+//#endregion
+export { runMirrorSync as t };

package/dist/tag-Cd9JujU5.mjs

@@ -0,0 +1,2 @@
+import "./engine-CcWEHSCq.mjs";
+export {};

package/dist/tag-hEKVZ_-7.mjs

@@ -0,0 +1,58 @@
+import { t as messageFromCaughtUnknown } from "./caught-unknown-message-CRhkDWO7.mjs";
+import { t as loadConfig } from "./loader-DpN-zl5g.mjs";
+import "./config-DVia_f9a.mjs";
+import { t as printConfigSchemaWarnings } from "./config-reporter-SCcWDZc1.mjs";
+import { n as createNodeCliLogger, t as createNodeCliFs } from "./node-io-DFRbHO6m.mjs";
+import { t as findRepoRoot } from "./repo-root-HmtIEm6J.mjs";
+import { r as runTagSync } from "./engine-CcWEHSCq.mjs";
+import { a as formatWarningsAndErrors, i as formatTargetTable, r as formatSummary, t as createTagProgressListener } from "./tag-presenter-Cs66UBsH.mjs";
+import "./tag-Cd9JujU5.mjs";
+import process from "node:process";
+import path from "node:path";
+//#region src/commands/tag.ts
+function resolveTagRootDir(fs, logger) {
+	try {
+		return findRepoRoot(fs);
+	} catch (caughtRepoRootError) {
+		logger.out(`[tag] workspace root auto-detection failed (${messageFromCaughtUnknown(caughtRepoRootError)}), using cwd=${process.cwd()}`);
+		return process.cwd();
+	}
+}
+function registerTagCommand(program) {
+	program.command("tag").alias("annotate").description("Add @since <version> JSDoc tags to exported declarations").argument("[target]", "Directory or file to annotate (default: auto-discover workspace packages)").option("--dry-run", "Show summary without writing files", false).action(async (target, options) => {
+		const fs = createNodeCliFs();
+		const logger = createNodeCliLogger();
+		const rootDir = resolveTagRootDir(fs, logger);
+		let tagConfig = {};
+		try {
+			const { config, warnings } = await loadConfig(fs, rootDir);
+			printConfigSchemaWarnings(logger, warnings);
+			tagConfig = config.tag ?? {};
+		} catch (caughtConfigError) {
+			logger.err(messageFromCaughtUnknown(caughtConfigError));
+			process.exitCode = 1;
+			return;
+		}
+		const tagResult = await runTagSync({
+			rootDir,
+			config: tagConfig,
+			skipPackages: tagConfig.skipPackages,
+			targetPath: target ? path.resolve(target) : void 0,
+			write: !options.dryRun,
+			fs,
+			listener: createTagProgressListener((line) => logger.out(line))
+		});
+		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.");
+			process.exitCode = 1;
+			return;
+		}
+		const warningsAndErrorsSection = formatWarningsAndErrors(tagResult);
+		if (warningsAndErrorsSection) logger.err(warningsAndErrorsSection);
+		logger.out(formatSummary(tagResult));
+		process.exitCode = tagResult.targetResults.some((targetResult) => targetResult.runError !== null) || tagResult.hookError ? 1 : 0;
+	});
+}
+//#endregion
+export { registerTagCommand as t };

package/dist/tag-presenter-Cs66UBsH.mjs

@@ -0,0 +1,63 @@
+import { n as withTagColor, t as TAG_COLORS } from "./colors-BjdkCfGK.mjs";
+//#region src/lib/tag/presentation/tag-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");
+}
+function createTagProgressListener(onProgressLine) {
+	return {
+		onTargetStarted: (target) => {
+			onProgressLine(formatProgress({
+				type: "target-started",
+				target
+			}));
+		},
+		onTargetCompleted: (target, result) => {
+			onProgressLine(formatProgress({
+				type: "target-completed",
+				target,
+				result
+			}));
+		}
+	};
+}
+//#endregion
+export { formatWarningsAndErrors as a, formatTargetTable as i, formatProgress as n, formatSummary as r, createTagProgressListener as t };