@codefast/cli 0.9.0 → 0.11.0

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

@@ -0,0 +1,11 @@
+import type { ArrangeRunResult } from "#/arrange/domain/types";
+import type { ArrangeRunRequest } from "#/arrange/regroup/cli-schema";
+import type { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+import type { Result } from "#/core/result";
+/**
+ * Runs the grouping pipeline over every target file and returns the aggregated result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function runArrange(fs: Filesystem, request: ArrangeRunRequest): Promise<Result<ArrangeRunResult, AppError>>;

package/dist/arrange/{sync.js → regroup/run.js}

@@ -1,4 +1,4 @@
-import { processArrangeGroupFile } from "#/arrange/process-file";
+import { processArrangeGroupFile } from "#/arrange/regroup/process-file";
 import { scanArrangeTargets } from "#/arrange/scan-target";
 import { messageFrom } from "#/core/errors";
 import { ok } from "#/core/result";
@@ -19,7 +19,7 @@ async function runOnAfterWriteHook(hook, modifiedFiles) {
  *
  * @since 0.3.16-canary.0
  */
-export async function runArrangeSync(fs, request) {
+export async function runArrange(fs, request) {
     const filePaths = scanArrangeTargets(fs, request.targetPath);
     const modifiedFiles = [];
     const previewPlans = [];

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

@@ -0,0 +1,10 @@
+import type { Filesystem } from "#/core/filesystem/filesystem";
+/**
+ * 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: Filesystem, 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 { Filesystem } from "#/core/filesystem/filesystem";
+/**
+ * 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: Filesystem, targetPath: string): Array<string>;

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

@@ -0,0 +1,7 @@
+import type { ArrangeRunResult } from "#/arrange/domain/types";
+/**
+ * Machine-readable `arrange simplify` summary for `--json`.
+ *
+ * @since 0.11.0
+ */
+export declare function formatArrangeSimplifyJsonOutput(result: ArrangeRunResult, write: boolean): string;

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

@@ -0,0 +1,8 @@
+/**
+ * Machine-readable `arrange simplify` summary for `--json`.
+ *
+ * @since 0.11.0
+ */
+export function formatArrangeSimplifyJsonOutput(result, write) {
+    return JSON.stringify({ schemaVersion: 1, ok: true, write, result });
+}

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

@@ -0,0 +1,17 @@
+import * as z from "zod";
+/**
+ * The request payload for an `arrange simplify` run.
+ *
+ * @since 0.11.0
+ */
+export type ArrangeSimplifyRunRequest = {
+    targetPath: string;
+    write: boolean;
+    foldVariantClassName?: boolean | undefined;
+};
+/**
+ * The `zod` schema validating an `arrange simplify` run request.
+ *
+ * @since 0.11.0
+ */
+export declare const arrangeSimplifyRunRequestSchema: z.ZodType<ArrangeSimplifyRunRequest>;

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

@@ -0,0 +1,11 @@
+import * as z from "zod";
+/**
+ * The `zod` schema validating an `arrange simplify` run request.
+ *
+ * @since 0.11.0
+ */
+export const arrangeSimplifyRunRequestSchema = z.object({
+    targetPath: z.string().min(1),
+    write: z.boolean(),
+    foldVariantClassName: z.boolean().optional(),
+});

package/dist/arrange/simplify/fold-targets.d.ts

@@ -0,0 +1,13 @@
+/** Collects cn() calls whose override classes can fold into a variant function's `className` option. */
+import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+import type { PlannedSimplifyEdit } from "#/arrange/domain/ast/simplify-targets";
+import type { FileClassNameProbe } from "#/arrange/simplify/variant-classname-probe";
+/**
+ * Collects `className` fold edits for every foldable `cn(variant({…}), …)` call in a source file.
+ *
+ * @remarks The type server is loaded lazily via `resolveFileProbe` — only once a syntactic candidate
+ * exists — so files with no foldable call never pay for a type query.
+ *
+ * @since 0.11.0
+ */
+export declare function collectClassNameFoldTargets(sourceFile: DomainSourceFile, resolveFileProbe: () => FileClassNameProbe | null): Array<PlannedSimplifyEdit>;

package/dist/arrange/simplify/fold-targets.js

@@ -0,0 +1,139 @@
+/** Collects cn() calls whose override classes can fold into a variant function's `className` option. */
+import { forEachDomainChild, isDomainCallExpression, isDomainIdentifier, isDomainObjectLiteralExpression, isDomainPropertyAccessExpression, isDomainPropertyAssignment, isDomainTailwindClassLiteral, } from "#/arrange/domain/ast/ast-node";
+import { buildKnownCnTvBindings, isCnOrTvIdentifier, propertyAssignmentNameText } from "#/arrange/domain/ast/helpers";
+import { escapeTsStringLiteralContent } from "#/arrange/domain/source-text-formatters";
+/** Groups a run of trailing cn() arguments, coalescing adjacent static literals into one piece. */
+function coalesceTrailingArgs(args, sourceText) {
+    const pieces = [];
+    for (const arg of args) {
+        if (isDomainTailwindClassLiteral(arg)) {
+            const last = pieces.at(-1);
+            if (last?.kind === "static") {
+                last.texts.push(arg.text);
+            }
+            else {
+                pieces.push({ kind: "static", texts: [arg.text] });
+            }
+        }
+        else {
+            pieces.push({ kind: "dynamic", src: sourceText.slice(arg.pos, arg.end) });
+        }
+    }
+    return pieces;
+}
+/** Renders one class piece as either a quoted merged string or the raw source of a dynamic argument. */
+function renderPiece(piece) {
+    return piece.kind === "static" ? `"${escapeTsStringLiteralContent(piece.texts.join(" ").trim())}"` : piece.src;
+}
+/** The source offset of the callee's name — an identifier or the property of a member access. */
+function calleeNameOffset(expression) {
+    if (isDomainIdentifier(expression)) {
+        return expression.pos;
+    }
+    if (isDomainPropertyAccessExpression(expression)) {
+        return expression.name.pos;
+    }
+    return null;
+}
+/** True when the object literal is a plain bag of assignments that does not already set `className`/`class`. */
+function objectAcceptsClassNameFold(objectArg) {
+    for (const property of objectArg.properties) {
+        // A spread or shorthand parses as a non-assignment node — its `className` cannot be reasoned about.
+        if (!isDomainPropertyAssignment(property)) {
+            return false;
+        }
+        const name = propertyAssignmentNameText(property);
+        if (name === "className" || name === "class") {
+            return false;
+        }
+    }
+    return true;
+}
+/** Builds a fold candidate from syntax alone — no type server — or `null` when the shape is not foldable. */
+function buildFoldCandidate(cnCall, sourceText) {
+    const args = cnCall.arguments;
+    const variantCall = args[0];
+    if (args.length < 2 || variantCall === undefined || !isDomainCallExpression(variantCall)) {
+        return null;
+    }
+    const objectArg = variantCall.arguments[0];
+    if (variantCall.arguments.length !== 1 ||
+        objectArg === undefined ||
+        !isDomainObjectLiteralExpression(objectArg) ||
+        !objectAcceptsClassNameFold(objectArg)) {
+        return null;
+    }
+    const calleeOffset = calleeNameOffset(variantCall.expression);
+    if (calleeOffset === null) {
+        return null;
+    }
+    const pieces = coalesceTrailingArgs(args.slice(1), sourceText);
+    if (pieces.length === 0) {
+        return null;
+    }
+    // A dynamic override or more than one piece becomes an array, so the option must accept one; a
+    // single static override stays a scalar string. Types decide whether either shape is legal.
+    const needsArray = pieces.length > 1 || pieces.some((piece) => piece.kind === "dynamic");
+    const rendered = pieces.map(renderPiece);
+    const classNameValue = pieces.length > 1 ? `[${rendered.join(", ")}]` : rendered[0];
+    // Splice `className` in right after the last property (or just inside an empty object), keeping the
+    // object's original text — a trailing comma or line comment would break a re-serialized `{ … }`.
+    const lastProperty = objectArg.properties.at(-1);
+    const insertOffset = lastProperty ? lastProperty.end : objectArg.pos + 1;
+    const insertion = lastProperty ? `, className: ${classNameValue}` : ` className: ${classNameValue} `;
+    const replacement = sourceText.slice(variantCall.pos, insertOffset) + insertion + sourceText.slice(insertOffset, variantCall.end);
+    return {
+        calleeOffset,
+        needsArray,
+        edit: {
+            start: cnCall.pos,
+            end: cnCall.end,
+            replacement,
+            label: "cn-fold-classname",
+        },
+    };
+}
+/**
+ * Collects `className` fold edits for every foldable `cn(variant({…}), …)` call in a source file.
+ *
+ * @remarks The type server is loaded lazily via `resolveFileProbe` — only once a syntactic candidate
+ * exists — so files with no foldable call never pay for a type query.
+ *
+ * @since 0.11.0
+ */
+export function collectClassNameFoldTargets(sourceFile, resolveFileProbe) {
+    const sourceText = sourceFile.text;
+    const knownBindings = buildKnownCnTvBindings(sourceFile);
+    const candidates = [];
+    const visit = (node) => {
+        if (isDomainCallExpression(node) && isCnOrTvIdentifier(node.expression, "cn", knownBindings)) {
+            const candidate = buildFoldCandidate(node, sourceText);
+            if (candidate) {
+                candidates.push(candidate);
+            }
+        }
+        forEachDomainChild(node, visit);
+    };
+    for (const statement of sourceFile.statements) {
+        visit(statement);
+    }
+    if (candidates.length === 0) {
+        return [];
+    }
+    const fileProbe = resolveFileProbe();
+    if (!fileProbe) {
+        return [];
+    }
+    const results = [];
+    for (const candidate of candidates) {
+        const acceptance = fileProbe.classNameAcceptance(candidate.calleeOffset);
+        if (!acceptance) {
+            continue;
+        }
+        if (candidate.needsArray ? !acceptance.acceptsArray : !acceptance.acceptsString) {
+            continue;
+        }
+        results.push(candidate.edit);
+    }
+    return results;
+}

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

@@ -0,0 +1,7 @@
+import type { ArrangeRunResult } from "#/arrange/domain/types";
+/**
+ * Presents the totals for an `arrange simplify` run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function presentSimplifyResult(result: ArrangeRunResult, write: boolean): void;

package/dist/arrange/simplify/output.js

@@ -0,0 +1,15 @@
+import { logger } from "#/core/logger";
+/**
+ * Presents the totals for an `arrange simplify` run.
+ *
+ * @since 0.3.16-canary.0
+ */
+export function presentSimplifyResult(result, write) {
+    logger.out(`\nTotal: ${result.filePaths.length} file(s), ${result.totalFound} site(s) to simplify.`);
+    if (write) {
+        logger.out(`Applied: ${result.totalChanged} site(s) updated.`);
+    }
+    else {
+        logger.out(`(Run "simplify" to write changes, or "pnpm cli:arrange-simplify" / "pnpm exec codefast arrange simplify")`);
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { GroupFileResult } from "#/arrange/domain/types";
+import type { VariantClassNameProbe } from "#/arrange/simplify/variant-classname-probe";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+/**
+ * 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: Filesystem, args: {
+    readonly filePath: string;
+    readonly write: boolean;
+    readonly probe?: VariantClassNameProbe | null;
+}): GroupFileResult;

package/dist/arrange/simplify/process-file.js

@@ -0,0 +1,49 @@
+import { collectSimplifyTargets } from "#/arrange/domain/ast/simplify-targets";
+import { dropCnImportIfUnused } from "#/arrange/domain/imports";
+import { collectClassNameFoldTargets } from "#/arrange/simplify/fold-targets";
+import { parseDomainSourceFile } from "#/arrange/source-parse";
+import { applyEditsDescending, dropOverlappingEdits } from "#/core/source-text-edit";
+// A file simplify can act on names `cn`/`tv` (a call or an import to prune) or carries a `class`/`className`;
+// a source with none of these has nothing to flatten or fold, so it never needs parsing.
+const SIMPLIFY_MARKER = /\b(?:cn|tv)\b|className|\bclass\s*[=:]/;
+/**
+ * Runs the simplify pass on one file — flattening class expressions and pruning an unused `cn` import.
+ *
+ * @since 0.3.16-canary.0
+ */
+export function processArrangeSimplifyFile(fs, args) {
+    const { filePath, write, probe } = args;
+    const sourceText = fs.readFileSync(filePath, "utf8");
+    if (!SIMPLIFY_MARKER.test(sourceText)) {
+        return { filePath, totalFound: 0, changed: 0 };
+    }
+    const domainSf = parseDomainSourceFile(filePath, sourceText);
+    // Resolve the file's type-server project at most once, and only if a syntactic fold candidate needs it.
+    let resolvedFileProbe;
+    const resolveFileProbe = () => {
+        resolvedFileProbe ??= probe ? probe.forFile(filePath) : null;
+        return resolvedFileProbe;
+    };
+    // Combine fold and base edits, drop no-ops, then remove overlaps so applyEditsDescending only sees
+    // non-overlapping ranges. Fold edits lead the list, so a fold wins an exact-range tie with a base
+    // edit on the same call and nested calls keep only the outermost edit.
+    const foldEdits = probe ? collectClassNameFoldTargets(domainSf, resolveFileProbe) : [];
+    const baseEdits = collectSimplifyTargets(domainSf);
+    const meaningful = dropOverlappingEdits([...foldEdits, ...baseEdits].filter((edit) => sourceText.slice(edit.start, edit.end) !== edit.replacement));
+    // Apply class-simplification edits first, then prune any cn import that
+    // became (or was already) unused. With no edits the text is unchanged, so the
+    // already-parsed tree is reused rather than parsing every untouched file twice.
+    const textAfterEdits = meaningful.length > 0 ? applyEditsDescending(sourceText, meaningful) : sourceText;
+    const domainSfAfterEdits = meaningful.length > 0 ? parseDomainSourceFile(filePath, textAfterEdits) : domainSf;
+    const textAfterImportDrop = dropCnImportIfUnused(domainSfAfterEdits);
+    const importDropped = textAfterImportDrop !== textAfterEdits;
+    const totalFound = meaningful.length + (importDropped ? 1 : 0);
+    if (totalFound === 0) {
+        return { filePath, totalFound: 0, changed: 0 };
+    }
+    if (!write) {
+        return { filePath, totalFound, changed: 0 };
+    }
+    fs.writeFileSync(filePath, textAfterImportDrop, "utf8");
+    return { filePath, totalFound, changed: totalFound };
+}

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

@@ -0,0 +1,14 @@
+import type { ArrangeRunResult } from "#/arrange/domain/types";
+import type { AppError } from "#/core/errors";
+import type { Filesystem } from "#/core/filesystem/filesystem";
+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: Filesystem, args: {
+    targetPath: string;
+    write: boolean;
+    foldVariantClassName?: boolean | undefined;
+}): Promise<Result<ArrangeRunResult, AppError>>;

package/dist/arrange/simplify/run.js

@@ -0,0 +1,38 @@
+import { scanArrangeTargets } from "#/arrange/scan-target";
+import { processArrangeSimplifyFile } from "#/arrange/simplify/process-file";
+import { createVariantClassNameProbe } from "#/arrange/simplify/variant-classname-probe";
+import { ok } from "#/core/result";
+/**
+ * Runs the simplify pass over every target file and returns the aggregated result.
+ *
+ * @since 0.3.16-canary.0
+ */
+export async function runArrangeSimplify(fs, args) {
+    const filePaths = scanArrangeTargets(fs, args.targetPath);
+    const modifiedFiles = [];
+    let totalFound = 0;
+    let totalChanged = 0;
+    // The type probe spawns a TypeScript server, so it is created once and only when the fold is requested.
+    const probe = args.foldVariantClassName ? await createVariantClassNameProbe() : null;
+    try {
+        for (const filePath of filePaths) {
+            const result = processArrangeSimplifyFile(fs, { filePath, write: args.write, probe });
+            totalFound += result.totalFound;
+            totalChanged += result.changed;
+            if (result.changed > 0) {
+                modifiedFiles.push(result.filePath);
+            }
+        }
+    }
+    finally {
+        probe?.dispose();
+    }
+    return ok({
+        filePaths,
+        modifiedFiles,
+        totalFound,
+        totalChanged,
+        hookError: null,
+        previewPlans: [],
+    });
+}

package/dist/arrange/simplify/variant-classname-probe.d.ts

@@ -0,0 +1,35 @@
+/** Type probe that asks whether a variant function's options accept a folded `className`. */
+/**
+ * What a variant function's `className`/`class` option accepts, resolved from its type.
+ *
+ * @since 0.11.0
+ */
+export interface VariantClassNameAcceptance {
+    readonly acceptsString: boolean;
+    readonly acceptsArray: boolean;
+}
+/**
+ * A per-file view that resolves a callee's `className` acceptance from a source offset.
+ *
+ * @since 0.11.0
+ */
+export interface FileClassNameProbe {
+    classNameAcceptance(calleeOffset: number): VariantClassNameAcceptance | null;
+}
+/**
+ * A whole-run type probe backing the opt-in `className` fold, bound to one type server.
+ *
+ * @since 0.11.0
+ */
+export interface VariantClassNameProbe {
+    forFile(filePath: string): FileClassNameProbe | null;
+    dispose(): void;
+}
+/**
+ * Creates a type probe over the native TypeScript type server for the opt-in `className` fold.
+ *
+ * @throws AppError when the `typescript` package providing the type server cannot be loaded.
+ *
+ * @since 0.11.0
+ */
+export declare function createVariantClassNameProbe(): Promise<VariantClassNameProbe>;

package/dist/arrange/simplify/variant-classname-probe.js

@@ -0,0 +1,95 @@
+/** Type probe that asks whether a variant function's options accept a folded `className`. */
+import { AppError, messageFrom } from "#/core/errors";
+// ── Type inspection ──────────────────────────────────────────────────────────────────────────────────────────────────
+/** The type of the callee's first-parameter `className` (preferred) or `class` option, if any. */
+function classNameOptionType(checker, optionsType) {
+    for (const name of ["className", "class"]) {
+        const symbol = checker.getPropertyOfType(optionsType, name);
+        if (symbol) {
+            const propertyType = checker.getTypeOfSymbol(symbol);
+            if (propertyType) {
+                return propertyType;
+            }
+        }
+    }
+    return undefined;
+}
+/** True when any constituent of the option type is array-like — the option accepts a class array. */
+function optionAcceptsArray(checker, optionType) {
+    const constituents = optionType.isUnionType() ? optionType.getTypes() : [optionType];
+    return constituents.some((constituent) => checker.isArrayType(constituent) || checker.isTupleType(constituent) || checker.isArrayLikeType(constituent));
+}
+/** Resolves how the function called at `offset` accepts a `className`, or `null` when it is not a variant function. */
+function classNameAcceptanceAt(checker, callKind, filePath, offset) {
+    const calleeType = checker.getTypeAtPosition(filePath, offset);
+    if (!calleeType) {
+        return null;
+    }
+    const signature = checker.getSignaturesOfType(calleeType, callKind)[0];
+    if (!signature) {
+        return null;
+    }
+    const parameterType = checker.getParameterType(signature, 0);
+    if (!parameterType) {
+        return null;
+    }
+    const nonNullableType = checker.getNonNullableType(parameterType);
+    if (!nonNullableType) {
+        return null;
+    }
+    const optionsType = checker.getApparentType(nonNullableType);
+    if (!optionsType) {
+        return null;
+    }
+    const optionType = classNameOptionType(checker, optionsType);
+    if (!optionType) {
+        return null;
+    }
+    return {
+        acceptsString: checker.isTypeAssignableTo(checker.getStringType(), optionType),
+        acceptsArray: optionAcceptsArray(checker, optionType),
+    };
+}
+// ── Probe lifecycle ──────────────────────────────────────────────────────────────────────────────────────────────────
+/** Loads the native TypeScript type-server API, or fails with a coded error naming the missing package. */
+async function loadTypeServer() {
+    try {
+        return await import("typescript/unstable/sync");
+    }
+    catch (cause) {
+        throw new AppError("INFRA_FAILURE", `--fold-variant-classname needs the "typescript" package (v7) resolvable from the target: ${messageFrom(cause)}`, cause);
+    }
+}
+/**
+ * Creates a type probe over the native TypeScript type server for the opt-in `className` fold.
+ *
+ * @throws AppError when the `typescript` package providing the type server cannot be loaded.
+ *
+ * @since 0.11.0
+ */
+export async function createVariantClassNameProbe() {
+    const sync = await loadTypeServer();
+    const api = new sync.API();
+    const callKind = sync.SignatureKind.Call;
+    return {
+        forFile(filePath) {
+            try {
+                const project = api.updateSnapshot({ openFiles: [filePath] }).getDefaultProjectForFile(filePath);
+                if (!project) {
+                    return null;
+                }
+                const { checker } = project;
+                return {
+                    classNameAcceptance: (offset) => classNameAcceptanceAt(checker, callKind, filePath, offset),
+                };
+            }
+            catch {
+                // A file outside any tsconfig has no project to type against — skip its fold, keep the base pass.
+                return null;
+            }
+        },
+        dispose() {
+            api.close();
+        },
+    };
+}

package/dist/arrange/source-parse.d.ts

@@ -0,0 +1,7 @@
+import type { DomainSourceFile } from "#/arrange/domain/ast/ast-node";
+/**
+ * Parses source text into a domain source file via the shared `oxc-parser` translator.
+ *
+ * @since 0.3.16-canary.0
+ */
+export declare function parseDomainSourceFile(filePath: string, sourceText: string): DomainSourceFile;

package/dist/arrange/source-parse.js

@@ -1,4 +1,4 @@
-import { TypeScriptAstTranslator } from "#/arrange/typescript-ast-translator";
+import { TypeScriptAstTranslator } from "#/arrange/domain/ast/translator";
 import { messageFrom } from "#/core/errors";
 import { logger } from "#/core/logger";
 const translator = new TypeScriptAstTranslator();

package/dist/audit/command.d.ts

@@ -0,0 +1,8 @@
+import { Command } from "commander";
+/**
+ * Top-level `audit` command — the source scans. Every one of them reports by default; only
+ * `comments --fix` writes, and only where the rewrite discards nothing a person wrote.
+ *
+ * @since 0.5.0-canary.6
+ */
+export declare function createAuditCommand(): Command;