@codefast/cli 0.10.0 → 0.12.0

package/dist/arrange/domain/ast/simplify-targets.js

@@ -1,8 +1,8 @@
-import { forEachDomainChild, isDomainArrayLiteralExpression, isDomainCallExpression, isDomainJsxAttribute, isDomainJsxExpression, isDomainObjectLiteralExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainTailwindClassLiteral, } from "#/arrange/domain/ast/ast-node";
-import { buildKnownCnTvBindings, isCnOrTvIdentifier } from "#/arrange/domain/ast/helpers";
-import { MAX_OBJECT_DEPTH } from "#/arrange/domain/constants";
-import { escapeTsStringLiteralContent } from "#/arrange/domain/source-text-formatters";
-import { indentOfLineContaining } from "#/core/source-text-edit";
+import { forEachDomainChild, isDomainArrayLiteralExpression, isDomainCallExpression, isDomainJsxAttribute, isDomainJsxExpression, isDomainObjectLiteralExpression, isDomainPropertyAssignment, isDomainSpreadElement, isDomainTailwindClassLiteral, } from "#arrange/domain/ast/ast-node";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier } from "#arrange/domain/ast/helpers";
+import { MAX_OBJECT_DEPTH } from "#arrange/domain/constants";
+import { escapeTsStringLiteralContent } from "#arrange/domain/source-text-formatters";
+import { indentOfLineContaining } from "#core/source-text-edit";
 function toFlatString(text) {
     return `"${escapeTsStringLiteralContent(text.trim())}"`;
 }
@@ -15,47 +15,42 @@ function joinLiterals(args) {
 function isAllStaticLiterals(args) {
     return args.length > 0 && args.every(isDomainTailwindClassLiteral);
 }
-// ---------------------------------------------------------------------------
-// Mixed cn() merge: ALL static args → one string first, dynamic args follow
-// ---------------------------------------------------------------------------
 /**
- * For a cn() call that has both static and dynamic args:
- * - Merge ALL static string literals (regardless of position) into one string.
- * - Place the merged string first.
- * - Append all dynamic args in their original relative order.
+ * Builds a mixed cn() replacement that coalesces each run of adjacent static literals into one string.
  *
- * Returns `null` when nothing changes (0 statics, or already 1 static at arg[0]).
+ * @remarks Argument order is preserved so tailwind-merge precedence is unchanged — a later cn()
+ * argument still overrides an earlier one. Returns `null` when no run of two-or-more adjacent statics
+ * exists, since reordering a lone static across a dynamic argument would change what renders.
  */
 function buildMixedCnReplacement(call, sourceText) {
     const args = [...call.arguments];
     if (args.length === 0) {
         return null;
     }
-    const staticTexts = [];
-    const dynamicSrcs = [];
+    const pieces = [];
     for (const arg of args) {
         if (isDomainTailwindClassLiteral(arg)) {
-            staticTexts.push(arg.text);
+            const last = pieces.at(-1);
+            if (last?.kind === "static") {
+                last.texts.push(arg.text);
+            }
+            else {
+                pieces.push({ kind: "static", texts: [arg.text] });
+            }
         }
         else {
-            dynamicSrcs.push(sourceText.slice(arg.pos, arg.end));
+            pieces.push({ kind: "dynamic", src: sourceText.slice(arg.pos, arg.end) });
         }
     }
-    if (staticTexts.length === 0) {
-        return null;
-    }
-    // Already simplest form: 1 static arg already at the front.
-    const firstArg = args[0];
-    if (staticTexts.length === 1 && firstArg !== undefined && isDomainTailwindClassLiteral(firstArg)) {
+    const merged = pieces.some((piece) => piece.kind === "static" && piece.texts.length > 1);
+    if (!merged) {
         return null;
     }
-    const flatStatic = staticTexts.join(" ").trim();
     const baseIndent = indentOfLineContaining(sourceText, call.pos);
     const argIndent = `${baseIndent}  `;
-    const lines = [
-        `${argIndent}"${escapeTsStringLiteralContent(flatStatic)}",`,
-        ...dynamicSrcs.map((src) => `${argIndent}${src},`),
-    ];
+    const lines = pieces.map((piece) => piece.kind === "static"
+        ? `${argIndent}"${escapeTsStringLiteralContent(piece.texts.join(" ").trim())}",`
+        : `${argIndent}${piece.src},`);
     return `cn(\n${lines.join("\n")}\n${baseIndent})`;
 }
 // ── tv() array collector ─────────────────────────────────────────────────────────────────────────────────────────────

package/dist/arrange/domain/ast/targets.d.ts

@@ -1,5 +1,5 @@
-import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
-import type { GroupTarget, PlannedGroupEdit } from "#/arrange/domain/types";
+import type { DomainSourceFile } from "#arrange/domain/ast/ast-node";
+import type { GroupTarget, PlannedGroupEdit } from "#arrange/domain/types";
 /**
  * Resolves the source position where a group target's replacement begins.
  *

package/dist/arrange/domain/ast/targets.js

@@ -1,12 +1,12 @@
-import { isDomainArrayLiteralExpression, isDomainJsxAttribute, isDomainPropertyAssignment, isDomainTailwindClassLiteral, forEachDomainChild, } from "#/arrange/domain/ast/ast-node";
-import { isUnsafeLiteralForCnStyleApplySplit } from "#/arrange/domain/ast/collectors-cn";
-import { jsxClassNameStaticLiteral } from "#/arrange/domain/ast/collectors-jsx";
-import { collectGroupableStringNodes, slotClassString } from "#/arrange/domain/ast/collectors-tv";
-import { APPLY_MIN_TOKENS } from "#/arrange/domain/constants";
-import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels, } from "#/arrange/domain/grouping";
-import { escapeTsStringLiteralContent, formatArray, formatArrayElementsAsSiblingLines, formatJsxCnAttributeValue, } from "#/arrange/domain/source-text-formatters";
-import { tokenizeClassString } from "#/arrange/domain/tailwind-token";
-import { endAfterOptionalCommaFollowingInSource, indentOfLineContaining, textPrefixFromLineStartToPosition, } from "#/core/source-text-edit";
+import { isDomainArrayLiteralExpression, isDomainJsxAttribute, isDomainPropertyAssignment, isDomainTailwindClassLiteral, forEachDomainChild, } from "#arrange/domain/ast/ast-node";
+import { isUnsafeLiteralForCnStyleApplySplit } from "#arrange/domain/ast/collectors-cn";
+import { jsxClassNameStaticLiteral } from "#arrange/domain/ast/collectors-jsx";
+import { collectGroupableStringNodes, slotClassString } from "#arrange/domain/ast/collectors-tv";
+import { APPLY_MIN_TOKENS } from "#arrange/domain/constants";
+import { areCnTailwindPartitionsEquivalent, suggestCnGroups, summarizeGroupBucketLabels, } from "#arrange/domain/grouping";
+import { escapeTsStringLiteralContent, formatArray, formatArrayElementsAsSiblingLines, formatJsxCnAttributeValue, } from "#arrange/domain/source-text-formatters";
+import { tokenizeClassString } from "#arrange/domain/tailwind-token";
+import { endAfterOptionalCommaFollowingInSource, indentOfLineContaining, textPrefixFromLineStartToPosition, } from "#core/source-text-edit";
 /**
  * Resolves the source position where a group target's replacement begins.
  *

package/dist/arrange/{typescript-ast-translator.d.ts → domain/ast/translator.d.ts}

@@ -2,7 +2,7 @@
  * Anti-corruption layer: maps the oxc-parser ESTree AST to the arrange domain AST.
  * This is the only place that parses TypeScript source for arrange AST translation.
  */
-import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { DomainSourceFile } from "#arrange/domain/ast/ast-node";
 /**
  * The translator mapping the `oxc-parser` ESTree AST to the arrange domain AST.
  *
@@ -11,11 +11,12 @@ import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
 export declare class TypeScriptAstTranslator {
     translateSourceFile(filePath: string, sourceText: string): DomainSourceFile;
     /**
-     * Own child nodes in source-declaration order, mirroring `ts.forEachChild`:
-     * recurses into nested node objects and arrays of nodes, skipping primitives
-     * and plain records (e.g. a template element's `value`) that carry no `type`.
+     * Translates any node the typed cases do not cover, recursing into own child nodes and arrays of
+     * nodes in source-declaration order and skipping primitives and records that carry no `type`.
+     *
+     * @remarks Children are walked inline rather than through a generator — the `yield` per child is
+     * several times slower than a plain loop on this hot path, and this fallback runs for most nodes.
      */
-    private childNodesOf;
     private translateUnknown;
     private stringLiteralText;
     private noSubstitutionTemplateText;

package/dist/arrange/{typescript-ast-translator.js → domain/ast/translator.js}

@@ -3,7 +3,7 @@
  * This is the only place that parses TypeScript source for arrange AST translation.
  */
 import { parseSync } from "oxc-parser";
-import { DomainBinaryOperator, DomainSyntaxKind } from "#/arrange/domain/ast/ast-node";
+import { DomainBinaryOperator, DomainSyntaxKind } from "#arrange/domain/ast/ast-node";
 function isOxcNode(value) {
     return typeof value === "object" && value !== null && typeof value.type === "string";
 }
@@ -20,11 +20,21 @@ export class TypeScriptAstTranslator {
         return this.parseDomainSourceFile(filePath, sourceText);
     }
     /**
-     * Own child nodes in source-declaration order, mirroring `ts.forEachChild`:
-     * recurses into nested node objects and arrays of nodes, skipping primitives
-     * and plain records (e.g. a template element's `value`) that carry no `type`.
+     * Translates any node the typed cases do not cover, recursing into own child nodes and arrays of
+     * nodes in source-declaration order and skipping primitives and records that carry no `type`.
+     *
+     * @remarks Children are walked inline rather than through a generator — the `yield` per child is
+     * several times slower than a plain loop on this hot path, and this fallback runs for most nodes.
      */
-    *childNodesOf(node) {
+    translateUnknown(node, parent) {
+        const self = {
+            kind: DomainSyntaxKind.Unknown,
+            pos: node.start,
+            end: node.end,
+            parent,
+            children: [],
+        };
+        const childList = [];
         for (const key in node) {
             if (key === "type" || key === "start" || key === "end" || key === "range") {
                 continue;
@@ -33,29 +43,16 @@ export class TypeScriptAstTranslator {
             if (Array.isArray(value)) {
                 for (const element of value) {
                     if (isOxcNode(element)) {
-                        yield element;
+                        childList.push(this.translateNode(element, self));
                     }
                 }
-                continue;
             }
-            if (isOxcNode(value)) {
-                yield value;
+            else if (isOxcNode(value)) {
+                childList.push(this.translateNode(value, self));
             }
         }
-    }
-    translateUnknown(node, parent) {
-        const self = {
-            kind: DomainSyntaxKind.Unknown,
-            pos: node.start,
-            end: node.end,
-            parent,
-            children: [],
-        };
-        const childList = [];
-        for (const child of this.childNodesOf(node)) {
-            childList.push(this.translateNode(child, self));
-        }
-        return { ...self, children: childList };
+        self.children = childList;
+        return self;
     }
     stringLiteralText(node) {
         if (node.type === "Literal" && typeof node.value === "string") {

package/dist/arrange/domain/constants.d.ts

@@ -1,4 +1,4 @@
-import type { Bucket } from "#/arrange/domain/types";
+import type { Bucket } from "#arrange/domain/types";
 /**
  * Analyze report: long literal threshold (token count).
  *

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

@@ -2,8 +2,8 @@
  * 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 { DomainCallExpression, DomainSourceFile } from "#/arrange/domain/ast/ast-node";
-import type { GroupFileResult, PlannedGroupEdit } from "#/arrange/domain/types";
+import type { DomainCallExpression, DomainSourceFile } from "#arrange/domain/ast/ast-node";
+import type { GroupFileResult, PlannedGroupEdit } from "#arrange/domain/types";
 /**
  * A planned replacement unwrapping one `cn()` call nested in `tv({ ... })`.
  *

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

@@ -2,9 +2,9 @@
  * 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 { listAllCnCallsInsideTvInSourceFile } from "#/arrange/domain/ast/collectors-tv";
-import { applyEditsDescending, buildKnownCnTvBindings, unwrapCnInsideTvCallReplacement, } from "#/arrange/domain/ast/helpers";
-import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart } from "#/arrange/domain/ast/targets";
+import { listAllCnCallsInsideTvInSourceFile } from "#arrange/domain/ast/collectors-tv";
+import { applyEditsDescending, buildKnownCnTvBindings, unwrapCnInsideTvCallReplacement, } from "#arrange/domain/ast/helpers";
+import { collectGroupTargets, planGroupEditForTarget, targetReplaceStart } from "#arrange/domain/ast/targets";
 function toUnwrapPlans(cnInTvCalls, sourceText) {
     return cnInTvCalls
         .map((call) => {

package/dist/arrange/domain/grouping.js

@@ -1,6 +1,6 @@
-import { BUCKET_ORDER, MAX_GROUPS_BASE, MAX_GROUPS_CAP, MAX_GROUPS_HEADROOM, MIN_GROUP_TOKENS, } from "#/arrange/domain/constants";
-import { stripVariants, tokenizeClassString } from "#/arrange/domain/tailwind-token";
-import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSecondaryOrder, selectorKey, stateKey, } from "#/arrange/domain/token-classifier";
+import { BUCKET_ORDER, MAX_GROUPS_BASE, MAX_GROUPS_CAP, MAX_GROUPS_HEADROOM, MIN_GROUP_TOKENS, } from "#arrange/domain/constants";
+import { stripVariants, tokenizeClassString } from "#arrange/domain/tailwind-token";
+import { bucketsCompatible, bucketsMergeCompatible, classifyToken, compositeSecondaryOrder, selectorKey, stateKey, } from "#arrange/domain/token-classifier";
 /**
  * `cn()` grouping: bucket sequence is {@link BUCKET_ORDER} only; tokens are classified with
  * {@link classifyToken}. Comparators here (`compareClassifiedTailwindTokensForCnGrouping`, …)

package/dist/arrange/domain/imports.d.ts

@@ -1,4 +1,4 @@
-import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { DomainSourceFile } from "#arrange/domain/ast/ast-node";
 /**
  * After simplify rewrites, drop the `cn` import specifier when `cn` is no
  * longer referenced anywhere outside the import declarations.

package/dist/arrange/domain/imports.js

@@ -1,5 +1,5 @@
-import { forEachDomainChild, isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainStringLiteral, } from "#/arrange/domain/ast/ast-node";
-import { endAfterOptionalCommaFollowingInSource } from "#/core/source-text-edit";
+import { forEachDomainChild, isDomainIdentifier, isDomainImportDeclaration, isDomainNamedImports, isDomainStringLiteral, } from "#arrange/domain/ast/ast-node";
+import { endAfterOptionalCommaFollowingInSource } from "#core/source-text-edit";
 function sourceFileImportsCn(sourceFile) {
     for (const statement of sourceFile.statements) {
         if (!isDomainImportDeclaration(statement) || !statement.importClause) {

package/dist/arrange/domain/source-text-formatters.js

@@ -1,4 +1,4 @@
-import { indentOfLineContaining } from "#/core/source-text-edit";
+import { indentOfLineContaining } from "#core/source-text-edit";
 /**
  * Escapes backslashes and double quotes for embedding in a double-quoted TypeScript string literal.
  *

package/dist/arrange/domain/tailwind-token.js

@@ -1,4 +1,4 @@
-import { MAX_STRIP_VARIANT_PASSES } from "#/arrange/domain/constants";
+import { MAX_STRIP_VARIANT_PASSES } from "#arrange/domain/constants";
 /**
  * Splits a class string into its whitespace-separated tokens.
  *

package/dist/arrange/domain/token-classifier.d.ts

@@ -1,4 +1,4 @@
-import type { Bucket } from "#/arrange/domain/types";
+import type { Bucket } from "#arrange/domain/types";
 /**
  * Secondary sort inside the **composite** bucket: opacity / blend / isolation →
  * 3D context → 3D transforms → 2D transforms → filters → will-change.

package/dist/arrange/domain/token-classifier.js

@@ -1,5 +1,5 @@
-import { COMPATIBLE_BUCKET_SETS, RESPONSIVE_PREFIX, STATE_PREFIXES } from "#/arrange/domain/constants";
-import { indexOfFirstVariantColon, stripVariants } from "#/arrange/domain/tailwind-token";
+import { COMPATIBLE_BUCKET_SETS, RESPONSIVE_PREFIX, STATE_PREFIXES } from "#arrange/domain/constants";
+import { indexOfFirstVariantColon, stripVariants } from "#arrange/domain/tailwind-token";
 /**
  * Bare-token classification is **total** (always returns a {@link Bucket}). The `Result` pattern
  * (`isOk` / `isErr`) belongs at arrange use-case / I/O boundaries, not on this hot path.

package/dist/arrange/domain/types.d.ts

@@ -7,9 +7,9 @@
  *
  * `arbitrary` and `other` are non-pipeline tails for `[prop:value]` syntax and unknown utilities.
  */
-import type { DomainAstNode, DomainCallExpression, DomainSourceFile, DomainTailwindClassLiteral } from "#/arrange/domain/ast/ast-node";
-import type { GroupFileWorkPlan } from "#/arrange/domain/grouping-service";
-import type { CodefastConfig } from "#/core/config/schema";
+import type { DomainAstNode, DomainCallExpression, DomainSourceFile, DomainTailwindClassLiteral } from "#arrange/domain/ast/ast-node";
+import type { GroupFileWorkPlan } from "#arrange/domain/grouping-service";
+import type { CodefastConfig } from "#core/config/schema";
 /**
  * The render-pipeline bucket a Tailwind token classifies into.
  *

package/dist/arrange/group/cli-result.d.ts

@@ -0,0 +1,7 @@
+import type { ArrangeSuggestGroupsOutput } from "#arrange/domain/types";
+/**
+ * Machine-readable `arrange group` suggestion for `--json`.
+ *
+ * @since 0.11.0
+ */
+export declare function formatArrangeGroupJsonOutput(output: ArrangeSuggestGroupsOutput): string;

package/dist/arrange/group/cli-result.js

@@ -0,0 +1,12 @@
+/**
+ * Machine-readable `arrange group` suggestion for `--json`.
+ *
+ * @since 0.11.0
+ */
+export function formatArrangeGroupJsonOutput(output) {
+    return JSON.stringify({
+        schemaVersion: 1,
+        primaryLine: output.primaryLine,
+        bucketsCommentLine: output.bucketsCommentLine,
+    });
+}

package/dist/arrange/group/cli-schema.d.ts

@@ -0,0 +1,17 @@
+import * as z from "zod";
+/**
+ * The request payload for `arrange group`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ArrangeSuggestGroupsRequest = {
+    inlineClasses: string;
+    emitTvStyleArray: boolean;
+    trailingClassName: boolean;
+};
+/**
+ * The `zod` schema validating an `arrange group` request.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const arrangeSuggestGroupsRequestSchema: z.ZodType<ArrangeSuggestGroupsRequest>;

package/dist/arrange/group/cli-schema.js

@@ -0,0 +1,13 @@
+import * as z from "zod";
+/**
+ * The `zod` schema validating an `arrange group` request.
+ *
+ * @since 0.3.16-canary.0
+ */
+export const arrangeSuggestGroupsRequestSchema = z.object({
+    inlineClasses: z
+        .string()
+        .min(1, 'Pass a class string. Example: codefast arrange group "flex gap-2 text-sm rounded-md"'),
+    emitTvStyleArray: z.boolean(),
+    trailingClassName: z.boolean(),
+});

package/dist/arrange/group/output.d.ts

@@ -0,0 +1,7 @@
+import type { ArrangeSuggestGroupsOutput } from "#arrange/domain/types";
+/**
+ * Presents the suggested grouping lines for an `arrange group` run.
+ *
+ * @since 0.11.0
+ */
+export declare function presentArrangeGroupResult(output: ArrangeSuggestGroupsOutput): void;

package/dist/arrange/group/output.js

@@ -0,0 +1,10 @@
+import { logger } from "#core/logger";
+/**
+ * Presents the suggested grouping lines for an `arrange group` run.
+ *
+ * @since 0.11.0
+ */
+export function presentArrangeGroupResult(output) {
+    logger.out(output.primaryLine);
+    logger.out(output.bucketsCommentLine);
+}

package/dist/arrange/group/suggest.d.ts

@@ -0,0 +1,8 @@
+import type { ArrangeSuggestGroupsOutput } from "#arrange/domain/types";
+import type { ArrangeSuggestGroupsRequest } from "#arrange/group/cli-schema";
+/**
+ * Formats the suggested grouping for an inline class string as `arrange group` output lines.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function suggestCnGroupsFromCli(request: ArrangeSuggestGroupsRequest): ArrangeSuggestGroupsOutput;

package/dist/arrange/{suggest.js → group/suggest.js}

@@ -1,5 +1,5 @@
-import { suggestCnGroups, summarizeGroupBucketLabels } from "#/arrange/domain/grouping";
-import { formatArray, formatCnCall } from "#/arrange/domain/source-text-formatters";
+import { suggestCnGroups, summarizeGroupBucketLabels } from "#arrange/domain/grouping";
+import { formatArray, formatCnCall } from "#arrange/domain/source-text-formatters";
 /**
  * Formats the suggested grouping for an inline class string as `arrange group` output lines.
  *

package/dist/arrange/inspect/cli-result.d.ts

@@ -0,0 +1,7 @@
+import type { AnalyzeReport } from "#arrange/domain/types";
+/**
+ * Machine-readable `arrange inspect` report for `--json`.
+ *
+ * @since 0.11.0
+ */
+export declare function formatArrangeAnalyzeJsonOutput(analyzeRootPath: string, report: AnalyzeReport): string;

package/dist/arrange/inspect/cli-result.js

@@ -0,0 +1,8 @@
+/**
+ * Machine-readable `arrange inspect` report for `--json`.
+ *
+ * @since 0.11.0
+ */
+export function formatArrangeAnalyzeJsonOutput(analyzeRootPath, report) {
+    return JSON.stringify({ schemaVersion: 1, analyzeRootPath, report });
+}

package/dist/arrange/inspect/cli-schema.d.ts

@@ -0,0 +1,15 @@
+import * as z from "zod";
+/**
+ * The request payload for `arrange inspect`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ArrangeAnalyzeDirectoryRequest = {
+    analyzeRootPath: string;
+};
+/**
+ * The `zod` schema validating an `arrange inspect` request.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const arrangeAnalyzeDirectoryRequestSchema: z.ZodType<ArrangeAnalyzeDirectoryRequest>;

package/dist/arrange/inspect/cli-schema.js

@@ -0,0 +1,9 @@
+import * as z from "zod";
+/**
+ * The `zod` schema validating an `arrange inspect` request.
+ *
+ * @since 0.3.16-canary.0
+ */
+export const arrangeAnalyzeDirectoryRequestSchema = z.object({
+    analyzeRootPath: z.string().min(1, "analyzeRootPath is required"),
+});

package/dist/arrange/{domain → inspect/domain}/analyze-service.d.ts

@@ -2,8 +2,8 @@
  * 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 { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
-import type { AnalyzeReport } from "#/arrange/domain/types";
+import type { DomainSourceFile } from "#arrange/domain/ast/ast-node";
+import type { AnalyzeReport } from "#arrange/domain/types";
 /**
  * Creates a zeroed analyze report ready for accumulation.
  *

package/dist/arrange/{domain → inspect/domain}/analyze-service.js

@@ -2,13 +2,13 @@
  * 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 { isDomainCallExpression, isDomainJsxAttribute, isDomainObjectLiteralExpression, forEachDomainChild, } from "#/arrange/domain/ast/ast-node";
-import { forEachStringLiteralInClassExpression } from "#/arrange/domain/ast/collectors-cn";
-import { jsxClassNameStaticLiteral } from "#/arrange/domain/ast/collectors-jsx";
-import { collectCnCallsInsideTv, traverseTvObject } from "#/arrange/domain/ast/collectors-tv";
-import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf } from "#/arrange/domain/ast/helpers";
-import { LONG_STRING_TOKEN_THRESHOLD } from "#/arrange/domain/constants";
-import { tokenizeClassString } from "#/arrange/domain/tailwind-token";
+import { isDomainCallExpression, isDomainJsxAttribute, isDomainObjectLiteralExpression, forEachDomainChild, } from "#arrange/domain/ast/ast-node";
+import { forEachStringLiteralInClassExpression } from "#arrange/domain/ast/collectors-cn";
+import { jsxClassNameStaticLiteral } from "#arrange/domain/ast/collectors-jsx";
+import { collectCnCallsInsideTv, traverseTvObject } from "#arrange/domain/ast/collectors-tv";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, lineOf } from "#arrange/domain/ast/helpers";
+import { LONG_STRING_TOKEN_THRESHOLD } from "#arrange/domain/constants";
+import { tokenizeClassString } from "#arrange/domain/tailwind-token";
 const PREVIEW_MAX_LENGTH = 72;
 function previewText(text) {
     return text.length > PREVIEW_MAX_LENGTH ? `${text.slice(0, PREVIEW_MAX_LENGTH)}…` : text;

package/dist/arrange/inspect/output.d.ts

@@ -0,0 +1,7 @@
+import type { AnalyzeReport } from "#arrange/domain/types";
+/**
+ * Presents the human-readable summary of an `arrange inspect` report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function presentAnalyzeReport(resolvedTargetPath: string, report: AnalyzeReport): void;

package/dist/arrange/inspect/output.js

@@ -0,0 +1,42 @@
+import path from "node:path";
+import { LONG_STRING_TOKEN_THRESHOLD, MAX_REPORT_LINES } from "#arrange/domain/constants";
+import { logger } from "#core/logger";
+/**
+ * Presents the human-readable summary of an `arrange inspect` report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export function presentAnalyzeReport(resolvedTargetPath, report) {
+    logger.out(`Path: ${path.resolve(resolvedTargetPath)}`);
+    logger.out(`.ts/.tsx files: ${report.files}`);
+    logger.out(`cn(...) call sites: ${report.cnCallExpressions}`);
+    logger.out(`tv(...) call sites: ${report.tvCallExpressions}`);
+    logger.out(`\nLong cn(...) string literals (≥${LONG_STRING_TOKEN_THRESHOLD} tokens — consider splitting arguments): ${report.longCnStringLiterals.length}`);
+    for (const findingEntry of report.longCnStringLiterals.slice(0, MAX_REPORT_LINES)) {
+        logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+    }
+    if (report.longCnStringLiterals.length > MAX_REPORT_LINES) {
+        logger.out(`  … and ${report.longCnStringLiterals.length - MAX_REPORT_LINES} more`);
+    }
+    logger.out(`\nLong tv({...}) string literals in base/variants/… (≥${LONG_STRING_TOKEN_THRESHOLD} tokens): ${report.longTvStringLiterals.length}`);
+    for (const findingEntry of report.longTvStringLiterals.slice(0, MAX_REPORT_LINES)) {
+        logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+    }
+    if (report.longTvStringLiterals.length > MAX_REPORT_LINES) {
+        logger.out(`  … and ${report.longTvStringLiterals.length - MAX_REPORT_LINES} more`);
+    }
+    logger.out(`\nJSX className="..." or className={'...'} (static strings, ≥${LONG_STRING_TOKEN_THRESHOLD} tokens): ${report.longJsxClassNameLiterals.length}`);
+    for (const findingEntry of report.longJsxClassNameLiterals.slice(0, MAX_REPORT_LINES)) {
+        logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.tokenCount} tokens)  ${findingEntry.preview}`);
+    }
+    if (report.longJsxClassNameLiterals.length > MAX_REPORT_LINES) {
+        logger.out(`  … and ${report.longJsxClassNameLiterals.length - MAX_REPORT_LINES} more`);
+    }
+    logger.out(`\ncn(...) nested inside tv({...}) (prefer a string or array — preview/apply can rewrite): ${report.cnInsideTvCalls.length}`);
+    for (const findingEntry of report.cnInsideTvCalls.slice(0, MAX_REPORT_LINES)) {
+        logger.out(`  ${findingEntry.file}:${findingEntry.line}  (${findingEntry.argCount} args)  ${findingEntry.preview}`);
+    }
+    if (report.cnInsideTvCalls.length > MAX_REPORT_LINES) {
+        logger.out(`  … and ${report.cnInsideTvCalls.length - MAX_REPORT_LINES} more`);
+    }
+}

package/dist/arrange/inspect/run.d.ts

@@ -0,0 +1,10 @@
+import type { AnalyzeReport } from "#arrange/domain/types";
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+/**
+ * Scans a directory's arrange targets and returns the accumulated analyze report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runArrangeInspect(fs: Filesystem, analyzeRootPath: string): Result<AnalyzeReport, AppError>;

package/dist/arrange/{analyze.js → inspect/run.js}

@@ -1,15 +1,15 @@
-import { accumulateAnalyzeReportForSourceFile, createEmptyAnalyzeReport } from "#/arrange/domain/analyze-service";
-import { scanArrangeTargets } from "#/arrange/scan-target";
-import { parseDomainSourceFile } from "#/arrange/source-parse";
-import { AppError } from "#/core/errors";
-import { messageFrom } from "#/core/errors";
-import { err, ok } from "#/core/result";
+import { accumulateAnalyzeReportForSourceFile, createEmptyAnalyzeReport, } from "#arrange/inspect/domain/analyze-service";
+import { scanArrangeTargets } from "#arrange/scan-target";
+import { parseDomainSourceFile } from "#arrange/source-parse";
+import { AppError } from "#core/errors";
+import { messageFrom } from "#core/errors";
+import { err, ok } from "#core/result";
 /**
  * Scans a directory's arrange targets and returns the accumulated analyze report.
  *
  * @since 0.3.16-canary.0
  */
-export function analyzeDirectory(fs, analyzeRootPath) {
+export function runArrangeInspect(fs, analyzeRootPath) {
     const report = createEmptyAnalyzeReport();
     try {
         const files = scanArrangeTargets(fs, analyzeRootPath);

package/dist/arrange/prepare.d.ts

@@ -0,0 +1,13 @@
+import type { ArrangeTargetWorkspaceAndConfig } from "#arrange/domain/types";
+import { AppError } from "#core/errors";
+import type { Filesystem } from "#core/filesystem/filesystem";
+import type { Result } from "#core/result";
+/**
+ * Resolves the arrange target, repo root, and loaded config an arrange run needs.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function prepareArrangeWorkspace(fs: Filesystem, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<ArrangeTargetWorkspaceAndConfig, AppError>>;