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

package/dist/lib/arrange/application/run-target.js

@@ -0,0 +1,85 @@
+import path from "node:path";
+import { appError } from "#lib/core/domain/errors";
+import { err, ok } from "#lib/core/domain/result";
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message";
+import { groupFile } from "#lib/arrange/application/group-file";
+export function runOnTarget(request, deps) {
+    const { out } = deps.logger;
+    const { fs, fileWalker, domainSourceParser } = deps;
+    if (!fs.existsSync(request.targetPath)) {
+        return err(appError("NOT_FOUND", `Not found: ${request.targetPath}`));
+    }
+    const filePaths = fs.statSync(request.targetPath).isDirectory()
+        ? fileWalker.walkTypeScriptFiles(request.targetPath, fs)
+        : [request.targetPath];
+    const modifiedFiles = [];
+    let totalFound = 0;
+    let totalChanged = 0;
+    const groupOptions = {
+        write: request.write,
+        withClassName: !!request.withClassName,
+        cnImport: request.cnImport,
+    };
+    for (const filePath of filePaths) {
+        const result = groupFile(filePath, groupOptions, fs, deps.logger, domainSourceParser);
+        totalFound += result.totalFound;
+        totalChanged += result.changed;
+        if (result.changed > 0) {
+            modifiedFiles.push(result.filePath);
+        }
+    }
+    out(`\nTotal: ${filePaths.length} file(s), ${totalFound} site(s) (cn/tv/JSX className) to review.`);
+    if (request.write) {
+        out(`Applied: ${totalChanged} site(s) updated.`);
+    }
+    else {
+        out(`(Run "apply" to write changes, or "pnpm cli:arrange-apply" / "pnpm exec codefast arrange apply")`);
+    }
+    const showCascadeHint = request.write ? totalChanged > 0 : totalFound > 0;
+    if (showCascadeHint) {
+        out("Note: class order may change across concern groups — smoke-test the UI if you rely on cascade order.");
+    }
+    return ok({
+        filePaths,
+        modifiedFiles,
+        totalFound,
+        totalChanged,
+    });
+}
+async function runArrangeOnAfterWriteHook(logger, hook, modifiedFiles) {
+    if (!hook || modifiedFiles.length === 0) {
+        return;
+    }
+    try {
+        await hook({ files: modifiedFiles });
+    }
+    catch (caughtHookError) {
+        logger.err(`[arrange] onAfterWrite hook failed: ${messageFromCaughtUnknown(caughtHookError)}`);
+    }
+}
+/**
+ * Preview/apply orchestration: resolves target path, runs grouping pipeline, optional hook.
+ */
+export async function runArrangeSync(request, deps) {
+    void request.rootDir;
+    const resolvedTarget = path.resolve(request.targetPath);
+    const runTargetRequest = {
+        targetPath: resolvedTarget,
+        write: request.write,
+        withClassName: request.withClassName,
+        cnImport: request.cnImport,
+    };
+    const runOutcome = runOnTarget(runTargetRequest, deps);
+    if (!runOutcome.ok) {
+        if (runOutcome.error.code === "NOT_FOUND") {
+            deps.logger.err(runOutcome.error.message);
+        }
+        return runOutcome;
+    }
+    const result = runOutcome.value;
+    if (request.write && result.modifiedFiles.length > 0) {
+        const arrangeConfig = request.config;
+        await runArrangeOnAfterWriteHook(deps.logger, arrangeConfig?.onAfterWrite, result.modifiedFiles);
+    }
+    return ok(0);
+}

package/dist/lib/arrange/domain/arrange-analyze.service.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Rich domain: Tailwind/cn/tv analysis rules (counts, long literals, nested cn in tv).
+ * Pure orchestration of domain collectors and invariants — no I/O.
+ */
+import type { AnalyzeReport } from "#lib/arrange/domain/types";
+import { type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export declare function createEmptyAnalyzeReport(): AnalyzeReport;
+/**
+ * Accumulates findings for one parsed source file into `report` (mutates report).
+ */
+export declare function accumulateAnalyzeReportForSourceFile(report: AnalyzeReport, domainSf: DomainSourceFile, sourceText: string, filePath: string): void;
+//# sourceMappingURL=arrange-analyze.service.d.ts.map

package/dist/lib/arrange/domain/arrange-analyze.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-analyze.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/arrange-analyze.service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAGH,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,2BAA2B,CAAC;AAU/D,OAAO,EAIL,KAAK,gBAAgB,EAKtB,MAAM,wCAAwC,CAAC;AAQhD,wBAAgB,wBAAwB,IAAI,aAAa,CAUxD;AAmGD;;GAEG;AACH,wBAAgB,oCAAoC,CAClD,MAAM,EAAE,aAAa,EACrB,QAAQ,EAAE,gBAAgB,EAC1B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,GACf,IAAI,CAeN"}

package/dist/lib/arrange/domain/arrange-analyze.service.js

@@ -0,0 +1,116 @@
+/**
+ * Rich domain: Tailwind/cn/tv analysis rules (counts, long literals, nested cn in tv).
+ * Pure orchestration of domain collectors and invariants — no I/O.
+ */
+import { LONG_STRING_TOKEN_THRESHOLD } from "#lib/arrange/domain/constants";
+import { tokenizeClassString } from "#lib/arrange/domain/tokenizer";
+import { forEachStringLiteralInClassExpression } from "#lib/arrange/domain/ast/collectors-cn";
+import { jsxClassNameStaticLiteral } from "#lib/arrange/domain/ast/collectors-jsx";
+import { collectCnCallsInsideTv, traverseTvObject } from "#lib/arrange/domain/ast/collectors-tv";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf, } from "#lib/arrange/domain/ast/ast-helpers";
+import { isDomainCallExpression, isDomainJsxAttribute, isDomainObjectLiteralExpression, forEachDomainChild, } from "#lib/arrange/domain/ast/ast-node.model";
+const PREVIEW_MAX_LENGTH = 72;
+function previewText(text) {
+    return text.length > PREVIEW_MAX_LENGTH ? `${text.slice(0, PREVIEW_MAX_LENGTH)}…` : text;
+}
+export function createEmptyAnalyzeReport() {
+    return {
+        files: 0,
+        cnCallExpressions: 0,
+        tvCallExpressions: 0,
+        cnInsideTvCalls: [],
+        longCnStringLiterals: [],
+        longTvStringLiterals: [],
+        longJsxClassNameLiterals: [],
+    };
+}
+function analyzeCnCall(domainSf, 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: domainSf.fileName,
+                    line: lineOf(domainSf, lit),
+                    tokenCount,
+                    preview: previewText(text),
+                });
+            }
+        });
+    }
+}
+function visitCallExpressionForArrangeAnalyze(callExpression, domainSf, sourceText, knownBindings, report) {
+    if (isCnOrTvIdentifier(callExpression.expression, "cn", knownBindings)) {
+        report.cnCallExpressions++;
+        analyzeCnCall(domainSf, callExpression, report);
+        return;
+    }
+    if (!isCnOrTvIdentifier(callExpression.expression, "tv", knownBindings)) {
+        return;
+    }
+    report.tvCallExpressions++;
+    const arg0 = callExpression.arguments[0];
+    if (!arg0 || !isDomainObjectLiteralExpression(arg0)) {
+        return;
+    }
+    for (const nestedCn of collectCnCallsInsideTv(domainSf, arg0, knownBindings, 0)) {
+        const src = sourceText.slice(nestedCn.pos, nestedCn.end);
+        report.cnInsideTvCalls.push({
+            file: domainSf.fileName,
+            line: lineOf(domainSf, nestedCn),
+            argCount: nestedCn.arguments.length,
+            preview: previewText(src),
+        });
+    }
+    traverseTvObject(domainSf, arg0, (classLiteral) => {
+        const text = classLiteral.text;
+        const tokenCount = tokenizeClassString(text).length;
+        if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+            report.longTvStringLiterals.push({
+                file: domainSf.fileName,
+                line: lineOf(domainSf, classLiteral),
+                tokenCount,
+                preview: previewText(text),
+            });
+        }
+    }, 0, knownBindings);
+}
+function visitJsxAttributeForArrangeAnalyze(jsxClassAttribute, domainSf, filePath, report) {
+    if (!filePath.endsWith(".tsx")) {
+        return;
+    }
+    const parsed = jsxClassNameStaticLiteral(jsxClassAttribute);
+    if (!parsed) {
+        return;
+    }
+    const text = parsed.lit.text;
+    const tokenCount = tokenizeClassString(text).length;
+    if (tokenCount >= LONG_STRING_TOKEN_THRESHOLD) {
+        report.longJsxClassNameLiterals.push({
+            file: domainSf.fileName,
+            line: lineOf(domainSf, parsed.lit),
+            tokenCount,
+            preview: previewText(text),
+        });
+    }
+}
+/**
+ * Accumulates findings for one parsed source file into `report` (mutates report).
+ */
+export function accumulateAnalyzeReportForSourceFile(report, domainSf, sourceText, filePath) {
+    report.files++;
+    const knownBindings = buildKnownCnTvBindings(domainSf);
+    const visitTypeScriptSubtree = (tsNode) => {
+        if (isDomainCallExpression(tsNode)) {
+            visitCallExpressionForArrangeAnalyze(tsNode, domainSf, sourceText, knownBindings, report);
+        }
+        if (isDomainJsxAttribute(tsNode)) {
+            visitJsxAttributeForArrangeAnalyze(tsNode, domainSf, filePath, report);
+        }
+        forEachDomainChild(tsNode, visitTypeScriptSubtree);
+    };
+    for (const stmt of domainSf.statements) {
+        visitTypeScriptSubtree(stmt);
+    }
+}

package/dist/lib/arrange/domain/arrange-grouping.service.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+ * Pure: only DomainSourceFile, source strings, and options — no I/O.
+ */
+import type { GroupFileResult, PlannedGroupEdit } from "#lib/arrange/domain/types";
+import type { DomainCallExpression, DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export type GroupFileUnwrapPlan = {
+    readonly start: number;
+    readonly end: number;
+    readonly replacement: string;
+    readonly call: DomainCallExpression;
+};
+export type GroupFileUnwrapState = {
+    readonly cnInTvCalls: readonly DomainCallExpression[];
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: readonly GroupFileUnwrapPlan[];
+    readonly textAfterUnwrap: string;
+    readonly cnInTvNoReplacement: number;
+};
+export type GroupFileWorkPlan = {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly textAfterUnwrap: string;
+    readonly domainSfForLineNumbers: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly cnInTvCalls: readonly DomainCallExpression[];
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: readonly GroupFileUnwrapPlan[];
+    readonly plannedGroupEdits: readonly PlannedGroupEdit[];
+    readonly cnInTvNoReplacement: number;
+    readonly reportTotal: number;
+    readonly editSitesCount: number;
+};
+export declare function buildGroupFileUnwrapState(domainSfInitial: DomainSourceFile, sourceText: string): GroupFileUnwrapState;
+/**
+ * `domainSfGrouped` must be a parse of `unwrap.textAfterUnwrap` (same `text` as source).
+ * Returns `null` when there is no cn-in-tv and no grouping targets.
+ */
+export declare function tryBuildGroupFileWorkPlan(input: {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly domainSfInitial: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly withClassName: boolean;
+    readonly unwrap: GroupFileUnwrapState;
+}): GroupFileWorkPlan | null;
+export declare function groupFileDryRunNoEdits(filePath: string): GroupFileResult;
+export declare function groupFilePreviewTotals(work: GroupFileWorkPlan): GroupFileResult;
+export declare function mergeGroupFileBodyText(work: GroupFileWorkPlan): string;
+export declare function groupFileEditsTouchJsxCn(work: GroupFileWorkPlan): boolean;
+export declare function countPersistedGroupFileEdits(work: GroupFileWorkPlan): number;
+export declare function groupFileWorkHasNothingToReport(work: GroupFileWorkPlan): boolean;
+//# sourceMappingURL=arrange-grouping.service.d.ts.map

package/dist/lib/arrange/domain/arrange-grouping.service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-grouping.service.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/domain/arrange-grouping.service.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,KAAK,EAAE,eAAe,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAYnF,OAAO,KAAK,EACV,oBAAoB,EACpB,gBAAgB,EACjB,MAAM,wCAAwC,CAAC;AAEhD,MAAM,MAAM,mBAAmB,GAAG;IAChC,QAAQ,CAAC,KAAK,EAAE,MAAM,CAAC;IACvB,QAAQ,CAAC,GAAG,EAAE,MAAM,CAAC;IACrB,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,IAAI,EAAE,oBAAoB,CAAC;CACrC,CAAC;AAEF,MAAM,MAAM,oBAAoB,GAAG;IACjC,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACtD,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IAC5E,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;CACtC,CAAC;AAEF,MAAM,MAAM,iBAAiB,GAAG;IAC9B,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,MAAM,CAAC;IACjC,QAAQ,CAAC,sBAAsB,EAAE,gBAAgB,CAAC;IAClD,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,WAAW,EAAE,SAAS,oBAAoB,EAAE,CAAC;IACtD,QAAQ,CAAC,uBAAuB,EAAE,WAAW,CAAC,oBAAoB,EAAE,MAAM,CAAC,CAAC;IAC5E,QAAQ,CAAC,WAAW,EAAE,SAAS,mBAAmB,EAAE,CAAC;IACrD,QAAQ,CAAC,iBAAiB,EAAE,SAAS,gBAAgB,EAAE,CAAC;IACxD,QAAQ,CAAC,mBAAmB,EAAE,MAAM,CAAC;IACrC,QAAQ,CAAC,WAAW,EAAE,MAAM,CAAC;IAC7B,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;CACjC,CAAC;AAiBF,wBAAgB,yBAAyB,CACvC,eAAe,EAAE,gBAAgB,EACjC,UAAU,EAAE,MAAM,GACjB,oBAAoB,CAoBtB;AAED;;;GAGG;AACH,wBAAgB,yBAAyB,CAAC,KAAK,EAAE;IAC/C,QAAQ,CAAC,QAAQ,EAAE,MAAM,CAAC;IAC1B,QAAQ,CAAC,UAAU,EAAE,MAAM,CAAC;IAC5B,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,eAAe,EAAE,gBAAgB,CAAC;IAC3C,QAAQ,CAAC,aAAa,EAAE,OAAO,CAAC;IAChC,QAAQ,CAAC,MAAM,EAAE,oBAAoB,CAAC;CACvC,GAAG,iBAAiB,GAAG,IAAI,CA+C3B;AAED,wBAAgB,sBAAsB,CAAC,QAAQ,EAAE,MAAM,GAAG,eAAe,CAExE;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,eAAe,CAM/E;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAWtE;AAED,wBAAgB,wBAAwB,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEzE;AAED,wBAAgB,4BAA4B,CAAC,IAAI,EAAE,iBAAiB,GAAG,MAAM,CAE5E;AAED,wBAAgB,+BAA+B,CAAC,IAAI,EAAE,iBAAiB,GAAG,OAAO,CAEhF"}

package/dist/lib/arrange/domain/arrange-grouping.service.js

@@ -0,0 +1,106 @@
+/**
+ * Rich domain: plan Tailwind class grouping / cn-in-tv unwrap for a single file.
+ * Pure: only DomainSourceFile, source strings, and options — no I/O.
+ */
+import { applyEditsDescending, buildKnownCnTvBindings, unwrapCnInsideTvCallReplacement, } from "#lib/arrange/domain/ast/ast-helpers";
+import { listAllCnCallsInsideTvInSourceFile } from "#lib/arrange/domain/ast/collectors-tv";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart, } from "#lib/arrange/domain/ast/targets";
+function toUnwrapPlans(cnInTvCalls, sourceText) {
+    return cnInTvCalls
+        .map((call) => {
+        const replacement = unwrapCnInsideTvCallReplacement(call, sourceText);
+        if (replacement === undefined) {
+            return undefined;
+        }
+        return { start: call.pos, end: call.end, replacement, call };
+    })
+        .filter((plan) => plan !== undefined);
+}
+export function buildGroupFileUnwrapState(domainSfInitial, sourceText) {
+    const knownBindings = buildKnownCnTvBindings(domainSfInitial);
+    const cnInTvCalls = listAllCnCallsInsideTvInSourceFile(domainSfInitial, knownBindings);
+    const unwrapPlans = toUnwrapPlans(cnInTvCalls, sourceText);
+    const unwrapReplacementByCall = new Map(unwrapPlans.map((unwrapPlan) => [unwrapPlan.call, unwrapPlan.replacement]));
+    const unwrapEdits = unwrapPlans.filter((unwrapPlan) => sourceText.slice(unwrapPlan.start, unwrapPlan.end) !== unwrapPlan.replacement);
+    const textAfterUnwrap = unwrapEdits.length > 0 ? applyEditsDescending(sourceText, [...unwrapEdits]) : sourceText;
+    const cnInTvNoReplacement = cnInTvCalls.length - unwrapPlans.length;
+    return {
+        cnInTvCalls,
+        unwrapReplacementByCall,
+        unwrapEdits,
+        textAfterUnwrap,
+        cnInTvNoReplacement,
+    };
+}
+/**
+ * `domainSfGrouped` must be a parse of `unwrap.textAfterUnwrap` (same `text` as source).
+ * Returns `null` when there is no cn-in-tv and no grouping targets.
+ */
+export function tryBuildGroupFileWorkPlan(input) {
+    const { filePath, sourceText, domainSfInitial, domainSfGrouped, withClassName, unwrap } = input;
+    if (domainSfGrouped.text !== unwrap.textAfterUnwrap) {
+        throw new Error("Domain invariant: domainSfGrouped.text must match unwrap phase textAfterUnwrap");
+    }
+    const groupTargets = collectGroupTargets(domainSfGrouped, filePath);
+    if (unwrap.cnInTvCalls.length === 0 && groupTargets.length === 0) {
+        return null;
+    }
+    const sortedTargets = [...groupTargets].sort((leftTarget, rightTarget) => targetReplaceStart(rightTarget) - targetReplaceStart(leftTarget));
+    const plannedGroupEdits = [];
+    for (const groupTarget of sortedTargets) {
+        const plan = planGroupEditForTarget(groupTarget, unwrap.textAfterUnwrap, withClassName);
+        if (plan === undefined) {
+            continue;
+        }
+        if (unwrap.textAfterUnwrap.slice(plan.start, plan.end) === plan.replacement) {
+            continue;
+        }
+        plannedGroupEdits.push(plan);
+    }
+    const editSitesCount = unwrap.unwrapEdits.length + plannedGroupEdits.length;
+    const reportTotal = editSitesCount + unwrap.cnInTvNoReplacement;
+    return {
+        filePath,
+        sourceText,
+        textAfterUnwrap: unwrap.textAfterUnwrap,
+        domainSfForLineNumbers: domainSfInitial,
+        domainSfGrouped,
+        cnInTvCalls: unwrap.cnInTvCalls,
+        unwrapReplacementByCall: unwrap.unwrapReplacementByCall,
+        unwrapEdits: unwrap.unwrapEdits,
+        plannedGroupEdits,
+        cnInTvNoReplacement: unwrap.cnInTvNoReplacement,
+        reportTotal,
+        editSitesCount,
+    };
+}
+export function groupFileDryRunNoEdits(filePath) {
+    return { filePath, totalFound: 0, changed: 0 };
+}
+export function groupFilePreviewTotals(work) {
+    return {
+        filePath: work.filePath,
+        totalFound: work.reportTotal,
+        changed: 0,
+    };
+}
+export function mergeGroupFileBodyText(work) {
+    const groupEdits = work.plannedGroupEdits.map((plannedEdit) => ({
+        start: plannedEdit.start,
+        end: plannedEdit.end,
+        replacement: plannedEdit.replacement,
+        jsxCn: plannedEdit.jsxCn,
+    }));
+    return groupEdits.length > 0
+        ? applyEditsDescending(work.textAfterUnwrap, groupEdits)
+        : work.textAfterUnwrap;
+}
+export function groupFileEditsTouchJsxCn(work) {
+    return work.plannedGroupEdits.some((plannedEdit) => plannedEdit.jsxCn);
+}
+export function countPersistedGroupFileEdits(work) {
+    return work.unwrapEdits.length + work.plannedGroupEdits.length;
+}
+export function groupFileWorkHasNothingToReport(work) {
+    return work.editSitesCount === 0 && work.cnInTvNoReplacement === 0;
+}

package/dist/lib/arrange/domain/ast/ast-helpers.d.ts

@@ -0,0 +1,28 @@
+import { applyEditsDescending, indentOfLineContaining } from "#lib/shared/source-code/domain/text-edit";
+import { type DomainAstNode, type DomainCallExpression, type DomainPropertyAssignment, type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+/** Known module specifiers that export `cn` / `tv`. */
+export declare const KNOWN_CN_TV_MODULES: Set<string>;
+/**
+ * True for typical shadcn-style re-exports: `./utils`, `@/lib/utils`, `…/utils/…`,
+ * or a dedicated `cn.ts` / `cn.tsx` module.
+ */
+export declare function moduleLooksLikeCnTvReexport(moduleSpecifier: string): boolean;
+/**
+ * Build a set of local binding names that are imported from a known cn/tv
+ * module in `sourceFile`.
+ */
+export declare function buildKnownCnTvBindings(sourceFile: DomainSourceFile): Set<string>;
+/**
+ * Returns true when `expr` is an identifier whose name matches `name` AND
+ * that name is listed in `knownBindings` from a recognized import.
+ */
+export declare function isCnOrTvIdentifier(expr: DomainAstNode, name: "cn" | "tv", knownBindings?: Set<string>): boolean;
+export declare function propertyAssignmentNameText(prop: DomainPropertyAssignment): string | undefined;
+export declare function lineOf(sourceFile: DomainSourceFile, node: DomainAstNode): number;
+export { applyEditsDescending, indentOfLineContaining };
+/**
+ * Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+ * array (multiple args). Returns undefined when there are zero arguments.
+ */
+export declare function unwrapCnInsideTvCallReplacement(call: DomainCallExpression, sourceText: string): string | undefined;
+//# sourceMappingURL=ast-helpers.d.ts.map

package/dist/lib/arrange/domain/ast/ast-helpers.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ast-helpers.d.ts","sourceRoot":"","sources":["../../../../../src/lib/arrange/domain/ast/ast-helpers.ts"],"names":[],"mappings":"AACA,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACvB,MAAM,0CAA0C,CAAC;AAClD,OAAO,EACL,KAAK,aAAa,EAClB,KAAK,oBAAoB,EACzB,KAAK,wBAAwB,EAC7B,KAAK,gBAAgB,EAQtB,MAAM,wCAAwC,CAAC;AAEhD,uDAAuD;AACvD,eAAO,MAAM,mBAAmB,aAU9B,CAAC;AAEH;;;GAGG;AACH,wBAAgB,2BAA2B,CAAC,eAAe,EAAE,MAAM,GAAG,OAAO,CAY5E;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,gBAAgB,GAAG,GAAG,CAAC,MAAM,CAAC,CAsChF;AAED;;;GAGG;AACH,wBAAgB,kBAAkB,CAChC,IAAI,EAAE,aAAa,EACnB,IAAI,EAAE,IAAI,GAAG,IAAI,EACjB,aAAa,GAAE,GAAG,CAAC,MAAM,CAAwB,GAChD,OAAO,CAWT;AAED,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,wBAAwB,GAAG,MAAM,GAAG,SAAS,CAQ7F;AAED,wBAAgB,MAAM,CAAC,UAAU,EAAE,gBAAgB,EAAE,IAAI,EAAE,aAAa,GAAG,MAAM,CAEhF;AAED,OAAO,EAAE,oBAAoB,EAAE,sBAAsB,EAAE,CAAC;AAExD;;;GAGG;AACH,wBAAgB,+BAA+B,CAC7C,IAAI,EAAE,oBAAoB,EAC1B,UAAU,EAAE,MAAM,GACjB,MAAM,GAAG,SAAS,CAsBpB"}

package/dist/lib/arrange/domain/ast/ast-helpers.js

@@ -0,0 +1,130 @@
+import { EMPTY_CN_TV_BINDINGS } from "#lib/arrange/domain/constants";
+import { applyEditsDescending, indentOfLineContaining, } from "#lib/shared/source-code/domain/text-edit";
+import { isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainNamespaceImport, isDomainPropertyAccessExpression, isDomainStringLiteral, lineOfSourcePosition, } from "#lib/arrange/domain/ast/ast-node.model";
+/** Known module specifiers that export `cn` / `tv`. */
+export const KNOWN_CN_TV_MODULES = new Set([
+    "@codefast/tailwind-variants",
+    "clsx",
+    "class-variance-authority",
+    // Backward compatibility only: keep detection for existing user code that still imports
+    // from "tailwind-variants"; new code should prefer "@codefast/tailwind-variants".
+    "tailwind-variants",
+    "#lib/utils",
+    "~/lib/utils",
+    "@/lib/utils",
+]);
+/**
+ * True for typical shadcn-style re-exports: `./utils`, `@/lib/utils`, `…/utils/…`,
+ * or a dedicated `cn.ts` / `cn.tsx` module.
+ */
+export function moduleLooksLikeCnTvReexport(moduleSpecifier) {
+    const norm = moduleSpecifier.replace(/\\/g, "/");
+    if (/(?:^|[./])utils(?:\/|$)/.test(norm)) {
+        return true;
+    }
+    if (/\/utils\//.test(norm) || /\/utils$/.test(norm)) {
+        return true;
+    }
+    if (/(?:^|\/)cn\.tsx?$/.test(norm)) {
+        return true;
+    }
+    return false;
+}
+/**
+ * Build a set of local binding names that are imported from a known cn/tv
+ * module in `sourceFile`.
+ */
+export function buildKnownCnTvBindings(sourceFile) {
+    const bindings = new Set();
+    for (const stmt of sourceFile.statements) {
+        if (!isDomainImportDeclaration(stmt) || !stmt.importClause) {
+            continue;
+        }
+        if (stmt.importClause.isTypeOnly) {
+            continue;
+        }
+        const spec = stmt.moduleSpecifier;
+        if (!isDomainStringLiteral(spec)) {
+            continue;
+        }
+        const moduleSpecifierText = spec.text;
+        const isKnown = KNOWN_CN_TV_MODULES.has(moduleSpecifierText);
+        if (!isKnown && !moduleLooksLikeCnTvReexport(moduleSpecifierText)) {
+            continue;
+        }
+        const clause = stmt.importClause;
+        if (clause.name) {
+            bindings.add(clause.name.text);
+        }
+        const { namedBindings } = clause;
+        if (!namedBindings) {
+            continue;
+        }
+        if (isDomainNamedImports(namedBindings)) {
+            for (const namedImport of namedBindings.elements) {
+                bindings.add(namedImport.name.text);
+            }
+            continue;
+        }
+        if (isDomainNamespaceImport(namedBindings)) {
+            bindings.add(namedBindings.name.text);
+        }
+    }
+    return bindings;
+}
+/**
+ * Returns true when `expr` is an identifier whose name matches `name` AND
+ * that name is listed in `knownBindings` from a recognized import.
+ */
+export function isCnOrTvIdentifier(expr, name, knownBindings = EMPTY_CN_TV_BINDINGS) {
+    if (knownBindings.size === 0) {
+        return false;
+    }
+    if (isDomainIdentifier(expr) && expr.text === name) {
+        return knownBindings.has(expr.text);
+    }
+    if (isDomainPropertyAccessExpression(expr) && expr.name.text === name) {
+        return isDomainIdentifier(expr.expression) && knownBindings.has(expr.expression.text);
+    }
+    return false;
+}
+export function propertyAssignmentNameText(prop) {
+    if (isDomainIdentifier(prop.name)) {
+        return prop.name.text;
+    }
+    if (isDomainStringLiteral(prop.name)) {
+        return prop.name.text;
+    }
+    return undefined;
+}
+export function lineOf(sourceFile, node) {
+    return lineOfSourcePosition(sourceFile.text, node.pos);
+}
+export { applyEditsDescending, indentOfLineContaining };
+/**
+ * Replace `cn(...)` nested in `tv({...})` with a plain string (one arg) or a string
+ * array (multiple args). Returns undefined when there are zero arguments.
+ */
+export function unwrapCnInsideTvCallReplacement(call, sourceText) {
+    const args = call.arguments;
+    if (args.length === 0) {
+        return undefined;
+    }
+    const baseIndent = indentOfLineContaining(sourceText, call.pos);
+    const innerIndent = `${baseIndent}  `;
+    if (args.length === 1) {
+        const firstArg = args[0];
+        return sourceText.slice(firstArg.pos, firstArg.end);
+    }
+    const lines = ["["];
+    for (let i = 0; i < args.length; i++) {
+        const arg = args[i];
+        const piece = sourceText.slice(arg.pos, arg.end);
+        // Trailing comma on every element — intentional (Prettier-compatible style;
+        // keeps array diffs clean when arguments are later added or removed).
+        const comma = i < args.length - 1 || args.length > 1 ? "," : "";
+        lines.push(`${innerIndent}${piece}${comma}`);
+    }
+    lines.push(`${baseIndent}]`);
+    return lines.join("\n");
+}