@codefast/cli 0.3.12 → 0.3.13-canary.1

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

@@ -0,0 +1,170 @@
+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

@@ -0,0 +1,12 @@
+//#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

@@ -0,0 +1,63 @@
+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

@@ -0,0 +1,34 @@
+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.12",
+  "version": "0.3.13-canary.1",
   "description": "Developer CLI for the Codefast monorepo (mirror, arrange)",
   "keywords": [
     "cli",
@@ -22,7 +22,7 @@
     "directory": "packages/cli"
   },
   "bin": {
-    "codefast": "./dist/bin.js"
+    "codefast": "./dist/bin.mjs"
   },
   "files": [
     "dist",
@@ -33,14 +33,11 @@
   "type": "module",
   "imports": {
     "#*": [
-      "./dist/*.js",
-      "./dist/*/index.js",
-      "./dist/*",
+      "./src/*",
       "./src/*.ts",
       "./src/*.tsx",
       "./src/*/index.ts",
-      "./src/*/index.tsx",
-      "./src/*"
+      "./src/*/index.tsx"
     ]
   },
   "publishConfig": {
@@ -48,9 +45,11 @@
   },
   "dependencies": {
     "commander": "^14.0.3",
+    "jiti": "^2.6.1",
     "picomatch": "^4.0.4",
     "typescript": "^6.0.2",
-    "yaml": "^2.8.3"
+    "yaml": "^2.8.3",
+    "zod": "^4.3.6"
   },
   "devDependencies": {
     "@swc/core": "^1.15.24",
@@ -60,13 +59,14 @@
     "@types/picomatch": "^4.0.3",
     "@typescript/native-preview": "7.0.0-dev.20260411.1",
     "jest": "^30.3.0",
-    "@codefast/typescript-config": "0.3.12"
+    "tsdown": "^0.21.8",
+    "@codefast/typescript-config": "0.3.13-canary.1"
   },
   "engines": {
-    "node": ">=24.0.0"
+    "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "rm -rf dist && tsgo -p tsconfig.build.json",
+    "build": "tsdown",
     "check-types": "tsgo --noEmit",
     "clean": "rm -rf dist",
     "test": "jest",

package/dist/bin.d.ts

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

package/dist/bin.d.ts.map

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

package/dist/commands/arrange.d.ts

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

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

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

package/dist/commands/arrange.js

@@ -1,114 +0,0 @@
-import path from "node:path";
-import process from "node:process";
-import { Option } from "commander";
-import { ArrangeError, ArrangeErrorCode, analyzeDirectory, createNodeCliFs, createNodeCliLogger, DEFAULT_ARRANGE_TARGET, formatArray, formatCnCall, printAnalyzeReport, runOnTarget, suggestCnGroups, summarizeGroupBucketLabels, } from "#lib/arrange";
-/** Commander attribute `withClassName` (second long flag `--with-class-name`). */
-function createWithClassNameOption() {
-    return new Option("--with-classname, --with-class-name", "Append className as final cn() argument").default(false);
-}
-function defaultTargetPath() {
-    return path.resolve(process.cwd(), DEFAULT_ARRANGE_TARGET);
-}
-function checkTargetExists(resolved, fs, logger) {
-    if (!fs.existsSync(resolved)) {
-        logger.err(`Not found: ${resolved}`);
-        process.exitCode = 1;
-        return false;
-    }
-    return true;
-}
-function handleArrangeLibError(e, logger) {
-    if (e instanceof ArrangeError && e.code === ArrangeErrorCode.TARGET_NOT_FOUND) {
-        logger.err(e.message);
-        process.exitCode = 1;
-        return true;
-    }
-    return false;
-}
-function runArrangeAction(resolvedTarget, runOpts, fs, logger) {
-    try {
-        runOnTarget(resolvedTarget, {
-            write: runOpts.write,
-            withClassName: !!runOpts.withClassName,
-            cnImport: runOpts.cnImport,
-        }, fs, logger);
-    }
-    catch (e) {
-        if (!handleArrangeLibError(e, logger))
-            throw e;
-    }
-}
-export function registerArrangeCommand(program) {
-    const arrange = program
-        .command("arrange")
-        .description("Analyze and regroup Tailwind classes in cn() / tv() calls (Tailwind v4)");
-    arrange
-        .command("analyze")
-        .description("Report long strings, nested cn in tv(), and related findings")
-        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
-        .action((target) => {
-        const fs = createNodeCliFs();
-        const logger = createNodeCliLogger();
-        const resolved = target ? path.resolve(target) : defaultTargetPath();
-        if (!checkTargetExists(resolved, fs, logger))
-            return;
-        printAnalyzeReport(resolved, analyzeDirectory(resolved, fs), logger);
-    });
-    arrange
-        .command("preview")
-        .description("Dry-run: print suggested replacements without writing files")
-        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
-        .addOption(createWithClassNameOption())
-        .option("--cn-import <spec>", "Override module specifier when adding cn import")
-        .action((target, opts) => {
-        const fs = createNodeCliFs();
-        const logger = createNodeCliLogger();
-        const resolved = target ? path.resolve(target) : defaultTargetPath();
-        if (!checkTargetExists(resolved, fs, logger))
-            return;
-        runArrangeAction(resolved, {
-            write: false,
-            withClassName: opts.withClassName,
-            cnImport: opts.cnImport,
-        }, fs, logger);
-    });
-    arrange
-        .command("apply")
-        .description("Apply grouping and cn-in-tv unwrap edits to files")
-        .argument("[target]", "Directory or file (default: packages/ui/src/components)")
-        .addOption(createWithClassNameOption())
-        .option("--cn-import <spec>", "Override module specifier when adding cn import")
-        .action((target, opts) => {
-        const fs = createNodeCliFs();
-        const logger = createNodeCliLogger();
-        const resolved = target ? path.resolve(target) : defaultTargetPath();
-        if (!checkTargetExists(resolved, fs, logger))
-            return;
-        runArrangeAction(resolved, {
-            write: true,
-            withClassName: opts.withClassName,
-            cnImport: opts.cnImport,
-        }, fs, logger);
-    });
-    arrange
-        .command("group")
-        .description("Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)")
-        .argument("[tokens...]", "Class tokens (quote a single string if it contains spaces)")
-        .option("--tv", "Emit tv()-style array instead of cn() call", false)
-        .addOption(createWithClassNameOption())
-        .action((tokens, opts) => {
-        const inlineClasses = tokens.join(" ").trim();
-        if (!inlineClasses) {
-            process.stderr.write('Pass a class string. Example: codefast arrange group "flex gap-2 text-sm rounded-md"\n');
-            process.exitCode = 1;
-            return;
-        }
-        const groups = suggestCnGroups(inlineClasses);
-        const result = opts.tv
-            ? formatArray(groups)
-            : formatCnCall(groups, { trailingClassName: !!opts.withClassName });
-        process.stdout.write(`${result}\n`);
-        const bucketSummary = summarizeGroupBucketLabels(groups);
-        process.stdout.write(`\n// Buckets: ${JSON.stringify(bucketSummary)}\n`);
-    });
-}

package/dist/commands/mirror.d.ts

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

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

@@ -1 +0,0 @@
-{"version":3,"file":"mirror.d.ts","sourceRoot":"","sources":["../../src/commands/mirror.ts"],"names":[],"mappings":"AAGA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAapC,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,SAAS,CAiBjG;AAED,wBAAgB,qBAAqB,CAAC,OAAO,EAAE,OAAO,GAAG,IAAI,CAmC5D"}

package/dist/commands/mirror.js

@@ -1,63 +0,0 @@
-import { realpathSync } from "node:fs";
-import path from "node:path";
-import process from "node:process";
-import { createNodeCliFs } from "#lib/infra/node-io";
-import { normalizePath, runMirrorSync } from "#lib/mirror";
-import { findRepoRoot } from "#lib/repo-root";
-function tryRealpath(entryPath) {
-    try {
-        return realpathSync.native(entryPath);
-    }
-    catch {
-        return path.resolve(entryPath);
-    }
-}
-export function packageArgToRelative(rootDir, arg) {
-    if (!arg)
-        return undefined;
-    const rootReal = tryRealpath(path.resolve(rootDir));
-    const cwdReal = tryRealpath(process.cwd());
-    const resolved = path.isAbsolute(arg) ? path.resolve(arg) : path.resolve(cwdReal, arg);
-    const targetReal = tryRealpath(resolved);
-    const rel = path.relative(rootReal, targetReal);
-    const normalized = normalizePath(rel);
-    if (normalized.startsWith("..") ||
-        path.isAbsolute(normalized) ||
-        normalized === "" ||
-        normalized === ".") {
-        throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
-    }
-    return normalized;
-}
-export function registerMirrorCommand(program) {
-    const mirror = program
-        .command("mirror")
-        .description("Keep package manifests aligned with what you ship");
-    mirror
-        .command("sync")
-        .description("Write package.json exports from dist/ for workspace packages")
-        .argument("[package]", "Optional package path relative to repo root (e.g. packages/ui)")
-        .option("-v, --verbose", "Print extra diagnostics", false)
-        .action(async function (pkg, options) {
-        const globals = this.optsWithGlobals();
-        const fs = createNodeCliFs();
-        const rootDir = findRepoRoot(fs);
-        let packageFilter;
-        try {
-            packageFilter = packageArgToRelative(rootDir, pkg);
-        }
-        catch (e) {
-            this.error(e instanceof Error ? e.message : String(e));
-            return;
-        }
-        const exitCode = await runMirrorSync({
-            rootDir,
-            verbose: options.verbose,
-            /** Commander sets `color: false` when `--no-color` is passed (default `color: true`). */
-            noColor: globals.color === false,
-            packageFilter,
-            fs,
-        });
-        process.exitCode = exitCode;
-    });
-}

package/dist/lib/arrange/analyze.d.ts

@@ -1,4 +0,0 @@
-import type { CliFs } from "#lib/infra/fs-contract";
-import type { AnalyzeReport } from "#lib/arrange/types";
-export declare function analyzeDirectory(target: string, fs: CliFs): AnalyzeReport;
-//# sourceMappingURL=analyze.d.ts.map

package/dist/lib/arrange/analyze.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"analyze.d.ts","sourceRoot":"","sources":["../../../src/lib/arrange/analyze.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,wBAAwB,CAAC;AAEpD,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,oBAAoB,CAAC;AA8FxD,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,GAAG,aAAa,CAsCzE"}

package/dist/lib/arrange/analyze.js

@@ -1,105 +0,0 @@
-import ts from "typescript";
-import { LONG_STRING_TOKEN_THRESHOLD } from "#lib/arrange/constants";
-import { tokenizeClassString } from "#lib/arrange/tokenizer";
-import { forEachStringLiteralInClassExpression } from "#lib/arrange/ast/collectors-cn";
-import { jsxClassNameStaticLiteral } from "#lib/arrange/ast/collectors-jsx";
-import { collectCnCallsInsideTv, traverseTvObject } from "#lib/arrange/ast/collectors-tv";
-import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf } from "#lib/arrange/ast/utils";
-import { walkTsxFiles } from "#lib/arrange/walk";
-function analyzeCnCall(sf, call, report) {
-    for (const arg of call.arguments) {
-        forEachStringLiteralInClassExpression(arg, (lit) => {
-            const text = lit.text;
-            const tokenCount = tokenizeClassString(text).length;
-            if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
-                report.longCnStringLiterals.push({
-                    file: sf.fileName,
-                    line: lineOf(sf, lit),
-                    tokenCount,
-                    preview: text.length > 72 ? `${text.slice(0, 72)}…` : text,
-                });
-            }
-        });
-    }
-}
-function visitCallExpressionForArrangeAnalyze(node, sf, sourceText, knownBindings, report) {
-    if (isCnOrTvIdentifier(node.expression, "cn", knownBindings)) {
-        report.cnCallExpressions++;
-        analyzeCnCall(sf, node, report);
-        return;
-    }
-    if (!isCnOrTvIdentifier(node.expression, "tv", knownBindings))
-        return;
-    report.tvCallExpressions++;
-    const arg0 = node.arguments[0];
-    if (!arg0 || !ts.isObjectLiteralExpression(arg0))
-        return;
-    for (const nestedCn of collectCnCallsInsideTv(sf, arg0, knownBindings, 0)) {
-        const src = sourceText.slice(nestedCn.getStart(sf), nestedCn.getEnd());
-        const preview = src.length > 72 ? `${src.slice(0, 72)}…` : src;
-        report.cnInsideTvCalls.push({
-            file: sf.fileName,
-            line: lineOf(sf, nestedCn),
-            argCount: nestedCn.arguments.length,
-            preview,
-        });
-    }
-    traverseTvObject(sf, arg0, (strNode) => {
-        const text = strNode.text;
-        const tokenCount = tokenizeClassString(text).length;
-        if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
-            report.longTvStringLiterals.push({
-                file: sf.fileName,
-                line: lineOf(sf, strNode),
-                tokenCount,
-                preview: text.length > 72 ? `${text.slice(0, 72)}…` : text,
-            });
-        }
-    }, 0, knownBindings);
-}
-function visitJsxAttributeForArrangeAnalyze(node, sf, filePath, report) {
-    if (!filePath.endsWith(".tsx"))
-        return;
-    const parsed = jsxClassNameStaticLiteral(node);
-    if (!parsed)
-        return;
-    const text = parsed.lit.text;
-    const tokenCount = tokenizeClassString(text).length;
-    if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
-        report.longJsxClassNameLiterals.push({
-            file: sf.fileName,
-            line: lineOf(sf, parsed.lit),
-            tokenCount,
-            preview: text.length > 72 ? `${text.slice(0, 72)}…` : text,
-        });
-    }
-}
-export function analyzeDirectory(target, fs) {
-    const report = {
-        files: 0,
-        cnCallExpressions: 0,
-        tvCallExpressions: 0,
-        cnInsideTvCalls: [],
-        longCnStringLiterals: [],
-        longTvStringLiterals: [],
-        longJsxClassNameLiterals: [],
-    };
-    const files = fs.statSync(target).isDirectory() ? walkTsxFiles(target, fs) : [target];
-    for (const filePath of files) {
-        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);
-        report.files++;
-        const knownBindings = buildKnownCnTvBindings(sf);
-        const visit = (node) => {
-            if (ts.isCallExpression(node)) {
-                visitCallExpressionForArrangeAnalyze(node, sf, sourceText, knownBindings, report);
-            }
-            if (ts.isJsxAttribute(node)) {
-                visitJsxAttributeForArrangeAnalyze(node, sf, filePath, report);
-            }
-            ts.forEachChild(node, visit);
-        };
-        visit(sf);
-    }
-    return report;
-}