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

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

@@ -0,0 +1,200 @@
+import { globSync } from "node:fs";
+import path from "node:path";
+import picomatch from "picomatch";
+import { parse as parseYaml } from "yaml";
+import { z } from "zod";
+import { messageFromCaughtUnknown } from "#lib/infra/caught-unknown-message";
+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 = parseYaml(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 = new Set();
+    const globOptions = {
+        cwd: rootDir,
+        posix: true,
+        ...(path.sep === "\\" ? { windowsPathsNoEscape: true } : {}),
+    };
+    for (const pattern of includePatterns) {
+        const packageJsonGlob = workspacePatternToPackageJsonGlob(pattern);
+        const matches = globSync(packageJsonGlob, 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,
+    };
+}
+export 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));
+}

package/dist/lib/tag/infra/typescript-tree-walk.adapter.d.ts

@@ -0,0 +1,3 @@
+import type { TypeScriptTreeWalkPort } from "#lib/tag/application/ports/typescript-tree-walk.port";
+export declare const tagTypeScriptTreeWalkAdapter: TypeScriptTreeWalkPort;
+//# sourceMappingURL=typescript-tree-walk.adapter.d.ts.map

package/dist/lib/tag/infra/typescript-tree-walk.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"typescript-tree-walk.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/infra/typescript-tree-walk.adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,sDAAsD,CAAC;AAEnG,eAAO,MAAM,4BAA4B,EAAE,sBAE1C,CAAC"}

package/dist/lib/tag/infra/typescript-tree-walk.adapter.js

@@ -0,0 +1,4 @@
+import { walkTsxFiles } from "#lib/shared/source-code/infra/tsx-file-walk";
+export const tagTypeScriptTreeWalkAdapter = {
+    walkTsxFiles,
+};

package/dist/lib/tag/presentation/colors.d.ts

@@ -0,0 +1,8 @@
+export declare const TAG_COLORS: {
+    readonly RESET: "\u001B[0m";
+    readonly RED: "\u001B[31m";
+    readonly GREEN: "\u001B[32m";
+    readonly YELLOW: "\u001B[33m";
+};
+export declare function withTagColor(line: string, colorCode: string): string;
+//# sourceMappingURL=colors.d.ts.map

package/dist/lib/tag/presentation/colors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colors.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/colors.ts"],"names":[],"mappings":"AAAA,eAAO,MAAM,UAAU;aACrB,KAAK,EAAE,WAAS;aAChB,GAAG,EAAE,YAAU;aACf,KAAK,EAAE,YAAU;aACjB,MAAM,EAAE,YAAU;CACV,CAAC;AAEX,wBAAgB,YAAY,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,EAAE,MAAM,GAAG,MAAM,CAEpE"}

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

@@ -0,0 +1,9 @@
+export const TAG_COLORS = {
+    RESET: "\x1b[0m",
+    RED: "\x1b[31m",
+    GREEN: "\x1b[32m",
+    YELLOW: "\x1b[33m",
+};
+export function withTagColor(line, colorCode) {
+    return `${colorCode}${line}${TAG_COLORS.RESET}`;
+}

package/dist/lib/tag/presentation/tag-presenter.d.ts

@@ -0,0 +1,20 @@
+import type { CliLogger } from "#lib/core/application/ports/cli-io.port";
+import type { TagProgressListener, TagResolvedTarget, TagSyncResult, TagTargetExecutionResult } from "#lib/tag/domain/types";
+export type TagProgressEvent = {
+    type: "target-started";
+    target: TagResolvedTarget;
+} | {
+    type: "target-completed";
+    target: TagResolvedTarget;
+    result: TagTargetExecutionResult;
+};
+export declare function formatProgress(event: TagProgressEvent): string;
+export declare function formatTargetTable(targets: TagResolvedTarget[], rootDir: string): string;
+export declare function formatWarningsAndErrors(result: TagSyncResult): string | null;
+export declare function formatSummary(result: TagSyncResult): string;
+/**
+ * Prints tag sync output and returns a process exit code (0 success, 1 when empty targets or hook/run errors).
+ */
+export declare function presentTagSyncCliResult(logger: CliLogger, tagResult: TagSyncResult, rootDir: string): number;
+export declare function createTagProgressListener(onProgressLine: (line: string) => void): TagProgressListener;
+//# sourceMappingURL=tag-presenter.d.ts.map

package/dist/lib/tag/presentation/tag-presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tag-presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/tag/presentation/tag-presenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,KAAK,EACV,mBAAmB,EACnB,iBAAiB,EACjB,aAAa,EACb,wBAAwB,EACzB,MAAM,uBAAuB,CAAC;AAG/B,MAAM,MAAM,gBAAgB,GACxB;IAAE,IAAI,EAAE,gBAAgB,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAA;CAAE,GACrD;IAAE,IAAI,EAAE,kBAAkB,CAAC;IAAC,MAAM,EAAE,iBAAiB,CAAC;IAAC,MAAM,EAAE,wBAAwB,CAAA;CAAE,CAAC;AAmB9F,wBAAgB,cAAc,CAAC,KAAK,EAAE,gBAAgB,GAAG,MAAM,CAM9D;AAED,wBAAgB,iBAAiB,CAAC,OAAO,EAAE,iBAAiB,EAAE,EAAE,OAAO,EAAE,MAAM,GAAG,MAAM,CAyBvF;AAED,wBAAgB,uBAAuB,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,GAAG,IAAI,CAU5E;AAED,wBAAgB,aAAa,CAAC,MAAM,EAAE,aAAa,GAAG,MAAM,CAqB3D;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,SAAS,EAAE,aAAa,EACxB,OAAO,EAAE,MAAM,GACd,MAAM,CAiBR;AAED,wBAAgB,yBAAyB,CACvC,cAAc,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,IAAI,GACrC,mBAAmB,CASrB"}

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

@@ -0,0 +1,92 @@
+import { TAG_COLORS, withTagColor } from "#lib/tag/presentation/colors";
+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;
+}
+export 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)`;
+}
+export function formatTargetTable(targets, rootDir) {
+    const packageColumnWidth = Math.max("package".length, ...targets.map((target) => (target.packageName ?? "-").length));
+    const pathColumnWidth = Math.max("path".length, ...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("source".length)}`);
+    for (const target of targets) {
+        lines.push(`  ${(target.packageName ?? "-").padEnd(packageColumnWidth)}   ${target.rootRelativeTargetPath.padEnd(pathColumnWidth)}   ${target.source}`);
+    }
+    return lines.join("\n");
+}
+export 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");
+}
+export 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 hasError = result.targetResults.some((targetResult) => targetResult.runError !== null) ||
+        result.hookError !== null;
+    const summaryColor = hasError ? 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");
+}
+/**
+ * Prints tag sync output and returns a process exit code (0 success, 1 when empty targets or hook/run errors).
+ */
+export 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));
+    const hasRunErrors = tagResult.targetResults.some((targetResult) => targetResult.runError !== null);
+    return hasRunErrors || tagResult.hookError ? 1 : 0;
+}
+export function createTagProgressListener(onProgressLine) {
+    return {
+        onTargetStarted: (target) => {
+            onProgressLine(formatProgress({ type: "target-started", target }));
+        },
+        onTargetCompleted: (target, result) => {
+            onProgressLine(formatProgress({ type: "target-completed", target, result }));
+        },
+    };
+}

package/dist/program.d.ts

@@ -0,0 +1,4 @@
+import { Command } from "commander";
+export declare function createProgram(): Command;
+export declare function runCli(argv: string[]): Promise<number>;
+//# sourceMappingURL=program.d.ts.map

package/dist/program.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"program.d.ts","sourceRoot":"","sources":["../src/program.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,OAAO,EAAE,MAAM,WAAW,CAAC;AAiBpC,wBAAgB,aAAa,IAAI,OAAO,CAevC;AAED,wBAAsB,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,GAAG,OAAO,CAAC,MAAM,CAAC,CAK5D"}

package/dist/program.js

@@ -0,0 +1,40 @@
+import { readFileSync } from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import { Command } from "commander";
+import { registerArrangeCommand } from "#commands/arrange";
+import { registerMirrorCommand } from "#commands/mirror";
+import { registerTagCommand } from "#commands/tag";
+function readVersion() {
+    try {
+        const dir = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.join(dir, "..", "package.json");
+        const raw = readFileSync(pkgPath, "utf-8");
+        const pkgVersion = JSON.parse(raw).version;
+        return typeof pkgVersion === "string" && pkgVersion.length > 0 ? pkgVersion : "unknown";
+    }
+    catch {
+        return "unknown";
+    }
+}
+export 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;
+}
+export async function runCli(argv) {
+    const program = createProgram();
+    await program.parseAsync(argv, { from: "node" });
+    const code = process.exitCode ?? 0;
+    return typeof code === "number" ? code : Number(code) || 0;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@codefast/cli",
-  "version": "0.3.13-canary.1",
+  "version": "0.3.13-canary.2",
   "description": "Developer CLI for the Codefast monorepo (mirror, arrange)",
   "keywords": [
     "cli",
@@ -22,7 +22,7 @@
     "directory": "packages/cli"
   },
   "bin": {
-    "codefast": "./dist/bin.mjs"
+    "codefast": "./dist/bin.js"
   },
   "files": [
     "dist",
@@ -33,6 +33,9 @@
   "type": "module",
   "imports": {
     "#*": [
+      "./dist/*.js",
+      "./dist/*/index.js",
+      "./dist/*",
       "./src/*",
       "./src/*.ts",
       "./src/*.tsx",
@@ -59,17 +62,17 @@
     "@types/picomatch": "^4.0.3",
     "@typescript/native-preview": "7.0.0-dev.20260411.1",
     "jest": "^30.3.0",
-    "tsdown": "^0.21.8",
-    "@codefast/typescript-config": "0.3.13-canary.1"
+    "@codefast/typescript-config": "0.3.13-canary.2"
   },
   "engines": {
     "node": ">=22.0.0"
   },
   "scripts": {
-    "build": "tsdown",
+    "build": "rm -rf dist && tsgo -p tsconfig.build.json",
     "check-types": "tsgo --noEmit",
     "clean": "rm -rf dist",
     "test": "jest",
+    "test:architecture": "jest src/__tests__/architecture.test.ts",
     "test:coverage": "jest --coverage",
     "test:coverage:ci": "jest --coverage --ci",
     "test:watch": "jest --watch"

package/dist/commands/arrange.mjs

@@ -1,107 +0,0 @@
-import { messageFromCaughtUnknown } from "../lib/infra/caught-unknown-message.mjs";
-import { loadConfig } from "../lib/config/infra/loader.mjs";
-import "../lib/config/index.mjs";
-import { printConfigSchemaWarnings } from "../lib/infra/config-reporter.mjs";
-import { DEFAULT_ARRANGE_TARGET } from "../lib/arrange/domain/constants.mjs";
-import { analyzeDirectory } from "../lib/arrange/application/analyze.mjs";
-import { printAnalyzeReport } from "../lib/arrange/presentation/report.mjs";
-import { suggestCnGroups, summarizeGroupBucketLabels } from "../lib/arrange/domain/grouping.mjs";
-import { formatArray, formatCnCall } from "../lib/arrange/presentation/formatters.mjs";
-import { runArrangeSync } from "../lib/arrange/application/run-target.mjs";
-import { createNodeCliFs, createNodeCliLogger } from "../lib/infra/node-io.mjs";
-import "../lib/arrange/index.mjs";
-import { findRepoRoot } from "../lib/infra/workspace/repo-root.mjs";
-import process from "node:process";
-import path from "node:path";
-import { Option } from "commander";
-//#region src/commands/arrange.ts
-/** 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;
-}
-async function loadArrangeCommandConfig(fs, logger, rootDir) {
-	try {
-		const { config, warnings } = await loadConfig(fs, rootDir);
-		printConfigSchemaWarnings(logger, warnings);
-		return { arrangeConfig: config.arrange ?? {} };
-	} catch (caughtConfigError) {
-		logger.err(messageFromCaughtUnknown(caughtConfigError));
-		process.exitCode = 1;
-		return;
-	}
-}
-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(async (target) => {
-		const fs = createNodeCliFs();
-		const logger = createNodeCliLogger();
-		const resolved = target ? path.resolve(target) : defaultTargetPath();
-		if (!checkTargetExists(resolved, fs, logger)) return;
-		if (!await loadArrangeCommandConfig(fs, logger, findRepoRoot(fs))) 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(async (target, opts) => {
-		const fs = createNodeCliFs();
-		const logger = createNodeCliLogger();
-		const resolved = target ? path.resolve(target) : defaultTargetPath();
-		if (!checkTargetExists(resolved, fs, logger)) return;
-		const rootDir = findRepoRoot(fs);
-		const loaded = await loadArrangeCommandConfig(fs, logger, rootDir);
-		if (!loaded) return;
-		process.exitCode = await runArrangeSync({
-			rootDir,
-			config: loaded.arrangeConfig,
-			targetPath: 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(async (target, opts) => {
-		const fs = createNodeCliFs();
-		const logger = createNodeCliLogger();
-		const resolved = target ? path.resolve(target) : defaultTargetPath();
-		if (!checkTargetExists(resolved, fs, logger)) return;
-		const rootDir = findRepoRoot(fs);
-		const loaded = await loadArrangeCommandConfig(fs, logger, rootDir);
-		if (!loaded) return;
-		process.exitCode = await runArrangeSync({
-			rootDir,
-			config: loaded.arrangeConfig,
-			targetPath: 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`);
-	});
-}
-//#endregion
-export { registerArrangeCommand };

package/dist/commands/mirror.mjs

@@ -1,66 +0,0 @@
-import { messageFromCaughtUnknown } from "../lib/infra/caught-unknown-message.mjs";
-import { loadConfig } from "../lib/config/infra/loader.mjs";
-import "../lib/config/index.mjs";
-import { printConfigSchemaWarnings } from "../lib/infra/config-reporter.mjs";
-import { createNodeCliFs, createNodeCliLogger } from "../lib/infra/node-io.mjs";
-import { findRepoRoot } from "../lib/infra/workspace/repo-root.mjs";
-import { runMirrorSync } from "../lib/mirror/application/sync.mjs";
-import "../lib/mirror/index.mjs";
-import process from "node:process";
-import { realpathSync } from "node:fs";
-import path from "node:path";
-//#region src/commands/mirror.ts
-function tryRealpath(entryPath) {
-	try {
-		return realpathSync.native(entryPath);
-	} catch {
-		return path.resolve(entryPath);
-	}
-}
-function normalizePath(relPath) {
-	return relPath.split(path.sep).join("/").replace(/\\/g, "/");
-}
-function packageArgToRelative(rootDir, arg) {
-	if (!arg) return;
-	const rootReal = tryRealpath(path.resolve(rootDir));
-	const cwdReal = tryRealpath(process.cwd());
-	const targetReal = tryRealpath(path.isAbsolute(arg) ? path.resolve(arg) : path.resolve(cwdReal, arg));
-	const normalized = normalizePath(path.relative(rootReal, targetReal));
-	if (normalized.startsWith("..") || path.isAbsolute(normalized) || normalized === "" || normalized === ".") throw new Error(`Package path must be a subdirectory under monorepo root: ${rootDir}`);
-	return normalized;
-}
-function registerMirrorCommand(program) {
-	program.command("mirror").description("Keep package manifests aligned with what you ship").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 logger = createNodeCliLogger();
-		const rootDir = findRepoRoot(fs);
-		let packageFilter;
-		try {
-			packageFilter = packageArgToRelative(rootDir, pkg);
-		} catch (caughtPathError) {
-			this.error(messageFromCaughtUnknown(caughtPathError));
-			return;
-		}
-		let mirrorConfig = {};
-		try {
-			const { config, warnings } = await loadConfig(fs, rootDir);
-			printConfigSchemaWarnings(logger, warnings);
-			mirrorConfig = config.mirror ?? {};
-		} catch (caughtConfigError) {
-			this.error(messageFromCaughtUnknown(caughtConfigError));
-			return;
-		}
-		process.exitCode = await runMirrorSync({
-			rootDir,
-			config: mirrorConfig,
-			verbose: options.verbose,
-			noColor: globals.color === false,
-			packageFilter,
-			fs,
-			logger
-		});
-	});
-}
-//#endregion
-export { packageArgToRelative, registerMirrorCommand };