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

package/dist/lib/tag/application/engine.mjs

@@ -1,2 +1,287 @@
-import { n as runTagOnTarget, r as runTagSync, t as resolveNearestPackageVersion } from "../../../engine-CcWEHSCq.mjs";
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { applyEditsDescending, indentOfLineContaining } from "../../arrange/domain/ast/ast-helpers.mjs";
+import { walkTsxFiles } from "../../arrange/infra/walk.mjs";
+import "../../arrange/index.mjs";
+import { resolveTagTargetCandidates } from "../infra/target-resolver.mjs";
+import path from "node:path";
+import ts from "typescript";
+//#region src/lib/tag/application/engine.ts
+const PACKAGE_JSON = "package.json";
+const VERSION_TAG = "@since";
+function hasExportModifier(node) {
+	return (ts.canHaveModifiers(node) ? ts.getModifiers(node) : void 0)?.some((modifier) => modifier.kind === ts.SyntaxKind.ExportKeyword) ?? false;
+}
+function isTaggableDeclaration(node) {
+	return ts.isFunctionDeclaration(node) || ts.isClassDeclaration(node) || ts.isInterfaceDeclaration(node) || ts.isTypeAliasDeclaration(node) || ts.isEnumDeclaration(node) || ts.isVariableStatement(node);
+}
+function addDeclarationName(registry, name, declaration) {
+	if (!registry.has(name)) {
+		registry.set(name, new Set([declaration]));
+		return;
+	}
+	registry.get(name).add(declaration);
+}
+function collectLocalNamedDeclarations(sf) {
+	const declarations = /* @__PURE__ */ new Map();
+	for (const statement of sf.statements) {
+		if (ts.isFunctionDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isClassDeclaration(statement) && statement.name) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isInterfaceDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isTypeAliasDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (ts.isEnumDeclaration(statement)) {
+			addDeclarationName(declarations, statement.name.text, statement);
+			continue;
+		}
+		if (!ts.isVariableStatement(statement)) continue;
+		for (const declaration of statement.declarationList.declarations) if (ts.isIdentifier(declaration.name)) addDeclarationName(declarations, declaration.name.text, statement);
+	}
+	return declarations;
+}
+function collectExportedDeclarations(sf) {
+	const exported = /* @__PURE__ */ new Set();
+	const localNamed = collectLocalNamedDeclarations(sf);
+	for (const statement of sf.statements) {
+		if (isTaggableDeclaration(statement) && hasExportModifier(statement)) {
+			exported.add(statement);
+			continue;
+		}
+		if (ts.isExportDeclaration(statement) && !statement.moduleSpecifier && statement.exportClause && ts.isNamedExports(statement.exportClause)) {
+			for (const element of statement.exportClause.elements) {
+				const localName = element.propertyName?.text ?? element.name.text;
+				const declarations = localNamed.get(localName);
+				if (!declarations) continue;
+				for (const declaration of declarations) exported.add(declaration);
+			}
+			continue;
+		}
+		if (!ts.isExportAssignment(statement) || !ts.isIdentifier(statement.expression)) continue;
+		const declarations = localNamed.get(statement.expression.text);
+		if (!declarations) continue;
+		for (const declaration of declarations) exported.add(declaration);
+	}
+	return exported;
+}
+function makeJSDocSinceLine(existingComment, sourceText, version) {
+	const commentText = sourceText.slice(existingComment.pos, existingComment.end);
+	const baseIndent = indentOfLineContaining(sourceText, existingComment.pos);
+	const normalizedBodyLines = commentText.replace(/^\/\*\*\s?/, "").replace(/\s*\*\/$/, "").split("\n").map((line) => line.replace(/^\s*\*\s?/, "").replace(/\s+$/, "")).filter((line, lineIndex, lines) => {
+		if (line.length > 0) return true;
+		const hasNonEmptyBefore = lines.slice(0, lineIndex).some((value) => value.length > 0);
+		const hasNonEmptyAfter = lines.slice(lineIndex + 1).some((value) => value.length > 0);
+		return hasNonEmptyBefore && hasNonEmptyAfter;
+	});
+	const replacement = `/**\n${normalizedBodyLines.length > 0 ? `${normalizedBodyLines.map((line) => `${baseIndent} * ${line}`).join("\n")}\n${baseIndent} *\n` : ""}${baseIndent} * ${VERSION_TAG} ${version}\n${baseIndent} */`;
+	return {
+		start: existingComment.pos,
+		end: existingComment.end,
+		replacement
+	};
+}
+function makeSinceOnlyJSDocBlock(declarationIndent, version) {
+	return `/**\n${declarationIndent} * ${VERSION_TAG} ${version}\n${declarationIndent} */`;
+}
+function makeDeclarationSinceLine(declaration, sf, sourceText, version) {
+	if (ts.getJSDocTags(declaration).some((tag) => tag.tagName.text === "since")) return;
+	const lastJsDoc = ts.getJSDocCommentsAndTags(declaration).filter(ts.isJSDoc).at(-1);
+	if (lastJsDoc) return makeJSDocSinceLine(lastJsDoc, sourceText, version);
+	const start = declaration.getStart(sf);
+	const indent = indentOfLineContaining(sourceText, start);
+	return {
+		start,
+		end: start,
+		replacement: `${indent}${makeSinceOnlyJSDocBlock(indent, version)}\n${indent}`
+	};
+}
+function applySinceTagsToFile(filePath, version, fs, write) {
+	const sourceText = fs.readFileSync(filePath, "utf8");
+	const sf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS);
+	const edits = [];
+	for (const declaration of collectExportedDeclarations(sf)) {
+		const edit = makeDeclarationSinceLine(declaration, sf, sourceText, version);
+		if (edit) edits.push(edit);
+	}
+	if (edits.length > 0 && write) {
+		const updated = applyEditsDescending(sourceText, edits);
+		fs.writeFileSync(filePath, updated, "utf8");
+	}
+	return {
+		filePath,
+		taggedDeclarations: edits.length,
+		changed: edits.length > 0
+	};
+}
+function resolveNearestPackageVersion(targetPath, fs) {
+	const resolved = path.resolve(targetPath);
+	let current = fs.statSync(resolved).isDirectory() ? resolved : path.dirname(resolved);
+	while (true) {
+		const packageJsonPath = path.join(current, PACKAGE_JSON);
+		if (fs.existsSync(packageJsonPath)) {
+			const raw = fs.readFileSync(packageJsonPath, "utf8");
+			const version = JSON.parse(raw).version;
+			if (typeof version === "string" && version.length > 0) return version;
+			throw new Error(`Missing or invalid version in ${packageJsonPath}`);
+		}
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	throw new Error(`Unable to locate ${PACKAGE_JSON} from target: ${targetPath}`);
+}
+function runTagOnTarget(targetPath, opts, fs) {
+	const resolvedTarget = path.resolve(targetPath);
+	const version = resolveNearestPackageVersion(resolvedTarget, fs);
+	const tsFiles = (fs.statSync(resolvedTarget).isDirectory() ? walkTsxFiles(resolvedTarget, fs) : [resolvedTarget]).filter((filePath) => filePath.endsWith(".ts") || filePath.endsWith(".tsx"));
+	const fileResults = tsFiles.map((filePath) => applySinceTagsToFile(filePath, version, fs, opts.write));
+	const filesChanged = fileResults.filter((result) => result.changed).length;
+	const taggedDeclarations = fileResults.reduce((sum, result) => sum + result.taggedDeclarations, 0);
+	return {
+		version,
+		filesScanned: tsFiles.length,
+		filesChanged,
+		taggedDeclarations,
+		fileResults
+	};
+}
+async function runTagOnAfterWriteHook(hook, modifiedFiles) {
+	if (!hook || modifiedFiles.length === 0) return null;
+	try {
+		await hook({ files: modifiedFiles });
+		return null;
+	} catch (caughtHookError) {
+		return `[tag] onAfterWrite hook failed: ${messageFromCaughtUnknown(caughtHookError)}`;
+	}
+}
+function summarizeVersions(targetResults) {
+	const distinctVersions = extractDistinctVersions(targetResults);
+	if (distinctVersions.size === 0) return "none";
+	if (distinctVersions.size > 1) return "mixed";
+	return [...distinctVersions][0];
+}
+function extractDistinctVersions(targetResults) {
+	return new Set(targetResults.map((targetResult) => targetResult.result?.version).filter((version) => typeof version === "string" && version.length > 0));
+}
+function chooseWorkspacePackageTargetPath(candidate, fs) {
+	if (candidate.source !== "workspace-package") return {
+		targetPath: candidate.candidatePath,
+		source: candidate.source
+	};
+	const preferredSourceDir = path.join(candidate.candidatePath, "src");
+	if (fs.existsSync(preferredSourceDir) && fs.statSync(preferredSourceDir).isDirectory()) return {
+		targetPath: preferredSourceDir,
+		source: "workspace-package-selected-src"
+	};
+	return {
+		targetPath: candidate.candidatePath,
+		source: "workspace-package-selected-root"
+	};
+}
+function resolveTargetSelection(candidate, rootDir, fs) {
+	const selectedTarget = chooseWorkspacePackageTargetPath(candidate, fs);
+	const rootRelativeTargetPath = path.relative(rootDir, selectedTarget.targetPath).split(path.sep).join("/");
+	return {
+		targetPath: selectedTarget.targetPath,
+		rootRelativeTargetPath: rootRelativeTargetPath || ".",
+		source: selectedTarget.source,
+		packageDir: candidate.packageDir,
+		packageName: candidate.packageName
+	};
+}
+function filterSkippedCandidates(targetCandidates, skipPackages) {
+	if (!skipPackages || skipPackages.length === 0) return {
+		includedCandidates: targetCandidates,
+		skippedPackages: []
+	};
+	const skipPackageSet = new Set(skipPackages);
+	const includedCandidates = [];
+	const skippedPackages = [];
+	for (const candidate of targetCandidates) {
+		const packageName = candidate.packageName;
+		if (packageName && skipPackageSet.has(packageName)) {
+			skippedPackages.push(packageName);
+			continue;
+		}
+		includedCandidates.push(candidate);
+	}
+	return {
+		includedCandidates,
+		skippedPackages
+	};
+}
+async function runOnResolvedTarget(resolvedTarget, write, fs, listener) {
+	listener?.onTargetStarted(resolvedTarget);
+	const absoluteTargetPath = path.resolve(resolvedTarget.targetPath);
+	if (!fs.existsSync(absoluteTargetPath)) {
+		const missingTargetResult = {
+			target: resolvedTarget,
+			targetExists: false,
+			runError: `Not found: ${absoluteTargetPath}`,
+			result: null
+		};
+		listener?.onTargetCompleted(resolvedTarget, missingTargetResult);
+		return missingTargetResult;
+	}
+	try {
+		const targetRunResult = {
+			target: resolvedTarget,
+			targetExists: true,
+			runError: null,
+			result: runTagOnTarget(absoluteTargetPath, { write }, fs)
+		};
+		listener?.onTargetCompleted(resolvedTarget, targetRunResult);
+		return targetRunResult;
+	} catch (caughtRunError) {
+		const failedTargetRunResult = {
+			target: resolvedTarget,
+			targetExists: true,
+			runError: messageFromCaughtUnknown(caughtRunError),
+			result: null
+		};
+		listener?.onTargetCompleted(resolvedTarget, failedTargetRunResult);
+		return failedTargetRunResult;
+	}
+}
+/**
+* CLI entry: run tagging and optional `onAfterWrite` using config injected by the command layer.
+* Returns structured execution data; presentation/logging belongs to command layer.
+*/
+async function runTagSync(opts) {
+	const { fs } = opts;
+	const { includedCandidates, skippedPackages } = filterSkippedCandidates(await resolveTagTargetCandidates(opts.rootDir, opts.targetPath, fs), opts.skipPackages);
+	const selectedTargets = includedCandidates.map((candidate) => resolveTargetSelection(candidate, opts.rootDir, fs));
+	const targetResults = await Promise.all(selectedTargets.map((resolvedTarget) => runOnResolvedTarget(resolvedTarget, opts.write, fs, opts.listener)));
+	const allFileResults = targetResults.flatMap((targetResult) => targetResult.result?.fileResults ?? []);
+	const filesScanned = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesScanned ?? 0), 0);
+	const filesChanged = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.filesChanged ?? 0), 0);
+	const taggedDeclarations = targetResults.reduce((sum, targetResult) => sum + (targetResult.result?.taggedDeclarations ?? 0), 0);
+	const modifiedFiles = allFileResults.filter((entry) => entry.changed).map((entry) => entry.filePath);
+	const hookError = opts.write && modifiedFiles.length > 0 ? await runTagOnAfterWriteHook(opts.config?.onAfterWrite, modifiedFiles) : null;
+	const distinctVersions = [...extractDistinctVersions(targetResults)].sort((left, right) => left.localeCompare(right));
+	return {
+		mode: opts.write ? "applied" : "dry-run",
+		selectedTargets,
+		resolvedTargets: selectedTargets,
+		skippedPackages,
+		targetResults,
+		filesScanned,
+		filesChanged,
+		taggedDeclarations,
+		versionSummary: summarizeVersions(targetResults),
+		distinctVersions,
+		modifiedFiles,
+		hookError
+	};
+}
+//#endregion
 export { resolveNearestPackageVersion, runTagOnTarget, runTagSync };

package/dist/lib/tag/index.mjs

@@ -1,5 +1,4 @@
-import { n as createNodeCliLogger, t as createNodeCliFs } from "../../node-io-DFRbHO6m.mjs";
-import { n as runTagOnTarget, r as runTagSync, t as resolveNearestPackageVersion } from "../../engine-CcWEHSCq.mjs";
-import { a as formatWarningsAndErrors, i as formatTargetTable, n as formatProgress, r as formatSummary, t as createTagProgressListener } from "../../tag-presenter-Cs66UBsH.mjs";
-import "../../tag-Cd9JujU5.mjs";
+import { createNodeCliFs, createNodeCliLogger } from "../infra/node-io.mjs";
+import { resolveNearestPackageVersion, runTagOnTarget, runTagSync } from "./application/engine.mjs";
+import { createTagProgressListener, formatProgress, formatSummary, formatTargetTable, formatWarningsAndErrors } from "./presentation/tag-presenter.mjs";
 export { createNodeCliFs, createNodeCliLogger, createTagProgressListener, formatProgress, formatSummary, formatTargetTable, formatWarningsAndErrors, resolveNearestPackageVersion, runTagOnTarget, runTagSync };

package/dist/lib/tag/infra/target-resolver.mjs

@@ -1,2 +1,170 @@
-import { t as resolveTagTargetCandidates } from "../../../target-resolver-CR3FXMTy.mjs";
+import { messageFromCaughtUnknown } from "../../infra/caught-unknown-message.mjs";
+import { globSync } from "node:fs";
+import path from "node:path";
+import { z } from "zod";
+import picomatch from "picomatch";
+import { parse } from "yaml";
+//#region src/lib/tag/infra/target-resolver.ts
+const PNPM_WORKSPACE_FILE = "pnpm-workspace.yaml";
+const PACKAGE_JSON_FILE = "package.json";
+const DEFAULT_WORKSPACE_PACKAGE_PATTERNS = ["packages/*"];
+const PnpmWorkspaceSchema = z.object({ packages: z.array(z.string()).optional() }).passthrough();
+const PackageNameSchema = z.object({ name: z.string().min(1).optional() }).passthrough();
+function toPosix(filePath) {
+	return filePath.split(path.sep).join("/");
+}
+function workspacePatternToPackageJsonGlob(pattern) {
+	const normalizedPattern = toPosix(pattern.trim()).replace(/\/+$/, "");
+	if (!normalizedPattern) return `**/${PACKAGE_JSON_FILE}`;
+	return `${normalizedPattern}/${PACKAGE_JSON_FILE}`;
+}
+function splitWorkspacePackagePatterns(rawPatterns) {
+	const include = [];
+	const exclude = [];
+	for (const rawPattern of rawPatterns) {
+		const trimmedPattern = rawPattern.trim();
+		if (!trimmedPattern) continue;
+		if (trimmedPattern.startsWith("!")) {
+			exclude.push(trimmedPattern.slice(1).trim());
+			continue;
+		}
+		include.push(trimmedPattern);
+	}
+	return {
+		include,
+		exclude
+	};
+}
+async function readWorkspacePackagePatterns(rootDir, fs) {
+	const workspaceYamlPath = path.join(rootDir, PNPM_WORKSPACE_FILE);
+	if (!fs.existsSync(workspaceYamlPath)) return {
+		patterns: [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS],
+		hasWorkspaceFile: false,
+		declaredEmptyPackages: false
+	};
+	let workspaceYamlRaw = "";
+	try {
+		workspaceYamlRaw = await fs.readFile(workspaceYamlPath, "utf8");
+	} catch (caughtReadError) {
+		throw new Error(`Failed to read ${PNPM_WORKSPACE_FILE}: ${messageFromCaughtUnknown(caughtReadError)}`);
+	}
+	let parsedWorkspaceDoc;
+	try {
+		parsedWorkspaceDoc = parse(workspaceYamlRaw);
+	} catch (caughtParseError) {
+		throw new Error(`Failed to parse ${PNPM_WORKSPACE_FILE}: ${messageFromCaughtUnknown(caughtParseError)}`);
+	}
+	const parsedWorkspaceResult = PnpmWorkspaceSchema.safeParse(parsedWorkspaceDoc);
+	if (!parsedWorkspaceResult.success) {
+		const issuePath = parsedWorkspaceResult.error.issues[0]?.path.join(".") ?? "<root>";
+		const issueMessage = parsedWorkspaceResult.error.issues[0]?.message ?? "Invalid value";
+		throw new Error(`Invalid ${PNPM_WORKSPACE_FILE} schema at "${issuePath}": ${issueMessage}`);
+	}
+	const hasPackagesKey = typeof parsedWorkspaceDoc === "object" && parsedWorkspaceDoc !== null && Object.prototype.hasOwnProperty.call(parsedWorkspaceDoc, "packages");
+	const workspacePackages = parsedWorkspaceResult.data.packages;
+	if (!workspacePackages) return {
+		patterns: [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS],
+		hasWorkspaceFile: true,
+		declaredEmptyPackages: false
+	};
+	if (workspacePackages.length === 0 && hasPackagesKey) return {
+		patterns: [],
+		hasWorkspaceFile: true,
+		declaredEmptyPackages: true
+	};
+	return {
+		patterns: workspacePackages,
+		hasWorkspaceFile: true,
+		declaredEmptyPackages: false
+	};
+}
+async function discoverWorkspacePackageDirs(rootDir, fs) {
+	const workspacePackages = await readWorkspacePackagePatterns(rootDir, fs);
+	const { include, exclude } = splitWorkspacePackagePatterns(workspacePackages.patterns);
+	const includePatterns = include.length > 0 ? include : [...DEFAULT_WORKSPACE_PACKAGE_PATTERNS];
+	const foundPackageDirs = /* @__PURE__ */ new Set();
+	const globOptions = {
+		cwd: rootDir,
+		posix: true,
+		...path.sep === "\\" ? { windowsPathsNoEscape: true } : {}
+	};
+	for (const pattern of includePatterns) {
+		const matches = globSync(workspacePatternToPackageJsonGlob(pattern), globOptions);
+		for (const matchedPath of matches) {
+			if (!matchedPath.endsWith(`/${PACKAGE_JSON_FILE}`)) continue;
+			const packageRelDir = matchedPath.slice(0, -`/${PACKAGE_JSON_FILE}`.length);
+			if (!packageRelDir) continue;
+			foundPackageDirs.add(path.resolve(rootDir, packageRelDir));
+		}
+	}
+	if (exclude.length === 0) return {
+		packageDirs: [...foundPackageDirs].sort((leftDir, rightDir) => leftDir.localeCompare(rightDir)),
+		hasWorkspaceFile: workspacePackages.hasWorkspaceFile,
+		declaredEmptyPackages: workspacePackages.declaredEmptyPackages
+	};
+	const excludeMatchers = exclude.map((excludePattern) => picomatch(excludePattern, { dot: true }));
+	const discoveredDirs = [...foundPackageDirs].filter((packageDir) => {
+		const relativePackagePath = toPosix(path.relative(rootDir, packageDir));
+		return !excludeMatchers.some((excludeMatcher) => excludeMatcher(relativePackagePath));
+	});
+	discoveredDirs.sort((leftDir, rightDir) => leftDir.localeCompare(rightDir));
+	return {
+		packageDirs: discoveredDirs,
+		hasWorkspaceFile: workspacePackages.hasWorkspaceFile,
+		declaredEmptyPackages: workspacePackages.declaredEmptyPackages
+	};
+}
+function readPackageName(packageDir, fs) {
+	const packageJsonPath = path.join(packageDir, PACKAGE_JSON_FILE);
+	if (!fs.existsSync(packageJsonPath)) return null;
+	try {
+		const rawPackageJson = fs.readFileSync(packageJsonPath, "utf8");
+		const parsedPackageJson = JSON.parse(rawPackageJson);
+		const parsedPackageName = PackageNameSchema.safeParse(parsedPackageJson);
+		if (!parsedPackageName.success) return null;
+		return parsedPackageName.data.name ?? null;
+	} catch {
+		return null;
+	}
+}
+function toRootRelativePath(rootDir, absolutePath) {
+	const relativePath = path.relative(rootDir, absolutePath);
+	return relativePath ? toPosix(relativePath) : ".";
+}
+function toPackageTargetCandidate(rootDir, packageDir, fs) {
+	const packageName = readPackageName(packageDir, fs);
+	return {
+		candidatePath: packageDir,
+		rootRelativeCandidatePath: toRootRelativePath(rootDir, packageDir),
+		source: "workspace-package",
+		packageDir,
+		packageName
+	};
+}
+async function resolveTagTargetCandidates(rootDir, explicitTarget, fs) {
+	if (explicitTarget) {
+		const resolvedExplicitTarget = path.resolve(explicitTarget);
+		return [{
+			candidatePath: resolvedExplicitTarget,
+			rootRelativeCandidatePath: toRootRelativePath(rootDir, resolvedExplicitTarget),
+			source: "explicit-target",
+			packageDir: null,
+			packageName: null
+		}];
+	}
+	const workspaceDiscovery = await discoverWorkspacePackageDirs(rootDir, fs);
+	if (workspaceDiscovery.packageDirs.length === 0) {
+		if (workspaceDiscovery.hasWorkspaceFile) return [];
+		const repoSourceDir = path.join(rootDir, "src");
+		return [{
+			candidatePath: repoSourceDir,
+			rootRelativeCandidatePath: toRootRelativePath(rootDir, repoSourceDir),
+			source: "repo-src-fallback",
+			packageDir: null,
+			packageName: null
+		}];
+	}
+	return workspaceDiscovery.packageDirs.map((packageDir) => toPackageTargetCandidate(rootDir, packageDir, fs));
+}
+//#endregion
 export { resolveTagTargetCandidates };

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

@@ -1,2 +1,12 @@
-import { n as withTagColor, t as TAG_COLORS } from "../../../colors-BjdkCfGK.mjs";
+//#region src/lib/tag/presentation/colors.ts
+const TAG_COLORS = {
+	RESET: "\x1B[0m",
+	RED: "\x1B[31m",
+	GREEN: "\x1B[32m",
+	YELLOW: "\x1B[33m"
+};
+function withTagColor(line, colorCode) {
+	return `${colorCode}${line}${TAG_COLORS.RESET}`;
+}
+//#endregion
 export { TAG_COLORS, withTagColor };

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

@@ -1,2 +1,63 @@
-import { a as formatWarningsAndErrors, i as formatTargetTable, n as formatProgress, r as formatSummary, t as createTagProgressListener } from "../../../tag-presenter-Cs66UBsH.mjs";
+import { TAG_COLORS, withTagColor } from "./colors.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 { createTagProgressListener, formatProgress, formatSummary, formatTargetTable, formatWarningsAndErrors };

package/dist/program.mjs

@@ -1,2 +1,34 @@
-import { n as runCli, t as createProgram } from "./program-DR-H4tH3.mjs";
+import { registerArrangeCommand } from "./commands/arrange.mjs";
+import { registerMirrorCommand } from "./commands/mirror.mjs";
+import { registerTagCommand } from "./commands/tag.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() {
+	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)");
+	registerMirrorCommand(program);
+	registerArrangeCommand(program);
+	registerTagCommand(program);
+	return program;
+}
+async function runCli(argv) {
+	await createProgram().parseAsync(argv, { from: "node" });
+	const code = process.exitCode ?? 0;
+	return typeof code === "number" ? code : Number(code) || 0;
+}
+//#endregion
 export { createProgram, runCli };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.3.13-canary.0",
+  "version": "0.3.13-canary.1",
   "description": "Developer CLI for the Codefast monorepo (mirror, arrange)",
   "keywords": [
     "cli",
@@ -60,7 +60,7 @@
     "@typescript/native-preview": "7.0.0-dev.20260411.1",
     "jest": "^30.3.0",
     "tsdown": "^0.21.8",
-    "@codefast/typescript-config": "0.3.13-canary.0"
+    "@codefast/typescript-config": "0.3.13-canary.1"
   },
   "engines": {
     "node": ">=22.0.0"