@codefast/cli 0.10.0 → 0.11.0

package/CHANGELOG.md

@@ -1,5 +1,38 @@
 # @codefast/cli
 
+## 0.11.0
+
+### Minor Changes
+
+- [#855](https://github.com/codefastlabs/codefast/pull/855) [`76cf7a6`](https://github.com/codefastlabs/codefast/commit/76cf7a65372c5f13f779c7b59200cb956d93b882) Thanks [@thevuong](https://github.com/thevuong)! - Fix `codefast arrange simplify` changing rendered output: a mixed `cn()` call moved every static literal to the front,
+  which flipped tailwind-merge precedence and dropped overrides that sat after a variant call. It now coalesces only
+  adjacent static literals and preserves argument order.
+
+  Add `codefast arrange simplify --fold-variant-classname` (alias `--fold-variant-class-name`), which folds
+  `cn(buttonVariants({ size: "sm" }), "flex-1")` into `buttonVariants({ size: "sm", className: "flex-1" })`. The fold is
+  gated on the native TypeScript type server confirming the callee accepts a `className`/`class`, so it loads the
+  `typescript` package (a new optional peer, v7) and applies only inside a `tsconfig`; the default pass is unchanged.
+
+  The fold splices `className` in after the last option, so a trailing comma or line comment in the options object no
+  longer breaks the rewrite. Overlapping edits are now resolved before they are applied — keeping the outermost of any
+  nested `cn()`/variant pair — so nested calls no longer corrupt the output.
+
+- [#854](https://github.com/codefastlabs/codefast/pull/854) [`a7ad2d8`](https://github.com/codefastlabs/codefast/commit/a7ad2d8b24b10b5554a5809be943aca00e22e844) Thanks [@thevuong](https://github.com/thevuong)! - `codefast audit imports` now enforces the Zod namespace form (`import * as z from "zod"`) in every workspace package,
+  not only the front-end/bundled ones. The rule's `scope` restriction is dropped, so a named `import { z } from "zod"` is
+  flagged everywhere — backend/tsc packages such as `cli` itself included. Type-only imports
+  (`import type { ZodType } from "zod"`) stay allowed; only the value `z` is banned.
+
+### Patch Changes
+
+- [#855](https://github.com/codefastlabs/codefast/pull/855) [`9e481c5`](https://github.com/codefastlabs/codefast/commit/9e481c554b7f60216b130495fd157fe3a459721e) Thanks [@thevuong](https://github.com/thevuong)! - Fix `codefast arrange --dry-run --json` printing human-readable preview lines to stdout ahead of the JSON summary, which
+  broke piping the output to a JSON parser. Dry-run previews are now emitted only in human mode; `--json` writes a single
+  JSON object.
+
+- [#854](https://github.com/codefastlabs/codefast/pull/854) [`504a61a`](https://github.com/codefastlabs/codefast/commit/504a61a996684fbd4fb6703141612d3cd97dbfde) Thanks [@thevuong](https://github.com/thevuong)! - Reorganize the CLI source into a uniform per-command and per-subcommand directory layout. Each command follows one
+  skeleton (`command.ts`, `cli-schema.ts`, `prepare.ts`, `run*.ts`, `output.ts`, `cli-result.ts`, `domain/`), and every
+  `audit`/`arrange` subcommand is now its own mini-command directory (`audit/rtl/`, `arrange/inspect/`, …) with the shared
+  runner and grouping engine kept at the command root. Internal refactor only — no public API or behavior change.
+
 ## 0.10.0
 
 ### Minor Changes

package/README.md

@@ -125,7 +125,7 @@ Long static JSX `className` strings are regrouped regardless of where `cn` comes
 | `--dry-run`          | Preview suggested replacements without writing files.                         |
 | `--with-classname`   | Append `className` as the final `cn()` argument (alias: `--with-class-name`). |
 | `--cn-import <spec>` | Override the module specifier used when a missing `cn` import is added.       |
-| `--json`             | Print one JSON object on stdout (suppresses human progress).                  |
+| `--json`             | Print one JSON summary on stdout (suppresses human progress).                 |
 
 Exits `1` when the `arrange.onAfterWrite` hook fails, `0` otherwise.
 
@@ -136,7 +136,21 @@ Read-only report of long strings, nested `cn` inside `tv()`, and related finding
 ### `arrange simplify [target]`
 
 Flattens grouped arrays and static-only `cn()` calls back to plain strings in `tv()` slots — the inverse cleanup pass.
-Accepts `--dry-run` and `--json`.
+In a mixed `cn()` call it coalesces only _adjacent_ static literals and keeps argument order, so tailwind-merge
+precedence is unchanged (a later argument still overrides an earlier one).
+
+| Flag                       | Description                                                                                              |
+| -------------------------- | -------------------------------------------------------------------------------------------------------- |
+| `--dry-run`                | Show what simplify would change without writing files.                                                   |
+| `--fold-variant-classname` | Fold `cn()` overrides into a variant function's `className` option (alias: `--fold-variant-class-name`). |
+| `--json`                   | Print one JSON summary on stdout.                                                                        |
+
+With `--fold-variant-classname`, `cn(buttonVariants({ size: "sm" }), "flex-1")` becomes
+`buttonVariants({ size: "sm", className: "flex-1" })`, and a dynamic or multi-part override folds into a `className`
+array. The fold fires only when the native TypeScript type server confirms the callee's options accept a `className` (or
+`class`) of the right shape, so it loads the `typescript` package (an optional peer, v7) and needs the target inside a
+`tsconfig`; files outside a project keep the base pass. Run a formatter afterward — a folded call can exceed the print
+width until it is wrapped.
 
 ### `arrange group <tokens...>`
 

package/dist/arrange/command.js

@@ -1,18 +1,96 @@
-import process from "node:process";
 import { Command } from "commander";
-import { analyzeDirectory } from "#/arrange/analyze";
-import { arrangeAnalyzeDirectoryRequestSchema, arrangeSuggestGroupsRequestSchema, arrangeSyncRunRequestSchema, } from "#/arrange/cli-schema";
-import { printAnalyzeReport, printGroupFilePreviewFromWork, printSimplifyResult, printSyncResult, } from "#/arrange/output";
-import { runArrangeSimplify } from "#/arrange/simplify-sync";
-import { suggestCnGroupsFromCli } from "#/arrange/suggest";
-import { runArrangeSync } from "#/arrange/sync";
-import { prepareArrangeWorkspace } from "#/arrange/workspace";
-import { readOptionalPositionalArg } from "#/core/cli/positional";
-import { consumeCliAppError, runCliResultAsync } from "#/core/cli/result-handle";
-import { CLI_EXIT_GENERAL_ERROR, CLI_EXIT_SUCCESS } from "#/core/exit-codes";
+import { formatArrangeGroupJsonOutput } from "#/arrange/group/cli-result";
+import { arrangeSuggestGroupsRequestSchema } from "#/arrange/group/cli-schema";
+import { presentArrangeGroupResult } from "#/arrange/group/output";
+import { suggestCnGroupsFromCli } from "#/arrange/group/suggest";
+import { formatArrangeAnalyzeJsonOutput } from "#/arrange/inspect/cli-result";
+import { arrangeAnalyzeDirectoryRequestSchema } from "#/arrange/inspect/cli-schema";
+import { presentAnalyzeReport } from "#/arrange/inspect/output";
+import { runArrangeInspect } from "#/arrange/inspect/run";
+import { prepareArrangeWorkspace } from "#/arrange/prepare";
+import { exitCodeForArrangeResult, formatArrangeJsonOutput } from "#/arrange/regroup/cli-result";
+import { arrangeRunRequestSchema } from "#/arrange/regroup/cli-schema";
+import { presentArrangeResult, presentGroupFilePreviewFromWork } from "#/arrange/regroup/output";
+import { runArrange } from "#/arrange/regroup/run";
+import { formatArrangeSimplifyJsonOutput } from "#/arrange/simplify/cli-result";
+import { arrangeSimplifyRunRequestSchema } from "#/arrange/simplify/cli-schema";
+import { presentSimplifyResult } from "#/arrange/simplify/output";
+import { runArrangeSimplify } from "#/arrange/simplify/run";
+import { applyCommandPipeline, registerPipelineSubcommand } from "#/core/cli/command-pipeline";
+import { consumeCliAppError } from "#/core/cli/result-handle";
+import { CLI_EXIT_SUCCESS } from "#/core/exit-codes";
 import { nodeFilesystem } from "#/core/filesystem/node";
 import { logger } from "#/core/logger";
 import { parseWithSchema } from "#/core/schema-parse";
+const targetHelp = "Directory or file (default: nearest package directory from cwd)";
+const prepareWorkspace = (fs, input) => prepareArrangeWorkspace(fs, { currentWorkingDirectory: input.currentWorkingDirectory, rawTarget: input.rawArg });
+const regroupPipeline = {
+    positional: { name: "[target]", help: targetHelp },
+    schema: arrangeRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Preview suggested replacements without writing files", false);
+        command.option("--with-classname, --with-class-name", "Append className as final cn() argument", false);
+        command.option("--cn-import <spec>", "Override module specifier when adding cn import");
+    },
+    prepare: prepareWorkspace,
+    buildRequest: ({ prelude, opts }) => ({
+        rootDir: prelude.rootDir,
+        targetPath: prelude.resolvedTarget,
+        write: !opts.dryRun,
+        withClassName: opts.withClassName,
+        cnImport: opts.cnImport,
+        config: prelude.config.arrange ?? {},
+    }),
+    run: (fs, request) => runArrange(fs, request),
+    presentHuman: ({ result, opts }) => {
+        // Dry-run previews are human-only; the --json summary omits the non-serializable plans.
+        if (opts.dryRun) {
+            for (const plan of result.previewPlans) {
+                presentGroupFilePreviewFromWork(plan);
+            }
+        }
+        presentArrangeResult(result, !opts.dryRun);
+    },
+    formatJson: ({ result, opts }) => formatArrangeJsonOutput(result, !opts.dryRun),
+    exitCode: exitCodeForArrangeResult,
+};
+const inspectPipeline = {
+    name: "inspect",
+    description: "Report long strings, nested cn in tv(), and related findings (read-only)",
+    positional: { name: "[target]", help: targetHelp },
+    jsonHelp: "Print one JSON object on stdout instead of a human report",
+    schema: arrangeAnalyzeDirectoryRequestSchema,
+    prepare: prepareWorkspace,
+    buildRequest: ({ prelude }) => ({ analyzeRootPath: prelude.resolvedTarget }),
+    run: async (fs, request) => runArrangeInspect(fs, request.analyzeRootPath),
+    presentHuman: ({ result, prelude }) => {
+        presentAnalyzeReport(prelude.resolvedTarget, result);
+    },
+    formatJson: ({ result, prelude }) => formatArrangeAnalyzeJsonOutput(prelude.resolvedTarget, result),
+    exitCode: () => CLI_EXIT_SUCCESS,
+};
+const simplifyPipeline = {
+    name: "simplify",
+    description: "Flatten grouped arrays and static-only cn() calls back to plain strings in tv() slots",
+    positional: { name: "[target]", help: targetHelp },
+    schema: arrangeSimplifyRunRequestSchema,
+    configureArgv: (command) => {
+        command.option("--dry-run", "Show what simplify would change without writing files", false);
+        command.option("--fold-variant-classname, --fold-variant-class-name", "Fold cn() overrides into a variant function's className option (uses the TypeScript type server)", false);
+    },
+    prepare: prepareWorkspace,
+    buildRequest: ({ prelude, opts }) => ({
+        targetPath: prelude.resolvedTarget,
+        write: !opts.dryRun,
+        foldVariantClassName: opts.foldVariantClassName,
+    }),
+    run: (fs, request) => runArrangeSimplify(fs, request),
+    presentHuman: ({ result, opts }) => {
+        presentSimplifyResult(result, !opts.dryRun);
+    },
+    formatJson: ({ result, opts }) => formatArrangeSimplifyJsonOutput(result, !opts.dryRun),
+    exitCode: () => CLI_EXIT_SUCCESS,
+};
 /**
  * Creates the `arrange` command and its subcommands.
  *
@@ -23,103 +101,12 @@ export function createArrangeCommand() {
         .description("Regroup Tailwind classes in cn() / tv() calls in render-pipeline order")
         // The parent action shares option names (--json) with subcommands; positional
         // options ensure tokens after a subcommand bind to that subcommand, not the parent.
-        .enablePositionalOptions()
-        .argument("[target]", "Directory or file (default: nearest package directory from cwd)")
-        .option("--dry-run", "Preview suggested replacements without writing files", false)
-        .option("--with-classname, --with-class-name", "Append className as final cn() argument", false)
-        .option("--cn-import <spec>", "Override module specifier when adding cn import")
-        .option("--json", "Print one JSON object on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const write = !opts.dryRun;
-        const prelude = await prepareArrangeWorkspace(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { resolvedTarget, rootDir, config } = prelude.value;
-        const parsed = parseWithSchema(arrangeSyncRunRequestSchema, {
-            rootDir,
-            targetPath: resolvedTarget,
-            write,
-            withClassName: opts.withClassName,
-            cnImport: opts.cnImport,
-            config: config.arrange ?? {},
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        await runCliResultAsync(runArrangeSync(nodeFilesystem, parsed.value), (value) => {
-            if (!write) {
-                for (const plan of value.previewPlans) {
-                    printGroupFilePreviewFromWork(plan);
-                }
-            }
-            if (opts.json) {
-                logger.out(formatArrangeSyncJsonOutput(value, write));
-                return exitCodeForArrangeSyncResult(value);
-            }
-            printSyncResult(value, write);
-            return exitCodeForArrangeSyncResult(value);
-        });
-    });
-    cmd
-        .command("inspect")
-        .description("Report long strings, nested cn in tv(), and related findings (read-only)")
-        .argument("[target]", "Directory or file (default: nearest package directory from cwd)")
-        .option("--json", "Print one JSON object on stdout instead of a human report", false)
-        .action(async (target, opts) => {
-        const prelude = await prepareArrangeWorkspace(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { resolvedTarget } = prelude.value;
-        const parsed = parseWithSchema(arrangeAnalyzeDirectoryRequestSchema, {
-            analyzeRootPath: resolvedTarget,
-        });
-        if (!consumeCliAppError(parsed)) {
-            return;
-        }
-        const outcome = analyzeDirectory(nodeFilesystem, parsed.value.analyzeRootPath);
-        if (!consumeCliAppError(outcome)) {
-            return;
-        }
-        if (opts.json) {
-            logger.out(formatArrangeAnalyzeJsonOutput(resolvedTarget, outcome.value));
-        }
-        else {
-            printAnalyzeReport(resolvedTarget, outcome.value);
-        }
-    });
-    cmd
-        .command("simplify")
-        .description("Flatten grouped arrays and static-only cn() calls back to plain strings in tv() slots")
-        .argument("[target]", "Directory or file (default: nearest package directory from cwd)")
-        .option("--dry-run", "Show what simplify would change without writing files", false)
-        .option("--json", "Print one JSON object on stdout (suppresses human progress)", false)
-        .action(async (target, opts) => {
-        const write = !opts.dryRun;
-        const prelude = await prepareArrangeWorkspace(nodeFilesystem, {
-            currentWorkingDirectory: process.cwd(),
-            rawTarget: readOptionalPositionalArg(target),
-        });
-        if (!consumeCliAppError(prelude)) {
-            return;
-        }
-        const { resolvedTarget } = prelude.value;
-        await runCliResultAsync(runArrangeSimplify(nodeFilesystem, { targetPath: resolvedTarget, write }), (value) => {
-            if (opts.json) {
-                logger.out(JSON.stringify({ schemaVersion: 1, ok: true, write, result: value }));
-                return CLI_EXIT_SUCCESS;
-            }
-            printSimplifyResult(value, write);
-            return CLI_EXIT_SUCCESS;
-        });
-    });
+        .enablePositionalOptions();
+    applyCommandPipeline(cmd, nodeFilesystem, regroupPipeline);
+    registerPipelineSubcommand(cmd, nodeFilesystem, inspectPipeline);
+    registerPipelineSubcommand(cmd, nodeFilesystem, simplifyPipeline);
+    // `group` is a pure token-string transform — no workspace prelude, a variadic positional — so it
+    // does not fit the workspace pipeline and stays wired by hand.
     cmd
         .command("group")
         .description("Try grouping on a pasted class string (stdout: cn(...) or tv array with --tv)")
@@ -141,31 +128,8 @@ export function createArrangeCommand() {
             logger.out(formatArrangeGroupJsonOutput(output));
         }
         else {
-            logger.out(output.primaryLine);
-            logger.out(output.bucketsCommentLine);
+            presentArrangeGroupResult(output);
         }
     });
     return cmd;
-}
-function formatArrangeAnalyzeJsonOutput(analyzeRootPath, report) {
-    return JSON.stringify({ schemaVersion: 1, analyzeRootPath, report });
-}
-function formatArrangeSyncJsonOutput(result, write) {
-    const { previewPlans: _plans, ...serializableResult } = result;
-    return JSON.stringify({
-        schemaVersion: 1,
-        ok: result.hookError === null,
-        write,
-        result: serializableResult,
-    });
-}
-function formatArrangeGroupJsonOutput(output) {
-    return JSON.stringify({
-        schemaVersion: 1,
-        primaryLine: output.primaryLine,
-        bucketsCommentLine: output.bucketsCommentLine,
-    });
-}
-function exitCodeForArrangeSyncResult(result) {
-    return result.hookError !== null ? CLI_EXIT_GENERAL_ERROR : CLI_EXIT_SUCCESS;
 }

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

@@ -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/{typescript-ast-translator.d.ts → domain/ast/translator.d.ts}

@@ -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}

@@ -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/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/{suggest.d.ts → group/suggest.d.ts}

@@ -1,5 +1,5 @@
-import type { ArrangeSuggestGroupsRequest } from "#/arrange/cli-schema";
 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.
  *

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/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;