@codefast/cli 0.3.13-canary.1 → 0.3.13-canary.3

package/dist/lib/arrange/index.js

@@ -0,0 +1,41 @@
+/**
+ * Analyze and suggest Tailwind class grouping inside `cn(...)` / `tv(...)`.
+ *
+ * Detects literals in cn arguments: direct strings, ternaries, arrays, string concatenation.
+ * tv: compoundVariants[].className / class; nested cn literals use the same rules.
+ * Direct `cn(...)` inside tv config is discouraged — analyze/preview/apply may replace it with
+ * a string (one argument) or an array (≥2 arguments). Literals in bare tv arrays are not split
+ * by apply (avoids `[ [` artifacts).
+ *
+ * Tailwind CSS v4-oriented heuristics (class buckets follow **render-pipeline order**):
+ *   existence → position → layout → sizing → spacing → shape → background → shadow
+ *   → typography → composite → motion → starting → behavior → state (variants) → selector variants.
+ *   - Container queries (@min-* / @max-* / @[…] / @sm / @md / @3xl / @max-3xs, md/sidebar:, …)
+ *   - Logical properties (ps/pe/ms/me/start/end)
+ *   - not-* modifier; has-*; in-[…]; * / **; nth-* (including numeric); media (pointer-*, contrast-* …)
+ *   - Newer utilities: inset-shadow, field-sizing, mask-*, text-shadow-*, scheme-*, …
+ *   - Arbitrary variants [&...] in general forms
+ *
+ * Usage (repo root):
+ *   pnpm cli:arrange-analyze [dir|file]
+ *   pnpm exec codefast arrange analyze [dir|file]
+ *   pnpm exec codefast arrange group flex gap-2 rounded-md border px-3
+ *   pnpm exec codefast arrange group -- … --tv
+ */
+export { analyzeDirectory } from "#lib/arrange/application/use-cases/analyze-directory.use-case";
+export { printAnalyzeReport } from "#lib/arrange/presentation/report.presenter";
+export { groupFile } from "#lib/arrange/application/use-cases/group-file.use-case";
+export { runOnTarget, runArrangeSync, } from "#lib/arrange/application/use-cases/run-arrange-sync.use-case";
+export { createNodeCliFs, createNodeCliLogger } from "#lib/infra/node-io.adapter";
+export { domainSourceParserAdapter } from "#lib/arrange/infra/domain-source-parser.adapter";
+export { ArrangeError, ArrangeErrorCode } from "#lib/arrange/domain/errors.domain";
+export { DEFAULT_ARRANGE_TARGET, LONG_STRING_TOKEN_THRESHOLD, MAX_STRIP_VARIANT_PASSES, } from "#lib/arrange/domain/constants.domain";
+export { cnModuleSpecifierForFile } from "#lib/arrange/domain/imports.domain";
+export { ensureCnImport } from "#lib/arrange/infra/ensure-cn-import.adapter";
+export { areCnTailwindPartitionsEquivalent, capGroups, mergeEaseTimingIntoFollowingAnimatedState, mergeSingletons, suggestCnGroups, summarizeGroupBucketLabels, } from "#lib/arrange/domain/grouping.domain";
+export { classifyToken, indexOfFirstVariantColon, stripVariants, tokenizeClassString, bucketsCompatible, bucketsMergeCompatible, selectorKey, stateKey, } from "#lib/arrange/domain/tokenizer.util";
+export { forEachStringLiteralInClassExpression } from "#lib/arrange/domain/ast/collectors-cn.collector";
+export { mergeCnUnconditionalLiteralPoolForTest } from "#lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper";
+export { applyEditsDescending, buildKnownCnTvBindings, indentOfLineContaining, isCnOrTvIdentifier, KNOWN_CN_TV_MODULES, lineOf, moduleLooksLikeCnTvReexport, unwrapCnInsideTvCallReplacement, } from "#lib/arrange/domain/ast/ast-helpers.helper";
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue, } from "#lib/arrange/domain/source-text-formatters.formatter";
+export { DEFAULT_SKIP_DIRS, walkTsxFiles, } from "#lib/shared/source-code/infra/tsx-file-walk.adapter";

package/dist/lib/arrange/infra/arrange-sync-cli-options.adapter.d.ts

@@ -0,0 +1,14 @@
+import type { CodefastArrangeConfig } from "#lib/config/domain/schema.domain";
+import type { CliFs, CliLogger } from "#lib/infra/fs-contract.port";
+/** CLI / container wiring: filesystem and logger injected at the boundary. */
+export type ArrangeSyncOptions = {
+    rootDir: string;
+    config?: CodefastArrangeConfig;
+    targetPath: string;
+    write: boolean;
+    withClassName?: boolean;
+    cnImport?: string;
+    fs: CliFs;
+    logger: CliLogger;
+};
+//# sourceMappingURL=arrange-sync-cli-options.adapter.d.ts.map

package/dist/lib/arrange/infra/arrange-sync-cli-options.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-sync-cli-options.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/infra/arrange-sync-cli-options.adapter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,kCAAkC,CAAC;AAC9E,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAEpE,8EAA8E;AAC9E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,MAAM,CAAC,EAAE,qBAAqB,CAAC;IAC/B,UAAU,EAAE,MAAM,CAAC;IACnB,KAAK,EAAE,OAAO,CAAC;IACf,aAAa,CAAC,EAAE,OAAO,CAAC;IACxB,QAAQ,CAAC,EAAE,MAAM,CAAC;IAClB,EAAE,EAAE,KAAK,CAAC;IACV,MAAM,EAAE,SAAS,CAAC;CACnB,CAAC"}

package/dist/lib/arrange/infra/domain-source-parser.adapter.d.ts

@@ -0,0 +1,11 @@
+import type { CliLogger } from "#lib/infra/fs-contract.port";
+import type { DomainSourceParserPort } from "#lib/arrange/application/ports/domain-source-parser.port";
+import type { DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export declare class DomainSourceParserAdapter implements DomainSourceParserPort {
+    private readonly logger?;
+    constructor(logger?: CliLogger | undefined);
+    parseDomainSourceFile(filePath: string, sourceText: string): DomainSourceFile;
+}
+/** Default instance without diagnostics logging (tests and legacy imports). */
+export declare const domainSourceParserAdapter: DomainSourceParserAdapter;
+//# sourceMappingURL=domain-source-parser.adapter.d.ts.map

package/dist/lib/arrange/infra/domain-source-parser.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"domain-source-parser.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/infra/domain-source-parser.adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,sBAAsB,EAAE,MAAM,0DAA0D,CAAC;AACvG,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,wCAAwC,CAAC;AAG/E,qBAAa,yBAA0B,YAAW,sBAAsB;IAC1D,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAApC,YAA6B,MAAM,CAAC,EAAE,SAAS,YAAA,EAAI;IAEnD,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAO5E;CACF;AAED,+EAA+E;AAC/E,eAAO,MAAM,yBAAyB,2BAAkC,CAAC"}

package/dist/lib/arrange/infra/domain-source-parser.adapter.js

@@ -0,0 +1,19 @@
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+import { parseDomainSourceFile as parseDomainSourceFileFromTs } from "#lib/arrange/infra/ts-ast-translator.adapter";
+export class DomainSourceParserAdapter {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    parseDomainSourceFile(filePath, sourceText) {
+        try {
+            return parseDomainSourceFileFromTs(filePath, sourceText);
+        }
+        catch (caughtError) {
+            this.logger?.err(`[domain-source-parser] ${messageFromCaughtUnknown(caughtError)}`);
+            throw caughtError;
+        }
+    }
+}
+/** Default instance without diagnostics logging (tests and legacy imports). */
+export const domainSourceParserAdapter = new DomainSourceParserAdapter();

package/dist/lib/arrange/infra/ensure-cn-import.adapter.d.ts

@@ -0,0 +1,3 @@
+/** Parses source then applies domain cn import injection rules (public CLI-style entry). */
+export declare function ensureCnImport(sourceText: string, filePath: string, cnImportOverride?: string): string;
+//# sourceMappingURL=ensure-cn-import.adapter.d.ts.map

package/dist/lib/arrange/infra/ensure-cn-import.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ensure-cn-import.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/infra/ensure-cn-import.adapter.ts"],"names":[],"mappings":"AAGA,4FAA4F;AAC5F,wBAAgB,cAAc,CAC5B,UAAU,EAAE,MAAM,EAClB,QAAQ,EAAE,MAAM,EAChB,gBAAgB,CAAC,EAAE,MAAM,GACxB,MAAM,CAKR"}

package/dist/lib/arrange/infra/ensure-cn-import.adapter.js

@@ -0,0 +1,6 @@
+import { ensureCnImport as ensureCnImportOnDomainSourceFile } from "#lib/arrange/domain/imports.domain";
+import { parseDomainSourceFile } from "#lib/arrange/infra/ts-ast-translator.adapter";
+/** Parses source then applies domain cn import injection rules (public CLI-style entry). */
+export function ensureCnImport(sourceText, filePath, cnImportOverride) {
+    return ensureCnImportOnDomainSourceFile(parseDomainSourceFile(filePath, sourceText), cnImportOverride);
+}

package/dist/lib/arrange/infra/file-walker.adapter.d.ts

@@ -0,0 +1,8 @@
+import type { CliFs, CliLogger } from "#lib/infra/fs-contract.port";
+import type { FileWalkerPort } from "#lib/arrange/application/ports/file-walker.port";
+export declare class FileWalkerAdapter implements FileWalkerPort {
+    private readonly logger?;
+    constructor(logger?: CliLogger | undefined);
+    walkTypeScriptFiles(rootDirectoryPath: string, fs: CliFs): string[];
+}
+//# sourceMappingURL=file-walker.adapter.d.ts.map

package/dist/lib/arrange/infra/file-walker.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"file-walker.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/infra/file-walker.adapter.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAEpE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,iDAAiD,CAAC;AAEtF,qBAAa,iBAAkB,YAAW,cAAc;IAC1C,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAC;IAApC,YAA6B,MAAM,CAAC,EAAE,SAAS,YAAA,EAAI;IAEnD,mBAAmB,CAAC,iBAAiB,EAAE,MAAM,EAAE,EAAE,EAAE,KAAK,GAAG,MAAM,EAAE,CAOlE;CACF"}

package/dist/lib/arrange/infra/file-walker.adapter.js

@@ -0,0 +1,17 @@
+import { messageFromCaughtUnknown } from "#lib/core/application/utils/caught-unknown-message.util";
+import { walkTsxFiles } from "#lib/shared/source-code/infra/tsx-file-walk.adapter";
+export class FileWalkerAdapter {
+    logger;
+    constructor(logger) {
+        this.logger = logger;
+    }
+    walkTypeScriptFiles(rootDirectoryPath, fs) {
+        try {
+            return walkTsxFiles(rootDirectoryPath, fs);
+        }
+        catch (caughtError) {
+            this.logger?.err(`[file-walker] ${messageFromCaughtUnknown(caughtError)}`);
+            throw caughtError;
+        }
+    }
+}

package/dist/lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Test / REPL helper: parse `callee(<snippet>)` and return merged unconditional literal text.
+ * Lives in infra because parsing uses the TypeScript-backed translator.
+ */
+export declare function mergeCnUnconditionalLiteralPoolForTest(argsSnippet: string, options?: {
+    callee?: string;
+}): string;
+//# sourceMappingURL=merge-cn-literal-pool-for-test.test-helper.d.ts.map

package/dist/lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-cn-literal-pool-for-test.test-helper.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper.ts"],"names":[],"mappings":"AAQA;;;GAGG;AACH,wBAAgB,sCAAsC,CACpD,WAAW,EAAE,MAAM,EACnB,OAAO,CAAC,EAAE;IAAE,MAAM,CAAC,EAAE,MAAM,CAAA;CAAE,GAC5B,MAAM,CAmBR"}

package/dist/lib/arrange/infra/merge-cn-literal-pool-for-test.test-helper.js

@@ -0,0 +1,25 @@
+import { isDomainCallExpression, isDomainExpressionStatement, isDomainIdentifier, } from "#lib/arrange/domain/ast/ast-node.model";
+import { collectUnconditionalTailwindLiteralsFromCnArguments } from "#lib/arrange/domain/ast/collectors-cn.collector";
+import { parseDomainSourceFile } from "#lib/arrange/infra/ts-ast-translator.adapter";
+/**
+ * Test / REPL helper: parse `callee(<snippet>)` and return merged unconditional literal text.
+ * Lives in infra because parsing uses the TypeScript-backed translator.
+ */
+export function mergeCnUnconditionalLiteralPoolForTest(argsSnippet, options) {
+    const callee = options?.callee ?? "cn";
+    const sourceText = `${callee}(${argsSnippet});`;
+    const domainSf = parseDomainSourceFile("mergeCnUnconditionalLiteralPoolForTest.ts", sourceText);
+    const stmt = domainSf.statements[0];
+    if (!isDomainExpressionStatement(stmt)) {
+        throw new Error("expected expression statement");
+    }
+    const call = stmt.expression;
+    if (!isDomainCallExpression(call) ||
+        !isDomainIdentifier(call.expression) ||
+        call.expression.text !== callee) {
+        throw new Error(`expected ${callee}(...) call`);
+    }
+    return collectUnconditionalTailwindLiteralsFromCnArguments(call.arguments)
+        .map((literal) => literal.text)
+        .join(" ");
+}

package/dist/lib/arrange/infra/ts-ast-translator.adapter.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Anti-corruption layer: maps TypeScript compiler AST to arrange domain AST.
+ * This module is the only place that imports `typescript` for arrange AST translation.
+ */
+import ts from "typescript";
+import { type DomainAstNode, type DomainSourceFile } from "#lib/arrange/domain/ast/ast-node.model";
+export declare function translateNode(n: ts.Node, parent: DomainAstNode | null, sf: ts.SourceFile): DomainAstNode;
+export declare function translateTypeScriptSourceFile(tsSf: ts.SourceFile): DomainSourceFile;
+export declare function parseDomainSourceFile(filePath: string, sourceText: string): DomainSourceFile;
+//# sourceMappingURL=ts-ast-translator.adapter.d.ts.map

package/dist/lib/arrange/infra/ts-ast-translator.adapter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ts-ast-translator.adapter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/infra/ts-ast-translator.adapter.ts"],"names":[],"mappings":"AAAA;;;GAGG;AAEH,OAAO,EAAE,MAAM,YAAY,CAAC;AAC5B,OAAO,EAKL,KAAK,aAAa,EAoBlB,KAAK,gBAAgB,EAItB,MAAM,wCAAwC,CAAC;AAmChD,wBAAgB,aAAa,CAC3B,CAAC,EAAE,EAAE,CAAC,IAAI,EACV,MAAM,EAAE,aAAa,GAAG,IAAI,EAC5B,EAAE,EAAE,EAAE,CAAC,UAAU,GAChB,aAAa,CAuVf;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,EAAE,CAAC,UAAU,GAAG,gBAAgB,CAQnF;AAED,wBAAgB,qBAAqB,CAAC,QAAQ,EAAE,MAAM,EAAE,UAAU,EAAE,MAAM,GAAG,gBAAgB,CAI5F"}

package/dist/lib/arrange/infra/ts-ast-translator.adapter.js

@@ -0,0 +1,363 @@
+/**
+ * Anti-corruption layer: maps TypeScript compiler AST to arrange domain AST.
+ * This module is the only place that imports `typescript` for arrange AST translation.
+ */
+import ts from "typescript";
+import { DomainBinaryOperator, DomainSyntaxKind, } from "#lib/arrange/domain/ast/ast-node.model";
+function translateUnknown(n, parent, sf) {
+    const pos = n.getStart(sf);
+    const end = n.getEnd();
+    const self = {
+        kind: DomainSyntaxKind.Unknown,
+        pos,
+        end,
+        parent,
+        children: [],
+    };
+    const childList = [];
+    ts.forEachChild(n, (child) => {
+        childList.push(translateNode(child, self, sf));
+    });
+    return { ...self, children: childList };
+}
+function mapBinaryOperator(operatorToken) {
+    if (operatorToken.kind === ts.SyntaxKind.PlusToken) {
+        return DomainBinaryOperator.Plus;
+    }
+    return DomainBinaryOperator.Other;
+}
+export function translateNode(n, parent, sf) {
+    const pos = n.getStart(sf);
+    const end = n.getEnd();
+    switch (n.kind) {
+        case ts.SyntaxKind.Identifier: {
+            const id = n;
+            return {
+                kind: DomainSyntaxKind.Identifier,
+                pos,
+                end,
+                parent,
+                text: id.text,
+            };
+        }
+        case ts.SyntaxKind.StringLiteral: {
+            const lit = n;
+            return {
+                kind: DomainSyntaxKind.StringLiteral,
+                pos,
+                end,
+                parent,
+                text: lit.text,
+            };
+        }
+        case ts.SyntaxKind.NoSubstitutionTemplateLiteral: {
+            const lit = n;
+            return {
+                kind: DomainSyntaxKind.NoSubstitutionTemplateLiteral,
+                pos,
+                end,
+                parent,
+                text: lit.text,
+            };
+        }
+        case ts.SyntaxKind.ImportDeclaration: {
+            const decl = n;
+            const self = {
+                kind: DomainSyntaxKind.ImportDeclaration,
+                pos,
+                end,
+                parent,
+                importClause: undefined,
+                moduleSpecifier: undefined,
+            };
+            if (decl.importClause) {
+                self.importClause = translateNode(decl.importClause, self, sf);
+            }
+            self.moduleSpecifier = translateNode(decl.moduleSpecifier, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ImportClause: {
+            const clause = n;
+            const self = {
+                kind: DomainSyntaxKind.ImportClause,
+                pos,
+                end,
+                parent,
+                isTypeOnly: clause.isTypeOnly,
+                name: undefined,
+                namedBindings: undefined,
+            };
+            if (clause.name) {
+                self.name = translateNode(clause.name, self, sf);
+            }
+            if (clause.namedBindings) {
+                self.namedBindings = translateNode(clause.namedBindings, self, sf);
+            }
+            return self;
+        }
+        case ts.SyntaxKind.NamedImports: {
+            const named = n;
+            const self = {
+                kind: DomainSyntaxKind.NamedImports,
+                pos,
+                end,
+                parent,
+                elements: [],
+            };
+            const elements = [];
+            for (const element of named.elements) {
+                elements.push(translateNode(element, self, sf));
+            }
+            return { ...self, elements };
+        }
+        case ts.SyntaxKind.NamespaceImport: {
+            const ns = n;
+            const self = {
+                kind: DomainSyntaxKind.NamespaceImport,
+                pos,
+                end,
+                parent,
+                name: undefined,
+            };
+            self.name = translateNode(ns.name, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ImportSpecifier: {
+            const spec = n;
+            const self = {
+                kind: DomainSyntaxKind.ImportSpecifier,
+                pos,
+                end,
+                parent,
+                propertyName: undefined,
+                name: undefined,
+            };
+            if (spec.propertyName) {
+                self.propertyName = translateNode(spec.propertyName, self, sf);
+            }
+            self.name = translateNode(spec.name, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.CallExpression: {
+            const call = n;
+            const self = {
+                kind: DomainSyntaxKind.CallExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+                arguments: [],
+            };
+            self.expression = translateNode(call.expression, self, sf);
+            self.arguments = call.arguments.map((arg) => translateNode(arg, self, sf));
+            return self;
+        }
+        case ts.SyntaxKind.PropertyAccessExpression: {
+            const pa = n;
+            const self = {
+                kind: DomainSyntaxKind.PropertyAccessExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+                name: undefined,
+            };
+            self.expression = translateNode(pa.expression, self, sf);
+            self.name = translateNode(pa.name, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ObjectLiteralExpression: {
+            const obj = n;
+            const self = {
+                kind: DomainSyntaxKind.ObjectLiteralExpression,
+                pos,
+                end,
+                parent,
+                properties: [],
+            };
+            const properties = [];
+            for (const prop of obj.properties) {
+                properties.push(translateNode(prop, self, sf));
+            }
+            return { ...self, properties };
+        }
+        case ts.SyntaxKind.PropertyAssignment: {
+            const prop = n;
+            const self = {
+                kind: DomainSyntaxKind.PropertyAssignment,
+                pos,
+                end,
+                parent,
+                name: undefined,
+                initializer: undefined,
+            };
+            self.name = translateNode(prop.name, self, sf);
+            self.initializer = translateNode(prop.initializer, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ArrayLiteralExpression: {
+            const arr = n;
+            const self = {
+                kind: DomainSyntaxKind.ArrayLiteralExpression,
+                pos,
+                end,
+                parent,
+                elements: [],
+            };
+            const elements = [];
+            for (const element of arr.elements) {
+                elements.push(translateNode(element, self, sf));
+            }
+            return { ...self, elements };
+        }
+        case ts.SyntaxKind.SpreadElement: {
+            const sp = n;
+            const self = {
+                kind: DomainSyntaxKind.SpreadElement,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            self.expression = translateNode(sp.expression, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ParenthesizedExpression: {
+            const pe = n;
+            const self = {
+                kind: DomainSyntaxKind.ParenthesizedExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            self.expression = translateNode(pe.expression, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.AsExpression: {
+            const ae = n;
+            const self = {
+                kind: DomainSyntaxKind.AsExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            self.expression = translateNode(ae.expression, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.SatisfiesExpression: {
+            const se = n;
+            const self = {
+                kind: DomainSyntaxKind.SatisfiesExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            self.expression = translateNode(se.expression, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.NonNullExpression: {
+            const nn = n;
+            const self = {
+                kind: DomainSyntaxKind.NonNullExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            self.expression = translateNode(nn.expression, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ConditionalExpression: {
+            const ce = n;
+            const self = {
+                kind: DomainSyntaxKind.ConditionalExpression,
+                pos,
+                end,
+                parent,
+                condition: undefined,
+                whenTrue: undefined,
+                whenFalse: undefined,
+            };
+            self.condition = translateNode(ce.condition, self, sf);
+            self.whenTrue = translateNode(ce.whenTrue, self, sf);
+            self.whenFalse = translateNode(ce.whenFalse, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.BinaryExpression: {
+            const be = n;
+            const self = {
+                kind: DomainSyntaxKind.BinaryExpression,
+                pos,
+                end,
+                parent,
+                left: undefined,
+                operator: mapBinaryOperator(be.operatorToken),
+                right: undefined,
+            };
+            self.left = translateNode(be.left, self, sf);
+            self.right = translateNode(be.right, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.ExpressionStatement: {
+            const es = n;
+            const self = {
+                kind: DomainSyntaxKind.ExpressionStatement,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            self.expression = translateNode(es.expression, self, sf);
+            return self;
+        }
+        case ts.SyntaxKind.JsxAttribute: {
+            const ja = n;
+            const self = {
+                kind: DomainSyntaxKind.JsxAttribute,
+                pos,
+                end,
+                parent,
+                name: undefined,
+                initializer: undefined,
+            };
+            self.name = translateNode(ja.name, self, sf);
+            if (ja.initializer) {
+                self.initializer = translateNode(ja.initializer, self, sf);
+            }
+            return self;
+        }
+        case ts.SyntaxKind.JsxExpression: {
+            const je = n;
+            const self = {
+                kind: DomainSyntaxKind.JsxExpression,
+                pos,
+                end,
+                parent,
+                expression: undefined,
+            };
+            if (je.expression) {
+                self.expression = translateNode(je.expression, self, sf);
+            }
+            return self;
+        }
+        default:
+            return translateUnknown(n, parent, sf);
+    }
+}
+export function translateTypeScriptSourceFile(tsSf) {
+    const text = tsSf.getFullText();
+    const statements = tsSf.statements.map((statement) => translateNode(statement, null, tsSf));
+    return {
+        fileName: tsSf.fileName,
+        text,
+        statements,
+    };
+}
+export function parseDomainSourceFile(filePath, sourceText) {
+    const scriptKind = filePath.endsWith(".tsx") ? ts.ScriptKind.TSX : ts.ScriptKind.TS;
+    const tsSf = ts.createSourceFile(filePath, sourceText, ts.ScriptTarget.Latest, true, scriptKind);
+    return translateTypeScriptSourceFile(tsSf);
+}

package/dist/lib/arrange/presentation/arrange-prelude.presenter.d.ts

@@ -0,0 +1,14 @@
+import type { CodefastConfig } from "#lib/config/domain/schema.domain";
+import { type AppError } from "#lib/core/domain/errors.domain";
+import { type Result } from "#lib/core/domain/result.model";
+import type { CliContainer } from "#lib/core/infra/container.adapter";
+export type ArrangeTargetWorkspaceAndConfig = {
+    readonly resolvedTarget: string;
+    readonly rootDir: string;
+    readonly config: CodefastConfig;
+};
+export declare function prepareArrangeTargetWorkspaceAndConfig(cli: CliContainer, args: {
+    readonly currentWorkingDirectory: string;
+    readonly rawTarget: string | undefined;
+}): Promise<Result<ArrangeTargetWorkspaceAndConfig, AppError>>;
+//# sourceMappingURL=arrange-prelude.presenter.d.ts.map

package/dist/lib/arrange/presentation/arrange-prelude.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"arrange-prelude.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/presentation/arrange-prelude.presenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kCAAkC,CAAC;AACvE,OAAO,EAAY,KAAK,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AACzE,OAAO,EAAW,KAAK,MAAM,EAAE,MAAM,+BAA+B,CAAC;AACrE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,mCAAmC,CAAC;AAKtE,MAAM,MAAM,+BAA+B,GAAG;IAC5C,QAAQ,CAAC,cAAc,EAAE,MAAM,CAAC;IAChC,QAAQ,CAAC,OAAO,EAAE,MAAM,CAAC;IACzB,QAAQ,CAAC,MAAM,EAAE,cAAc,CAAC;CACjC,CAAC;AAEF,wBAAsB,sCAAsC,CAC1D,GAAG,EAAE,YAAY,EACjB,IAAI,EAAE;IACJ,QAAQ,CAAC,uBAAuB,EAAE,MAAM,CAAC;IACzC,QAAQ,CAAC,SAAS,EAAE,MAAM,GAAG,SAAS,CAAC;CACxC,GACA,OAAO,CAAC,MAAM,CAAC,+BAA+B,EAAE,QAAQ,CAAC,CAAC,CAkB5D"}

package/dist/lib/arrange/presentation/arrange-prelude.presenter.js

@@ -0,0 +1,24 @@
+import { appError } from "#lib/core/domain/errors.domain";
+import { err, ok } from "#lib/core/domain/result.model";
+import { tryLoadCodefastConfig } from "#lib/core/presentation/load-codefast-config.presenter";
+import { resolveCliWorkspaceRootStrict } from "#lib/core/presentation/workspace-root-strict.presenter";
+import { resolveArrangeCliTargetPath } from "#lib/arrange/presentation/resolve-arrange-cli-target.presenter";
+export async function prepareArrangeTargetWorkspaceAndConfig(cli, args) {
+    const resolvedTarget = resolveArrangeCliTargetPath(args.currentWorkingDirectory, args.rawTarget);
+    if (!cli.fs.existsSync(resolvedTarget)) {
+        return err(appError("NOT_FOUND", `Not found: ${resolvedTarget}`));
+    }
+    const rootOutcome = resolveCliWorkspaceRootStrict(cli);
+    if (!rootOutcome.ok) {
+        return rootOutcome;
+    }
+    const loadedOutcome = await tryLoadCodefastConfig(cli, rootOutcome.value);
+    if (!loadedOutcome.ok) {
+        return loadedOutcome;
+    }
+    return ok({
+        resolvedTarget,
+        rootDir: rootOutcome.value,
+        config: loadedOutcome.value.config,
+    });
+}

package/dist/lib/arrange/presentation/formatters.presenter.d.ts

@@ -0,0 +1,3 @@
+/** @deprecated Import from `#lib/arrange/domain/source-text-formatters.formatter` — kept for stable public surface. */
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue, } from "#lib/arrange/domain/source-text-formatters.formatter";
+//# sourceMappingURL=formatters.presenter.d.ts.map

package/dist/lib/arrange/presentation/formatters.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"formatters.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/presentation/formatters.presenter.ts"],"names":[],"mappings":"AAAA,uHAAuH;AACvH,OAAO,EACL,4BAA4B,EAC5B,WAAW,EACX,iBAAiB,EACjB,YAAY,EACZ,yBAAyB,GAC1B,MAAM,sDAAsD,CAAC"}

package/dist/lib/arrange/presentation/formatters.presenter.js

@@ -0,0 +1,2 @@
+/** @deprecated Import from `#lib/arrange/domain/source-text-formatters.formatter` — kept for stable public surface. */
+export { escapeTsStringLiteralContent, formatArray, formatCnArguments, formatCnCall, formatJsxCnAttributeValue, } from "#lib/arrange/domain/source-text-formatters.formatter";

package/dist/lib/arrange/presentation/present-analyze-cli.presenter.d.ts

@@ -0,0 +1,4 @@
+import type { CliLogger } from "#lib/core/application/ports/cli-io.port";
+import { printAnalyzeReport } from "#lib/arrange/presentation/report.presenter";
+export declare function presentAnalyzeCliReport(logger: CliLogger, resolvedTargetPath: string, report: Parameters<typeof printAnalyzeReport>[1]): void;
+//# sourceMappingURL=present-analyze-cli.presenter.d.ts.map

package/dist/lib/arrange/presentation/present-analyze-cli.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"present-analyze-cli.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/presentation/present-analyze-cli.presenter.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,yCAAyC,CAAC;AACzE,OAAO,EAAE,kBAAkB,EAAE,MAAM,4CAA4C,CAAC;AAEhF,wBAAgB,uBAAuB,CACrC,MAAM,EAAE,SAAS,EACjB,kBAAkB,EAAE,MAAM,EAC1B,MAAM,EAAE,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,GAC/C,IAAI,CAEN"}

package/dist/lib/arrange/presentation/present-analyze-cli.presenter.js

@@ -0,0 +1,4 @@
+import { printAnalyzeReport } from "#lib/arrange/presentation/report.presenter";
+export function presentAnalyzeCliReport(logger, resolvedTargetPath, report) {
+    printAnalyzeReport(resolvedTargetPath, report, logger);
+}

package/dist/lib/arrange/presentation/report.presenter.d.ts

@@ -0,0 +1,4 @@
+import type { CliLogger } from "#lib/infra/fs-contract.port";
+import type { AnalyzeReport } from "#lib/arrange/domain/types.domain";
+export declare function printAnalyzeReport(analyzeRootDirectoryPath: string, analyzeReport: AnalyzeReport, logger: CliLogger): void;
+//# sourceMappingURL=report.presenter.d.ts.map

package/dist/lib/arrange/presentation/report.presenter.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"report.presenter.d.ts","sourceRoot":"","sources":["../../../../src/lib/arrange/presentation/report.presenter.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,6BAA6B,CAAC;AAC7D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,kCAAkC,CAAC;AAEtE,wBAAgB,kBAAkB,CAChC,wBAAwB,EAAE,MAAM,EAChC,aAAa,EAAE,aAAa,EAC5B,MAAM,EAAE,SAAS,GAChB,IAAI,CAkDN"}