@codefast/cli 0.9.0 → 0.10.0

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

@@ -0,0 +1,111 @@
+import type { Bucket } from "#/arrange/domain/types";
+/**
+ * Analyze report: long literal threshold (token count).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const LONG_STRING_TOKEN_THRESHOLD = 18;
+/**
+ * Minimum token count for a string to be considered a candidate for grouping
+ * in the apply/preview pipeline. Intentionally much lower than
+ * {@link LONG_STRING_TOKEN_THRESHOLD} (analyze only).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const APPLY_MIN_TOKENS = 2;
+/**
+ * Minimum tokens a group must have to stand alone before singleton-merging.
+ * Set to 2 so single-token groups are not collapsed into unrelated buckets by the merger.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MIN_GROUP_TOKENS = 2;
+/**
+ * Dynamic max groups clamp: base bound.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_GROUPS_BASE = 4;
+/**
+ * Dynamic max groups clamp: upper cap.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_GROUPS_CAP = 24;
+/**
+ * Extra slots so a few state / aria groups do not force `capGroups` to merge
+ * unrelated buckets (e.g. `bg-border` + `outline-hidden`).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_GROUPS_HEADROOM = 2;
+/**
+ * Maximum findings printed per category in the analyze report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_REPORT_LINES = 40;
+/**
+ * Maximum recursion depth when traversing `tv()` object literals.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_OBJECT_DEPTH = 12;
+/**
+ * Maximum depth when peeling conditional / parens / arrays inside `cn(...)` args.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_CLASS_EXPR_DEPTH = 12;
+/**
+ * Maximum variant-stripping passes in {@link stripVariants}.
+ * Real-world Tailwind stacks rarely exceed 4–5 segments (e.g. `@md/sidebar:group-hover:dark:focus-visible:`);
+ * 12 is a conservative safety cap that prevents runaway loops on malformed input.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const MAX_STRIP_VARIANT_PASSES = 12;
+/**
+ * Passed when optional `knownBindings` is missing — size 0 disables matching
+ * for `cn` / `tv` identifier resolution.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const EMPTY_CN_TV_BINDINGS: Set<string>;
+/**
+ * Bucket sort order — **render pipeline** (lower → earlier in `cn()` output).
+ *
+ * Matches README: Existence → Position → Layout → Sizing → Spacing → Shape → Background
+ * → Shadow → Typography → Composite → Motion → Starting → Behavior → State → Selector,
+ * then `other` and `arbitrary` as sort tails for unknown utilities and arbitrary properties.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const BUCKET_ORDER: Record<Bucket, number>;
+/**
+ * Compatible bucket **pairs** — two adjacent tokens whose buckets appear in the same
+ * `Set` may stay in one `cn()` string chunk. Compatibility is **not transitive**: there is
+ * no `{position, sizing}` pair, so `fixed inset-0` and `overflow-auto` become **separate**
+ * literals unless **layout** tokens sit between them in sorted order; then
+ * `position↔layout` and `layout↔sizing` each justify one hop and the whole “box in flow”
+ * (place + tracks + scrollport) stays in one chunk — co-located because they jointly define
+ * stacking and scroll behavior for the same surface.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const COMPATIBLE_BUCKET_SETS: ReadonlyArray<ReadonlySet<Bucket>>;
+/**
+ * Responsive / variant prefix — Tailwind v4 aware.
+ *
+ * v3: sm: md: … — v4: `@sm:`, `@min-[600px]:`, `@[480px]:`, named `@md/sidebar:`,
+ * viewport md/sidebar:, min-[100px]: / max-[100px]:, …
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const RESPONSIVE_PREFIX: RegExp;
+/**
+ * State variant stems — hoisted to module scope (not recreated per call).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare const STATE_PREFIXES: ReadonlySet<string>;

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

@@ -0,0 +1,100 @@
+/**
+ * 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";
+/**
+ * A planned replacement unwrapping one `cn()` call nested in `tv({ ... })`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type GroupFileUnwrapPlan = {
+    readonly start: number;
+    readonly end: number;
+    readonly replacement: string;
+    readonly call: DomainCallExpression;
+};
+type GroupFileUnwrapState = {
+    readonly cnInTvCalls: ReadonlyArray<DomainCallExpression>;
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: ReadonlyArray<GroupFileUnwrapPlan>;
+    readonly textAfterUnwrap: string;
+    readonly cnInTvNoReplacement: number;
+};
+/**
+ * The complete per-file plan of unwrap and grouping edits, plus the totals reported for them.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type GroupFileWorkPlan = {
+    readonly filePath: string;
+    readonly sourceText: string;
+    readonly textAfterUnwrap: string;
+    readonly domainSfForLineNumbers: DomainSourceFile;
+    readonly domainSfGrouped: DomainSourceFile;
+    readonly cnInTvCalls: ReadonlyArray<DomainCallExpression>;
+    readonly unwrapReplacementByCall: ReadonlyMap<DomainCallExpression, string>;
+    readonly unwrapEdits: ReadonlyArray<GroupFileUnwrapPlan>;
+    readonly plannedGroupEdits: ReadonlyArray<PlannedGroupEdit>;
+    readonly cnInTvNoReplacement: number;
+    readonly reportTotal: number;
+    readonly editSitesCount: number;
+};
+/**
+ * Builds the unwrap phase's state — cn-in-tv calls, their replacements, and the text after unwrapping.
+ *
+ * @since 0.3.16-canary.0
+ */
+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.
+ *
+ * @since 0.3.16-canary.0
+ */
+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;
+/**
+ * Creates the empty per-file result for a dry run with nothing to edit.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFileDryRunNoEdits(filePath: string): GroupFileResult;
+/**
+ * Derives the preview-mode per-file result from a work plan's report total.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFilePreviewTotals(work: GroupFileWorkPlan): GroupFileResult;
+/**
+ * Applies a work plan's grouping edits to the unwrapped text and returns the merged file body.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function mergeGroupFileBodyText(work: GroupFileWorkPlan): string;
+/**
+ * Checks whether any planned edit rewrites a JSX `className` into a `cn()` call.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFileEditsTouchJsxCn(work: GroupFileWorkPlan): boolean;
+/**
+ * Counts the edits a work plan writes in apply mode — unwraps plus grouping replacements.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function countPersistedGroupFileEdits(work: GroupFileWorkPlan): number;
+/**
+ * Checks whether a work plan has no edit sites and no skipped cn-in-tv calls to report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function groupFileWorkHasNothingToReport(work: GroupFileWorkPlan): boolean;
+export {};

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

@@ -0,0 +1,21 @@
+/**
+ * True when `staticLiteralTexts` carries the **same partition** of Tailwind tokens as
+ * `suggestedGroups` from {@link suggestCnGroups}, ignoring order of arguments and
+ * order of tokens within each chunk.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function areCnTailwindPartitionsEquivalent(staticLiteralTexts: Array<string>, suggestedGroups: Array<string>): boolean;
+/**
+ * Partitions a class string into render-pipeline-ordered groups, one per suggested `cn()` argument.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function suggestCnGroups(classString: string): Array<string>;
+/**
+ * One label per suggested group: a single bucket name, or `mixed:a+b` when that chunk
+ * spans multiple Tailwind buckets (matches `codefast arrange group` stdout).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function summarizeGroupBucketLabels(groups: Array<string>): Array<string>;

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

@@ -0,0 +1,14 @@
+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.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function dropCnImportIfUnused(sourceFile: DomainSourceFile): string;
+/**
+ * Returns the source text with a `cn` import present, adding one when the file lacks it.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function ensureCnImport(sourceFile: DomainSourceFile, cnImportOverride?: string): string;

package/dist/arrange/domain/source-text-formatters.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Escapes backslashes and double quotes for embedding in a double-quoted TypeScript string literal.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function escapeTsStringLiteralContent(group: string): string;
+/**
+ * Formats grouped class strings as a multiline `cn(...)` call.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatCnCall(groups: Array<string>, options?: {
+    trailingClassName?: boolean;
+}): string;
+/**
+ * Formats grouped class strings as a multiline array literal.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatArray(groups: Array<string>): string;
+/**
+ * Multiple string literals as sequential lines for insertion **inside** an existing array
+ * (e.g. `tv({ base: [ … ] })` — avoids `[[ "a", "b" ]]` when replacing one long string).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatArrayElementsAsSiblingLines(groups: Array<string>, continuationPrefix: string): string;
+/**
+ * Formats grouped class strings as a JSX attribute value wrapping a multiline `cn(...)` call.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function formatJsxCnAttributeValue(groups: Array<string>, source: string, valueNodeStart: number): string;

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

@@ -0,0 +1,24 @@
+/**
+ * Splits a class string into its whitespace-separated tokens.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function tokenizeClassString(classString: string): Array<string>;
+/**
+ * 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`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function indexOfFirstVariantColon(text: string): number;
+/**
+ * Strips every variant prefix off a token, leaving the bare utility name.
+ *
+ * @remarks
+ * `"hover:dark:md:text-sm"` → `"text-sm"`, `"@min-[600px]:flex"` → `"flex"`,
+ * `"[&_a:hover]:text-red-500"` → `"text-red-500"`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function stripVariants(token: string): string;

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

@@ -0,0 +1,47 @@
+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.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function compositeSecondaryOrder(bareUtility: string): number;
+/**
+ * Classifies a Tailwind token into its render-pipeline bucket.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function classifyToken(token: string): Bucket;
+/**
+ * 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).
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function stateKey(token: string): string;
+/**
+ * Variant key for {@link Bucket} `"selector"` tokens in {@link suggestCnGroups}.
+ * Reuses {@link stateKey} layer splitting, then normalizes common Radix SVG patterns so
+ * `[&_svg]:…` and `[&_svg:not([class*='size-'])]:…` stay in one chunk.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function selectorKey(token: string): string;
+/**
+ * Checks whether two buckets may share one group in a suggested partition.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function bucketsCompatible(a: Bucket, b: Bucket): boolean;
+/**
+ * Like {@link bucketsCompatible}, but never merge two distinct state / starting / selector variant blobs.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function bucketsMergeCompatible(a: Bucket, b: Bucket): boolean;

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

@@ -0,0 +1,208 @@
+/**
+ * Shared types for the arrange pipeline (Tailwind `cn()` / `tv()` tooling).
+ *
+ * **Render Pipeline Order**: Existence → Position → Layout
+ * → Sizing → Spacing → Shape → Background → Shadow → Typography → Composite → Motion
+ * → Starting → Behavior → State → Selector.
+ *
+ * `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";
+/**
+ * The render-pipeline bucket a Tailwind token classifies into.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type Bucket = "existence" | "position" | "layout" | "sizing" | "spacing" | "shape" | "background" | "shadow" | "typography" | "composite" | "motion" | "starting" | "behavior" | "state"
+/**
+ * Selector variants (e.g. `[&…]:`, `*:`, `has-*`) distinct from interactive/data state.
+ */
+ | "selector" | "arbitrary" | "other";
+/**
+ * String or no-substitution template literal used as a Tailwind class blob.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type TailwindClassLiteral = DomainTailwindClassLiteral;
+/**
+ * Options controlling which literals a class-expression walk visits.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ForEachStringLiteralInClassExpressionOptions = {
+    /**
+     * When `false`, do not visit literals inside `cond ? "a" : "b"`. Used when
+     * building the cn/tv **apply** pool so mutually exclusive branch classes are
+     * never merged into one static string (while `analyze` still uses the default).
+     */
+    descendIntoConditional?: boolean;
+};
+/**
+ * A static JSX `className` literal paired with the node to replace.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type JsxClassNameStatic = {
+    lit: TailwindClassLiteral;
+    /**
+     * Replace this node: `StringLiteral` or whole `JsxExpression`.
+     */
+    valueNode: DomainAstNode;
+};
+/**
+ * A StringNode represents a single "grouping slot" — the full set of static
+ * string literals that belong to one logical class surface.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type StringNode = {
+    /**
+     * All static string literals belonging to this slot, in source order.
+     */
+    nodes: Array<TailwindClassLiteral>;
+    sf: DomainSourceFile;
+    /**
+     * String slots in `tv({ ... })` that are not `cn(...)` arguments — use `formatArray` when
+     * replacing a whole array, or `formatArrayElementsAsSiblingLines` when replacing one element
+     * inside an existing array.
+     */
+    isTvContext: boolean;
+    /**
+     * When set, the entire cn(...) call is replaced at once.
+     */
+    cnCall?: DomainCallExpression | undefined;
+    /**
+     * First literal in the slot; used for positions and line-number reporting.
+     */
+    get primaryClassLiteral(): TailwindClassLiteral;
+};
+/**
+ * A groupable class surface — a `cn()` argument slot or a static JSX `className`.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type GroupTarget = {
+    kind: "cnArg";
+    item: StringNode;
+} | {
+    kind: "jsxClassName";
+    sf: DomainSourceFile;
+    lit: TailwindClassLiteral;
+    valueNode: DomainAstNode;
+};
+/**
+ * A planned text replacement for one grouped class surface.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type PlannedGroupEdit = {
+    start: number;
+    end: number;
+    replacement: string;
+    /**
+     * Per-chunk bucket labels (same as `arrange group` trailing `// Buckets:` line).
+     */
+    bucketSummary: Array<string>;
+    jsxCn: boolean;
+    lineSf: DomainSourceFile;
+    reportNode: DomainAstNode;
+    label: string;
+};
+/**
+ * The accumulated findings of an `arrange analyze` run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type AnalyzeReport = {
+    files: number;
+    cnCallExpressions: number;
+    tvCallExpressions: number;
+    cnInsideTvCalls: Array<{
+        file: string;
+        line: number;
+        argCount: number;
+        preview: string;
+    }>;
+    longCnStringLiterals: Array<{
+        file: string;
+        line: number;
+        tokenCount: number;
+        preview: string;
+    }>;
+    longTvStringLiterals: Array<{
+        file: string;
+        line: number;
+        tokenCount: number;
+        preview: string;
+    }>;
+    longJsxClassNameLiterals: Array<{
+        file: string;
+        line: number;
+        tokenCount: number;
+        preview: string;
+    }>;
+};
+/**
+ * The per-file outcome of a grouping pass.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type GroupFileResult = {
+    filePath: string;
+    /**
+     * Sites worth human review: applied edits plus `cn()` inside `tv` with no args
+     * (skipped). Matches preview totals when `groupEdits` correspond to the same plan.
+     */
+    totalFound: number;
+    /**
+     * Edits actually written in apply mode; always 0 in preview mode.
+     */
+    changed: number;
+    /** Populated only in preview mode (write=false) when edits exist. */
+    workPlan?: GroupFileWorkPlan;
+};
+/**
+ * The options a per-file grouping pass runs with.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ArrangeGroupFileOptions = {
+    write: boolean;
+    withClassName: boolean;
+    cnImport?: string | undefined;
+};
+/**
+ * The aggregate outcome of an `arrange` run across files.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ArrangeRunResult = {
+    filePaths: Array<string>;
+    modifiedFiles: Array<string>;
+    totalFound: number;
+    totalChanged: number;
+    hookError: string | null;
+    /** Populated in preview mode (write=false); empty in apply mode. */
+    previewPlans: Array<GroupFileWorkPlan>;
+};
+/**
+ * The formatted lines `arrange group` prints for a suggested grouping.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ArrangeSuggestGroupsOutput = {
+    readonly primaryLine: string;
+    readonly bucketsCommentLine: string;
+};
+/**
+ * The resolved target, workspace root, and loaded config an arrange run starts from.
+ *
+ * @since 0.3.16-canary.0
+ */
+export type ArrangeTargetWorkspaceAndConfig = {
+    readonly resolvedTarget: string;
+    readonly rootDir: string;
+    readonly config: CodefastConfig;
+};

package/dist/arrange/output.d.ts

@@ -0,0 +1,26 @@
+import type { GroupFileWorkPlan } from "#/arrange/domain/grouping-service";
+import type { AnalyzeReport, ArrangeRunResult } from "#/arrange/domain/types";
+/**
+ * Prints the human-readable summary of an `arrange analyze` report.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function printAnalyzeReport(resolvedTargetPath: string, report: AnalyzeReport): void;
+/**
+ * Prints the totals and follow-up hints for an `arrange` run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function printSyncResult(result: ArrangeRunResult, write: boolean): void;
+/**
+ * Prints the totals for an `arrange simplify` run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function printSimplifyResult(result: ArrangeRunResult, write: boolean): void;
+/**
+ * Prints the per-file preview of a work plan's unwrap and grouping edits.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function printGroupFilePreviewFromWork(work: GroupFileWorkPlan): void;

package/dist/arrange/process-file.d.ts

@@ -0,0 +1,11 @@
+import type { ArrangeGroupFileOptions, GroupFileResult } from "#/arrange/domain/types";
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Runs the grouping pipeline on one file — preview or write — and returns its per-file result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function processArrangeGroupFile(fs: FilesystemPort, args: {
+    readonly filePath: string;
+    readonly options: ArrangeGroupFileOptions;
+}): GroupFileResult;

package/dist/arrange/resolve-target.d.ts

@@ -0,0 +1,10 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Resolves the arrange target to a canonical path, defaulting to the nearest package directory.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function resolveArrangeTargetPath(fs: FilesystemPort, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): string;

package/dist/arrange/resolve-target.js

@@ -1,5 +1,6 @@
 import path from "node:path";
-const packageJsonFileName = "package.json";
+import { findNearestAncestor } from "#/core/workspace/ancestor-directories";
+import { packageJsonFileName } from "#/core/workspace/well-known-files";
 /**
  * Resolves the arrange target to a canonical path, defaulting to the nearest package directory.
  *
@@ -14,21 +15,7 @@ export function resolveArrangeTargetPath(fs, args) {
     if (explicitTargetPath) {
         return fs.canonicalPathSync(explicitTargetPath);
     }
-    const nearestPackageDirectory = findNearestPackageDirectory(fs, args.currentWorkingDirectory);
+    const nearestPackageDirectory = findNearestAncestor(args.currentWorkingDirectory, (directoryPath) => fs.existsSync(path.join(directoryPath, packageJsonFileName)));
     const resolvedDefaultTarget = nearestPackageDirectory ?? args.currentWorkingDirectory;
     return fs.canonicalPathSync(resolvedDefaultTarget);
-}
-function findNearestPackageDirectory(fs, currentWorkingDirectory) {
-    let currentDir = path.resolve(currentWorkingDirectory);
-    while (true) {
-        const packageJsonPath = path.join(currentDir, packageJsonFileName);
-        if (fs.existsSync(packageJsonPath)) {
-            return currentDir;
-        }
-        const parentDirectory = path.dirname(currentDir);
-        if (parentDirectory === currentDir) {
-            return undefined;
-        }
-        currentDir = parentDirectory;
-    }
 }

package/dist/arrange/scan-target.d.ts

@@ -0,0 +1,7 @@
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Lists the files an arrange run visits — a directory's non-test `.ts`/`.tsx` files, or the single target.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function scanArrangeTargets(fs: FilesystemPort, targetPath: string): Array<string>;

package/dist/arrange/simplify-process-file.d.ts

@@ -0,0 +1,11 @@
+import type { GroupFileResult } from "#/arrange/domain/types";
+import type { FilesystemPort } from "#/core/filesystem/port";
+/**
+ * Runs the simplify pass on one file — flattening class expressions and pruning an unused `cn` import.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function processArrangeSimplifyFile(fs: FilesystemPort, args: {
+    readonly filePath: string;
+    readonly write: boolean;
+}): GroupFileResult;

package/dist/arrange/simplify-sync.d.ts

@@ -0,0 +1,13 @@
+import type { ArrangeRunResult } from "#/arrange/domain/types";
+import type { AppError } from "#/core/errors";
+import type { FilesystemPort } from "#/core/filesystem/port";
+import type { Result } from "#/core/result";
+/**
+ * Runs the simplify pass over every target file and returns the aggregated result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runArrangeSimplify(fs: FilesystemPort, args: {
+    targetPath: string;
+    write: boolean;
+}): Promise<Result<ArrangeRunResult, AppError>>;