@codefast/cli 0.3.12 → 0.3.13-canary.1

package/dist/lib/arrange/domain/tokenizer.mjs

@@ -0,0 +1,216 @@
+import { COMPATIBLE_BUCKET_SETS, RESPONSIVE_PREFIX, STATE_PREFIXES } from "./constants.mjs";
+//#region src/lib/arrange/domain/tokenizer.ts
+/**
+* Variant stems not covered by a single entry in STATE_PREFIXES (compound `has-*`,
+* numbered `nth-*`, media features, v4 `in-[…]`, child selectors `*` / `**`, …).
+* When these are missed, `isStateToken` is false and the variant is stripped — the
+* utility is then bucketed as if it were unconditional, which breaks preview grouping.
+*/
+function isCompoundOrMediaVariantPrefix(prefix) {
+	if (prefix === "*" || prefix === "**") return true;
+	if (prefix === "inert") return true;
+	if (prefix.startsWith("has-")) return true;
+	if (prefix.startsWith("in-[")) return true;
+	if (/^nth(?:-last)?(?:-of-type)?(?:-\d+|-\[)/.test(prefix) || /^nth-of-type-\d+$/.test(prefix) || /^nth-last-of-type-\d+$/.test(prefix)) return true;
+	if (/^(?:user-valid|user-invalid|contrast-more|contrast-less|forced-colors|inverted-colors)$/.test(prefix)) return true;
+	if (/^(?:any-)?pointer-(?:fine|coarse|none)$/.test(prefix)) return true;
+	if (/^(?:portrait|landscape|noscript)$/.test(prefix)) return true;
+	return false;
+}
+function tokenizeClassString(classString) {
+	return classString.trim().split(/\s+/).filter(Boolean);
+}
+/**
+* Index of the first `:` that separates a Tailwind variant segment from the rest.
+* Colons inside `[...]` (at positive bracket depth) are ignored so selectors like
+* `[&_a:hover]:text-red-500` split as `[&_a:hover]:` + `text-red-500`.
+*/
+function indexOfFirstVariantColon(text) {
+	let depth = 0;
+	for (let i = 0; i < text.length; i++) {
+		const ch = text[i];
+		if (ch === "[") depth++;
+		else if (ch === "]") depth = Math.max(0, depth - 1);
+		else if (ch === ":" && depth === 0) return i;
+	}
+	return -1;
+}
+function stripVariants(token) {
+	let withoutVariants = token;
+	const MAX_PASSES = 12;
+	for (let i = 0; i < MAX_PASSES; i++) {
+		const colonIdx = indexOfFirstVariantColon(withoutVariants);
+		if (colonIdx === -1) break;
+		withoutVariants = withoutVariants.slice(colonIdx + 1);
+	}
+	return withoutVariants;
+}
+/** Outermost variant segment: first `:` at bracket depth 0 → text before it. */
+function firstLeadingVariantPrefix(token) {
+	const colonIdx = indexOfFirstVariantColon(token);
+	if (colonIdx === -1) return;
+	return token.slice(0, colonIdx);
+}
+function isSelectorVariantToken(token) {
+	const prefix = firstLeadingVariantPrefix(token);
+	if (prefix === void 0) return false;
+	if (prefix === "*" || prefix === "**") return true;
+	if (prefix.startsWith("has-")) return true;
+	if (prefix.startsWith("in-[")) return true;
+	if (prefix.startsWith("group-[")) return true;
+	if (prefix.startsWith("peer-[")) return true;
+	if (prefix.startsWith("not-[")) return true;
+	return false;
+}
+function isStateToken(token) {
+	const prefix = firstLeadingVariantPrefix(token);
+	if (prefix === void 0) return false;
+	if (RESPONSIVE_PREFIX.test(token)) return true;
+	if (STATE_PREFIXES.has(prefix)) return true;
+	if (prefix.startsWith("data-[")) return true;
+	if (prefix.startsWith("aria-[")) return true;
+	if (prefix.startsWith("supports-[")) return true;
+	if (prefix.startsWith("in-data-")) return true;
+	if (/^data-(?!\[)/.test(prefix)) return true;
+	if (/^aria-/.test(prefix)) return true;
+	if (/^(group|peer)-/.test(prefix)) return true;
+	if (/^not-/.test(prefix)) return true;
+	if (isCompoundOrMediaVariantPrefix(prefix)) return true;
+	if (prefix.startsWith("[") && prefix.endsWith("]")) return true;
+	return false;
+}
+/**
+* Secondary sort inside the **composite** bucket: opacity / blend / isolation →
+* 3D context → 3D transforms → 2D transforms → filters → will-change.
+*/
+function compositeSecondaryOrder(bareUtility) {
+	const b = bareUtility;
+	if (/^opacity(?:-|$)/.test(b) || /^mix-blend-/.test(b) || /^isolation(?:-|$)/.test(b) || b === "isolate") return 0;
+	if (b === "transform-3d" || /^perspective(?:-|$)/.test(b)) return 10;
+	if (/^rotate-[xyz](?:-|$)/.test(b) || /^translate-z(?:-|$)/.test(b) || /^scale-z(?:-|$)/.test(b)) return 20;
+	if (/^translate(?:-|$)/.test(b) || /^scale(?:-|$)/.test(b) || /^rotate(?:-|$)/.test(b) || /^skew(?:-|$)/.test(b)) return 30;
+	if (/^transform(?:-(?:gpu|cpu|none))?$/.test(b)) return 35;
+	if (/^blur(?:-|$)/.test(b) || /^backdrop-/.test(b) || /^filter(?:-|$)/.test(b) || /^brightness-/.test(b) || /^contrast-/.test(b) || /^grayscale(?:-|$)/.test(b) || /^hue-rotate-/.test(b) || /^invert(?:-|$)/.test(b) || /^saturate-/.test(b) || /^sepia(?:-|$)/.test(b)) return 40;
+	if (/^will-change/.test(b)) return 50;
+	return 99;
+}
+/** Classify a **bare** utility (no `hover:` / `md:` / … prefixes). */
+function classifyBareUtility(bareUtility) {
+	const b = bareUtility;
+	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(b)) return "existence";
+	if (/^(?:hidden|contents|sr-only|not-sr-only|list-item|flow-root)$/.test(b) || /^(?:block|inline-block|inline)$/.test(b)) return "existence";
+	if (/^table(?:$|-)/.test(b)) return "existence";
+	if (/^contain-/.test(b)) return "existence";
+	if (/^(?:group|peer)(?:\/[a-z][a-z0-9-]*)?$/.test(b)) return "existence";
+	if (/^(?:static|relative|absolute|fixed|sticky)$/.test(b)) return "position";
+	if (/^-?(?:inset|top|right|bottom|left|start|end)(?:-|\/|$)/.test(b) || /^-?(?:inset-x|inset-y|inset-s|inset-e)-/.test(b)) return "position";
+	if (/^-?z-/.test(b) || b === "z-auto") return "position";
+	if (/^(?:flex|inline-flex|grid|inline-grid|subgrid|masonry)(?:$|-)/.test(b) || /^(?:items|justify|justify-items|justify-self|content|self|place|place-content|place-items|place-self)-/.test(b) || /^-?(?:gap|space-[xy]|col-|row-|grid-|auto-cols|auto-rows|order-|order$)/.test(b) || /^-?(?:auto-flow|grid-flow)-/.test(b) || /^(?:columns-|break-after|break-before|break-inside)-/.test(b) || /^(?:float|clear)-/.test(b) || /^(?:wrap-|flex-wrap|flex-nowrap|flex-row|flex-col|flex-auto|flex-initial|flex-none|flex-1|flex-\[)/.test(b) || /^container$/.test(b)) return "layout";
+	if (/^-?(?:w|h|min-w|max-w|min-h|max-h|size|aspect|shrink|grow|basis)-/.test(b) || /^(?:shrink|grow)(?:$|-)/.test(b) || /^-?overflow-/.test(b) || /^-?object-/.test(b)) return "sizing";
+	if (/^-?(?:p|px|py|pt|pb|pl|pr|ps|pe|m|mx|my|mt|mb|ml|mr|ms|me)-/.test(b)) return "spacing";
+	if (/^-?(?:rounded|border|ring|divide|inset-ring)(?:-|\/|$)/.test(b) || /^(?:rounded|border|ring|divide|inset-ring)$/.test(b) || /^ring-offset-/.test(b)) return "shape";
+	if (/^-?bg-/.test(b) || /^(?:from|via|to)(?:-|\/|$)/.test(b) || /^bg-(?:linear|radial|conic)-/.test(b) || /^-?mask-/.test(b) || /^-?(?:fill|stroke)-/.test(b)) return "background";
+	if (/^-?(?:shadow|inset-shadow|drop-shadow|text-shadow)(?:-|\/|$)/.test(b) || /^(?:shadow|inset-shadow)$/.test(b) || /^-?outline(?:-|\/|$)/.test(b) || /^outline$/.test(b)) return "shadow";
+	if (/^-?(?:font|leading|tracking|list|indent|align|decoration|underline-offset|text-wrap|text-balance|text-pretty)-/.test(b) || /^-?(?:text-(?!shadow))/.test(b) || /^-?(?:whitespace|break|line-clamp|hyphens)-/.test(b) || /^(?:antialiased|subpixel-antialiased|italic|not-italic|overline|line-through|underline|no-underline|uppercase|lowercase|capitalize|normal-case|truncate|text-wrap|text-balance|text-pretty)$/.test(b) || /^text-wrap-/.test(b) || /^tabular-nums$|^slashed-zero$|^lining-nums$|^oldstyle-nums$|^proportional-nums$/.test(b)) return "typography";
+	if (/^opacity(?:-|$)/.test(b) || /^mix-blend-/.test(b) || /^isolation(?:-|$)/.test(b) || b === "isolate" || /^transform(?:-(?:gpu|cpu|none))?$/.test(b) || /^-?(?:translate|scale|rotate|skew)-/.test(b) || /^perspective(?:-|$)/.test(b) || b === "transform-3d" || /^blur(?:-|$)/.test(b) || /^backdrop-/.test(b) || /^filter(?:-|$)/.test(b) || /^brightness-/.test(b) || /^contrast-/.test(b) || /^grayscale(?:-|$)/.test(b) || /^hue-rotate-/.test(b) || /^invert(?:-|$)/.test(b) || /^saturate-/.test(b) || /^sepia(?:-|$)/.test(b) || /^will-change/.test(b)) return "composite";
+	if (/^(?:transition|duration|ease|delay|animate)(?:-|$)/.test(b) || /^ease-/.test(b)) return "motion";
+	if (/^(?:cursor|pointer-events|select|touch|scroll|scroll-m|scroll-p|overscroll|snap|resize|field-sizing|appearance|scheme|color-scheme|accent|caret)(?:-|$)/.test(b) || /^(?:cursor|select|resize)$/.test(b) || /^scroll-behavior/.test(b) || /^scroll-snap/.test(b) || /^touch-action/.test(b) || b === "inert") return "behavior";
+	return "other";
+}
+/**
+* Arbitrary **parent** selectors (`[&…]`, `[&>a]:…`, slot forms with `&` inside the bracket)
+* scope utilities to descendants — bucket as `selector` so they chunk apart from base layout/typography
+* and are labeled distinctly from interactive `state` variants (`hover:`, `data-[…]:`, …).
+* Pure arbitrary **properties** (`[--x]:`, `[color:red]`) have no `&` in the leading `[…]` segment.
+*/
+function isArbitraryParentSelectorStateToken(token) {
+	if (/^\[&/.test(token)) return true;
+	if (!token.startsWith("[")) return false;
+	const colonIdx = indexOfFirstVariantColon(token);
+	if (colonIdx === -1 || colonIdx === 0 || token[colonIdx - 1] !== "]") return false;
+	return token.slice(0, colonIdx).includes("&");
+}
+function classifyToken(token) {
+	if (isArbitraryParentSelectorStateToken(token)) return "selector";
+	if (isSelectorVariantToken(token)) return "selector";
+	if (/^@container(?:\/[a-z][a-z0-9-]*)?$/i.test(token)) return "existence";
+	if (token.startsWith("[")) {
+		const splitIdx = indexOfFirstVariantColon(token);
+		if (splitIdx === -1) return "arbitrary";
+		if (splitIdx === 0 || token[splitIdx - 1] !== "]") return "arbitrary";
+	}
+	if (firstLeadingVariantPrefix(token) === "starting") return "starting";
+	if (isStateToken(token)) return "state";
+	return classifyBareUtility(stripVariants(token));
+}
+/**
+* Stable key for `data-[…]` variants so unrelated selectors stay split, while
+* **branching on the full bracket** (e.g. `data-[vaul-drawer-direction=bottom]`
+* vs `=left`) keeps direction-specific utilities in separate state groups.
+*/
+function dataAttributeStem(token) {
+	const match = token.match(/^data-\[([^\]]*)\]/);
+	return match ? `data-[${match[1]}]` : "data";
+}
+/** Same idea as {@link dataAttributeStem} for `aria-[…]:` variants. */
+function ariaAttributeStem(token) {
+	const match = token.match(/^aria-\[([^\]]*)\]/);
+	return match ? `aria-[${match[1]}]` : "aria";
+}
+/** `in-data-[…]:` — normalize on the full bracket expression like {@link dataAttributeStem}. */
+function inDataAttributeStem(token) {
+	const match = token.match(/^in-data-\[([^\]]*)\]/);
+	return match ? `in-data-[${match[1]}]` : "in-data";
+}
+/**
+* Stable key for splitting adjacent `state` / `starting` tokens in {@link suggestCnGroups}
+* (`selector` uses {@link selectorKey}).
+* Uses the **full variant stack** (every `:` segment outside `[…]`), not only the
+* outermost prefix, so `@md/foo:[&>*]:w-auto` and `@md/foo:has-[…]:mt-px` stay in
+* separate groups while `hover:opacity` still keys as `hover` + `opacity`…
+*
+* `data-[…]` / `aria-[…]` normalize the first segment via {@link dataAttributeStem} /
+* {@link ariaAttributeStem} (full token required for bracket capture).
+*/
+function stateKey(token) {
+	const layers = [];
+	let rest = token;
+	while (rest.length > 0) {
+		const colonIdx = indexOfFirstVariantColon(rest);
+		if (colonIdx === -1) break;
+		layers.push(rest.slice(0, colonIdx));
+		rest = rest.slice(colonIdx + 1);
+	}
+	if (layers.length === 0) return token;
+	if (layers[0].startsWith("data-[")) layers[0] = dataAttributeStem(token);
+	else if (layers[0].startsWith("aria-[")) layers[0] = ariaAttributeStem(token);
+	else if (layers[0].startsWith("in-data-[")) layers[0] = inDataAttributeStem(token);
+	return layers.join("");
+}
+const SELECTOR_KEY_SEP = "";
+/**
+* Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+* Reuses {@link stateKey} layer splitting, then normalizes common shadcn/Radix SVG patterns so
+* `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+*/
+function selectorKey(token) {
+	return stateKey(token).split(SELECTOR_KEY_SEP).map(normalizeSelectorVariantLayer).join(SELECTOR_KEY_SEP);
+}
+function normalizeSelectorVariantLayer(layer) {
+	if (layer === "[&_svg:not([class*='size-'])]") return "[&_svg]";
+	return layer;
+}
+function bucketsCompatible(a, b) {
+	if (a === b) return true;
+	return COMPATIBLE_BUCKET_SETS.some((bucketSet) => bucketSet.has(a) && bucketSet.has(b));
+}
+/** Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs. */
+function bucketsMergeCompatible(a, b) {
+	if (a === "state" && b === "state") return false;
+	if (a === "starting" && b === "starting") return false;
+	if (a === "selector" && b === "selector") return false;
+	if (a === "arbitrary" || b === "arbitrary") return false;
+	return bucketsCompatible(a, b);
+}
+//#endregion
+export { bucketsCompatible, bucketsMergeCompatible, classifyBareUtility, classifyToken, compositeSecondaryOrder, indexOfFirstVariantColon, isArbitraryParentSelectorStateToken, selectorKey, stateKey, stripVariants, tokenizeClassString };

package/dist/lib/arrange/index.mjs

@@ -0,0 +1,15 @@
+import { DEFAULT_ARRANGE_TARGET, LONG_STRING_TOKEN_THRESHOLD, MAX_STRIP_VARIANT_PASSES } from "./domain/constants.mjs";
+import { bucketsCompatible, bucketsMergeCompatible, classifyToken, indexOfFirstVariantColon, selectorKey, stateKey, stripVariants, tokenizeClassString } from "./domain/tokenizer.mjs";
+import { forEachStringLiteralInClassExpression, mergeCnUnconditionalLiteralPoolForTest } from "./domain/ast/collectors-cn.mjs";
+import { KNOWN_CN_TV_MODULES, applyEditsDescending, buildKnownCnTvBindings, indentOfLineContaining, isCnOrTvIdentifier, lineOf, moduleLooksLikeCnTvReexport, unwrapCnInsideTvCallReplacement } from "./domain/ast/ast-helpers.mjs";
+import { DEFAULT_SKIP_DIRS, walkTsxFiles } from "./infra/walk.mjs";
+import { analyzeDirectory } from "./application/analyze.mjs";
+import { printAnalyzeReport } from "./presentation/report.mjs";
+import { areCnTailwindPartitionsEquivalent, capGroups, mergeEaseTimingIntoFollowingAnimatedState, mergeSingletons, suggestCnGroups, summarizeGroupBucketLabels } from "./domain/grouping.mjs";
+import { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue } from "./presentation/formatters.mjs";
+import { cnModuleSpecifierForFile, ensureCnImport } from "./domain/imports.mjs";
+import { groupFile } from "./application/group-file.mjs";
+import { ArrangeError, ArrangeErrorCode } from "./domain/errors.mjs";
+import { runArrangeSync, runOnTarget } from "./application/run-target.mjs";
+import { createNodeCliFs, createNodeCliLogger } from "../infra/node-io.mjs";
+export { ArrangeError, ArrangeErrorCode, DEFAULT_ARRANGE_TARGET, DEFAULT_SKIP_DIRS, KNOWN_CN_TV_MODULES, LONG_STRING_TOKEN_THRESHOLD, MAX_STRIP_VARIANT_PASSES, analyzeDirectory, applyEditsDescending, areCnTailwindPartitionsEquivalent, bucketsCompatible, bucketsMergeCompatible, buildKnownCnTvBindings, capGroups, classifyToken, cnModuleSpecifierForFile, createNodeCliFs, createNodeCliLogger, ensureCnImport, escapeTsStringLiteralContent, forEachStringLiteralInClassExpression, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue, groupFile, indentOfLineContaining, indexOfFirstVariantColon, isCnOrTvIdentifier, lineOf, mergeCnUnconditionalLiteralPoolForTest, mergeEaseTimingIntoFollowingAnimatedState, mergeSingletons, moduleLooksLikeCnTvReexport, printAnalyzeReport, runArrangeSync, runOnTarget, selectorKey, stateKey, stripVariants, suggestCnGroups, summarizeGroupBucketLabels, tokenizeClassString, unwrapCnInsideTvCallReplacement, walkTsxFiles };

package/dist/lib/arrange/infra/walk.mjs

@@ -0,0 +1,33 @@
+import path from "node:path";
+//#region src/lib/arrange/infra/walk.ts
+const DEFAULT_SKIP_DIRS = new Set([
+	"node_modules",
+	"dist",
+	".git",
+	".turbo",
+	".next",
+	".cache",
+	"out",
+	"build",
+	"coverage",
+	".vercel",
+	".output"
+]);
+function walkTsxFiles(rootDirectoryPath, fs) {
+	const result = [];
+	const visit = (entryPath) => {
+		if (fs.statSync(entryPath).isDirectory()) {
+			for (const childName of fs.readdirSync(entryPath)) {
+				if (DEFAULT_SKIP_DIRS.has(childName)) continue;
+				visit(path.join(entryPath, childName));
+			}
+			return;
+		}
+		if (entryPath.endsWith(".d.ts")) return;
+		if (entryPath.endsWith(".tsx") || entryPath.endsWith(".ts")) result.push(entryPath);
+	};
+	visit(rootDirectoryPath);
+	return result;
+}
+//#endregion
+export { DEFAULT_SKIP_DIRS, walkTsxFiles };

package/dist/lib/arrange/presentation/formatters.mjs

@@ -0,0 +1,52 @@
+import { indentOfLineContaining } from "../domain/ast/ast-helpers.mjs";
+//#region src/lib/arrange/presentation/formatters.ts
+function escapeTsStringLiteralContent(group) {
+	return group.replaceAll("\\", "\\\\").replaceAll("\"", "\\\"");
+}
+/**
+* Multiline fragment for use *inside* an existing `cn(...)` — replaces one
+* string argument with several, without producing `cn(cn(...))`.
+*/
+function formatCnArguments(groups, options) {
+	const indent = options?.indent ?? "  ";
+	const commaAfterLast = options?.commaAfterLastGroup ?? options?.trailingClassName ?? false;
+	const lines = [];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const comma = i < groups.length - 1 || commaAfterLast ? "," : "";
+		lines.push(`${indent}"${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	if (options?.trailingClassName) lines.push(`${indent}className,`);
+	return lines.join("\n");
+}
+function formatCnCall(groups, options) {
+	const lines = ["cn("];
+	const commaOnEachStringLine = groups.length > 1 || Boolean(options?.trailingClassName);
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const comma = commaOnEachStringLine ? "," : "";
+		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	if (options?.trailingClassName) lines.push("  className,");
+	lines.push(")");
+	return lines.join("\n");
+}
+function formatArray(groups) {
+	const lines = ["["];
+	for (let i = 0; i < groups.length; i++) {
+		const group = groups[i];
+		const comma = i < groups.length - 1 || groups.length > 1 ? "," : "";
+		lines.push(`  "${escapeTsStringLiteralContent(group)}"${comma}`);
+	}
+	lines.push("]");
+	return lines.join("\n");
+}
+function formatJsxCnAttributeValue(groups, source, valueNodeStart) {
+	const baseIndent = indentOfLineContaining(source, valueNodeStart);
+	return `{cn(\n${formatCnArguments(groups, {
+		indent: `${baseIndent}  `,
+		commaAfterLastGroup: groups.length > 1
+	})}\n${baseIndent})}`;
+}
+//#endregion
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue };

package/dist/lib/arrange/presentation/report.mjs

@@ -0,0 +1,24 @@
+import "../domain/constants.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 };

package/dist/lib/config/domain/schema.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 { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema };

package/dist/lib/config/index.mjs

@@ -0,0 +1,3 @@
+import { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, mirrorConfigSchema } from "./domain/schema.mjs";
+import { loadConfig, resetConfigLoaderCacheForTests } from "./infra/loader.mjs";
+export { codefastArrangeConfigSchema, codefastConfigSchema, codefastTagConfigSchema, hookSchema, loadConfig, mirrorConfigSchema, resetConfigLoaderCacheForTests };

package/dist/lib/config/infra/loader.mjs

@@ -0,0 +1,78 @@
+import { codefastConfigSchema } from "../domain/schema.mjs";
+import process from "node:process";
+import path from "node:path";
+import jiti from "jiti";
+import { ZodError } from "zod";
+//#region src/lib/config/infra/loader.ts
+const CONFIG_JS_PRIORITY = [
+	"codefast.config.mjs",
+	"codefast.config.js",
+	"codefast.config.cjs"
+];
+const CONFIG_JSON = "codefast.config.json";
+const cachedLoads = /* @__PURE__ */ new Map();
+function formatZodError(error, filePath) {
+	const formatted = error.issues.map((issue) => {
+		return `  - ${issue.path.length > 0 ? issue.path.join(".") : "<root>"}: ${issue.message}`;
+	}).join("\n");
+	return `Invalid config schema in ${path.basename(filePath)}:\n${formatted}`;
+}
+function parseLoadedConfig(raw, filePath) {
+	try {
+		return codefastConfigSchema.parse(raw);
+	} catch (caughtError) {
+		if (caughtError instanceof ZodError) throw new Error(formatZodError(caughtError, filePath));
+		throw caughtError;
+	}
+}
+function listConfigCandidates(startDir, fs) {
+	const candidates = [];
+	let current = path.resolve(startDir);
+	while (true) {
+		for (const name of CONFIG_JS_PRIORITY) {
+			const candidate = path.join(current, name);
+			if (fs.existsSync(candidate)) candidates.push(candidate);
+		}
+		const jsonCandidate = path.join(current, CONFIG_JSON);
+		if (fs.existsSync(jsonCandidate)) candidates.push(jsonCandidate);
+		const parent = path.dirname(current);
+		if (parent === current) break;
+		current = parent;
+	}
+	return candidates;
+}
+async function readConfigFromPath(filePath, fs) {
+	if (path.extname(filePath) === ".json") {
+		const content = await fs.readFile(filePath, "utf8");
+		return parseLoadedConfig(JSON.parse(content), filePath);
+	}
+	const moduleConfig = jiti(process.cwd(), {
+		interopDefault: true,
+		moduleCache: false
+	})(filePath);
+	return parseLoadedConfig(typeof moduleConfig === "object" && moduleConfig !== null && "default" in moduleConfig ? moduleConfig.default : moduleConfig, filePath);
+}
+async function loadOnce(fs, startDir) {
+	const warnings = [];
+	const configPaths = listConfigCandidates(startDir, fs);
+	if (configPaths.length === 0) return {
+		config: {},
+		warnings
+	};
+	const configPath = configPaths[0];
+	return {
+		config: await readConfigFromPath(configPath, fs),
+		warnings,
+		configPath
+	};
+}
+async function loadConfig(fs, startDir = process.cwd()) {
+	const cacheKey = path.resolve(startDir);
+	if (!cachedLoads.has(cacheKey)) cachedLoads.set(cacheKey, loadOnce(fs, cacheKey));
+	return cachedLoads.get(cacheKey);
+}
+function resetConfigLoaderCacheForTests() {
+	cachedLoads.clear();
+}
+//#endregion
+export { loadConfig, resetConfigLoaderCacheForTests };

package/dist/lib/infra/caught-unknown-message.mjs

@@ -0,0 +1,20 @@
+//#region src/lib/infra/caught-unknown-message.ts
+/**
+* Stable, user-facing text for values caught as `unknown`.
+* Avoids `String(unknown)` / `[object Object]` and satisfies strict `no-base-to-string`.
+*/
+function messageFromCaughtUnknown(value) {
+	if (value instanceof Error) return value.message;
+	if (typeof value === "string") return value;
+	if (typeof value === "number" || typeof value === "bigint" || typeof value === "boolean") return String(value);
+	if (typeof value === "symbol") return String(value);
+	if (value === null) return "null";
+	if (value === void 0) return "undefined";
+	try {
+		const serialized = JSON.stringify(value);
+		if (typeof serialized === "string") return serialized;
+	} catch {}
+	return "[unserializable non-Error value]";
+}
+//#endregion
+export { messageFromCaughtUnknown };

package/dist/lib/infra/config-reporter.mjs

@@ -0,0 +1,10 @@
+//#region src/lib/infra/config-reporter.ts
+const YELLOW = "\x1B[33m";
+const RESET = "\x1B[0m";
+/** User-visible lines for non-fatal issues returned with a successfully parsed config. */
+function printConfigSchemaWarnings(logger, warnings) {
+	const { out } = logger;
+	for (const warningMessage of warnings) out(`${YELLOW}\u26A0\uFE0F ${warningMessage}${RESET}`);
+}
+//#endregion
+export { printConfigSchemaWarnings };

package/dist/lib/infra/node-io.mjs

@@ -0,0 +1,30 @@
+import process from "node:process";
+import fsSync from "node:fs";
+import fsPromises from "node:fs/promises";
+//#region src/lib/infra/node-io.ts
+function createNodeCliFs() {
+	return {
+		existsSync: fsSync.existsSync,
+		statSync: fsSync.statSync,
+		readFileSync: fsSync.readFileSync,
+		writeFileSync: fsSync.writeFileSync,
+		readdirSync: fsSync.readdirSync,
+		readFile: (p, enc) => fsPromises.readFile(p, enc),
+		writeFile: (p, data, enc) => fsPromises.writeFile(p, data, enc),
+		readdir: (p, opts) => fsPromises.readdir(p, opts),
+		rename: (oldPath, newPath) => fsPromises.rename(oldPath, newPath),
+		unlink: (p) => fsPromises.unlink(p)
+	};
+}
+function createNodeCliLogger() {
+	return {
+		out: (line) => {
+			process.stdout.write(`${line}\n`);
+		},
+		err: (line) => {
+			process.stderr.write(`${line}\n`);
+		}
+	};
+}
+//#endregion
+export { createNodeCliFs, createNodeCliLogger };

package/dist/lib/infra/workspace/repo-root.mjs

@@ -0,0 +1,22 @@
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+//#region src/lib/infra/workspace/repo-root.ts
+/**
+* Resolve the monorepo root (directory containing `pnpm-workspace.yaml`).
+* Tries the compiled package location first, then `process.cwd()`.
+*/
+function findRepoRoot(fs) {
+	const candidates = [path.dirname(fileURLToPath(import.meta.url)), process.cwd()];
+	for (const start of candidates) {
+		let dir = path.resolve(start);
+		for (;;) {
+			if (fs.existsSync(path.join(dir, "pnpm-workspace.yaml"))) return dir;
+			const parent = path.dirname(dir);
+			if (parent === dir) break;
+			dir = parent;
+		}
+	}
+	throw new Error(`Could not locate monorepo root (missing pnpm-workspace.yaml). Searched from: ${candidates.join(", ")}`);
+}
+//#endregion
+export { findRepoRoot };