@openrewrite/rewrite 8.69.0-20251207-220615 → 8.69.0-20251208-071356

package/src/javascript/autodetect.ts

@@ -0,0 +1,302 @@
+/*
+ * Copyright 2025 the original author or authors.
+ * <p>
+ * Licensed under the Moderne Source Available License (the "License");
+ * you may not use this file except in compliance with the License.
+ * You may obtain a copy of the License at
+ * <p>
+ * https://docs.moderne.io/licensing/moderne-source-available-license
+ * <p>
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+import {NamedStyles, Style} from "../style";
+import {randomId} from "../uuid";
+import {SourceFile} from "../tree";
+import {JS} from "./tree";
+import {JavaScriptVisitor} from "./visitor";
+import {J} from "../java";
+import {
+    IntelliJ,
+    SpacesStyle,
+    StyleKind,
+    TabsAndIndentsStyle,
+    WrappingAndBracesStyle,
+    WrappingAndBracesStyleDetailKind
+} from "./style";
+
+/**
+ * Auto-detected styles for JavaScript/TypeScript code.
+ * Focuses on key formatting variations where projects differ:
+ * - Tabs vs spaces
+ * - Indent size (2, 4, etc.)
+ * - Spaces within ES6 import/export braces
+ */
+export class Autodetect implements NamedStyles {
+    readonly kind = "org.openrewrite.marker.NamedStyles" as const;
+    readonly id: string;
+    readonly name = "org.openrewrite.javascript.Autodetect";
+    readonly displayName = "Auto-detected";
+    readonly description = "Automatically detect styles from a repository's existing code.";
+    readonly tags: string[] = [];
+    readonly styles: Style[];
+
+    constructor(id: string, styles: Style[]) {
+        this.id = id;
+        this.styles = styles;
+    }
+
+    static detector(): Detector {
+        return new Detector();
+    }
+}
+
+/**
+ * Collects formatting statistics from source files and builds auto-detected styles.
+ */
+export class Detector {
+    private readonly tabsAndIndentsStats = new TabsAndIndentsStatistics();
+    private readonly spacesStats = new SpacesStatistics();
+
+    /**
+     * Sample a source file to collect formatting statistics.
+     */
+    async sample(sourceFile: SourceFile): Promise<void> {
+        if (sourceFile.kind === JS.Kind.CompilationUnit) {
+            await this.sampleJavaScript(sourceFile as JS.CompilationUnit);
+        }
+    }
+
+    /**
+     * Sample a JavaScript/TypeScript compilation unit.
+     */
+    async sampleJavaScript(cu: JS.CompilationUnit): Promise<void> {
+        await new FindIndentVisitor(this.tabsAndIndentsStats).visit(cu, {});
+        await new FindSpacesVisitor(this.spacesStats).visit(cu, {});
+    }
+
+    /**
+     * Build the auto-detected styles from collected statistics.
+     */
+    build(): Autodetect {
+        return new Autodetect(randomId(), [
+            this.tabsAndIndentsStats.getTabsAndIndentsStyle(),
+            this.spacesStats.getSpacesStyle(),
+            this.getWrappingAndBracesStyle(),
+        ]);
+    }
+
+    getTabsAndIndentsStyle(): TabsAndIndentsStyle {
+        return this.tabsAndIndentsStats.getTabsAndIndentsStyle();
+    }
+
+    getSpacesStyle(): SpacesStyle {
+        return this.spacesStats.getSpacesStyle();
+    }
+
+    getWrappingAndBracesStyle(): WrappingAndBracesStyle {
+        return {
+            kind: StyleKind.WrappingAndBracesStyle,
+            ifStatement: {
+                kind: WrappingAndBracesStyleDetailKind.WrappingAndBracesStyleIfStatement,
+                elseOnNewLine: false
+            }
+        };
+    }
+}
+
+// ============================================================================
+// Statistics Classes
+// ============================================================================
+
+/**
+ * Tracks indentation patterns to detect tabs vs spaces and indent size.
+ */
+class TabsAndIndentsStatistics {
+    private totalSpaceIndents = 0;
+    private totalTabIndents = 0;
+
+    // Track all observed indent sizes to compute GCD
+    private observedIndents: number[] = [];
+
+    recordSpaceIndent(spaceCount: number): void {
+        this.totalSpaceIndents++;
+        if (spaceCount > 0) {
+            this.observedIndents.push(spaceCount);
+        }
+    }
+
+    recordTabIndent(): void {
+        this.totalTabIndents++;
+    }
+
+    getTabsAndIndentsStyle(): TabsAndIndentsStyle {
+        // Determine if using tabs or spaces
+        const useTabs = this.totalTabIndents > this.totalSpaceIndents;
+
+        // Find indent size by computing GCD of all observed indents
+        // This correctly handles 2-space files where we see 2, 4, 6, 8... (all multiples of 2)
+        let detectedIndentSize = 4; // Default
+        if (this.observedIndents.length > 0) {
+            // Compute GCD of all observed indents
+            let gcd = this.observedIndents[0];
+            for (let i = 1; i < this.observedIndents.length; i++) {
+                gcd = this.computeGcd(gcd, this.observedIndents[i]);
+                if (gcd === 1) break; // Can't get smaller than 1
+            }
+            // Only use common indent sizes (2, 4, 8)
+            if (gcd === 2 || gcd === 4 || gcd === 8) {
+                detectedIndentSize = gcd;
+            } else if (gcd > 0 && gcd % 4 === 0) {
+                detectedIndentSize = 4;
+            } else if (gcd > 0 && gcd % 2 === 0) {
+                detectedIndentSize = 2;
+            }
+        }
+
+        return {
+            kind: StyleKind.TabsAndIndentsStyle,
+            useTabCharacter: useTabs,
+            tabSize: 4,
+            indentSize: detectedIndentSize,
+            continuationIndent: detectedIndentSize * 2,
+            keepIndentsOnEmptyLines: false,
+            indentChainedMethods: true,
+            indentAllChainedCallsInAGroup: false
+        };
+    }
+
+    private computeGcd(a: number, b: number): number {
+        while (b !== 0) {
+            const temp = b;
+            b = a % b;
+            a = temp;
+        }
+        return a;
+    }
+}
+
+/**
+ * Tracks spacing patterns around ES6 import/export braces.
+ */
+class SpacesStatistics {
+    // Track spaces within ES6 import/export braces: { a } vs {a}
+    es6ImportExportBracesWithSpace = 0;
+    es6ImportExportBracesWithoutSpace = 0;
+
+    getSpacesStyle(): SpacesStyle {
+        // Use TypeScript defaults as base since most modern JS/TS projects use similar conventions
+        // TypeScript defaults include afterTypeReferenceColon: true which is commonly expected
+        const defaults = IntelliJ.TypeScript.spaces();
+
+        return {
+            ...defaults,
+            within: {
+                ...defaults.within,
+                es6ImportExportBraces: this.es6ImportExportBracesWithSpace > this.es6ImportExportBracesWithoutSpace
+            }
+        };
+    }
+}
+
+// ============================================================================
+// Visitor Classes for Collecting Statistics
+// ============================================================================
+
+/**
+ * Detects indentation patterns by examining block contents.
+ */
+class FindIndentVisitor extends JavaScriptVisitor<any> {
+    constructor(private stats: TabsAndIndentsStatistics) {
+        super();
+    }
+
+    protected async visitBlock(block: J.Block, p: any): Promise<J | undefined> {
+        // Check indentation of statements in the block
+        for (const stmt of block.statements) {
+            const whitespace = stmt.element.prefix?.whitespace;
+            if (whitespace) {
+                this.analyzeIndent(whitespace);
+            }
+        }
+        return super.visitBlock(block, p);
+    }
+
+    private analyzeIndent(whitespace: string): void {
+        const newlineIndex = whitespace.lastIndexOf('\n');
+        if (newlineIndex < 0) return;
+
+        const indent = whitespace.substring(newlineIndex + 1);
+        if (indent.length === 0) return;
+
+        // Check first character to determine type
+        if (indent[0] === '\t') {
+            this.stats.recordTabIndent();
+        } else if (indent[0] === ' ') {
+            // Count consecutive spaces
+            let spaceCount = 0;
+            for (const char of indent) {
+                if (char === ' ') spaceCount++;
+                else break;
+            }
+            if (spaceCount > 0) {
+                this.stats.recordSpaceIndent(spaceCount);
+            }
+        }
+    }
+}
+
+/**
+ * Detects spacing patterns in imports and exports.
+ */
+class FindSpacesVisitor extends JavaScriptVisitor<any> {
+    constructor(private stats: SpacesStatistics) {
+        super();
+    }
+
+    protected async visitImportDeclaration(import_: JS.Import, p: any): Promise<J | undefined> {
+        // Check ES6 import braces spacing: import { a } from 'x' vs import {a} from 'x'
+        if (import_.importClause?.namedBindings?.kind === JS.Kind.NamedImports) {
+            const namedImports = import_.importClause.namedBindings as JS.NamedImports;
+            if (namedImports.elements.elements.length > 0) {
+                const firstElement = namedImports.elements.elements[0];
+                const hasSpaceAfterOpenBrace = firstElement.element.prefix?.whitespace?.includes(' ') ?? false;
+
+                const lastElement = namedImports.elements.elements[namedImports.elements.elements.length - 1];
+                const hasSpaceBeforeCloseBrace = lastElement.after?.whitespace?.includes(' ') ?? false;
+
+                if (hasSpaceAfterOpenBrace || hasSpaceBeforeCloseBrace) {
+                    this.stats.es6ImportExportBracesWithSpace++;
+                } else {
+                    this.stats.es6ImportExportBracesWithoutSpace++;
+                }
+            }
+        }
+        return super.visitImportDeclaration(import_, p);
+    }
+
+    protected async visitExportDeclaration(export_: JS.ExportDeclaration, p: any): Promise<J | undefined> {
+        // Check ES6 export braces spacing
+        if (export_.exportClause?.kind === JS.Kind.NamedExports) {
+            const namedExports = export_.exportClause as JS.NamedExports;
+            if (namedExports.elements.elements.length > 0) {
+                const firstElement = namedExports.elements.elements[0];
+                const hasSpaceAfterOpenBrace = firstElement.element.prefix?.whitespace?.includes(' ') ?? false;
+
+                const lastElement = namedExports.elements.elements[namedExports.elements.elements.length - 1];
+                const hasSpaceBeforeCloseBrace = lastElement.after?.whitespace?.includes(' ') ?? false;
+
+                if (hasSpaceAfterOpenBrace || hasSpaceBeforeCloseBrace) {
+                    this.stats.es6ImportExportBracesWithSpace++;
+                } else {
+                    this.stats.es6ImportExportBracesWithoutSpace++;
+                }
+            }
+        }
+        return super.visitExportDeclaration(export_, p);
+    }
+}

package/src/javascript/format.ts

@@ -18,14 +18,8 @@ import {JavaScriptVisitor} from "./visitor";
 import {Comment, J, lastWhitespace, replaceLastWhitespace, Statement} from "../java";
 import {Draft, produce} from "immer";
 import {Cursor, isScope, Tree} from "../tree";
-import {
-    BlankLinesStyle,
-    SpacesStyle,
-    styleFromSourceFile,
-    StyleKind,
-    TabsAndIndentsStyle,
-    WrappingAndBracesStyle
-} from "./style";
+import {BlankLinesStyle, getStyle, SpacesStyle, StyleKind, TabsAndIndentsStyle, WrappingAndBracesStyle} from "./style";
+import {NamedStyles} from "../style";
 import {produceAsync} from "../visitor";
 import {findMarker} from "../markers";
 import {Generator} from "./markers";
@@ -40,22 +34,33 @@ export const maybeAutoFormat = async <J2 extends J, P>(before: J2, after: J2, p:
     return after;
 }
 
-export const autoFormat = async <J2 extends J, P>(j: J2, p: P, stopAfter?: J, parent?: Cursor): Promise<J2> =>
-    (await new AutoformatVisitor(stopAfter).visit(j, p, parent) as J2);
+export const autoFormat = async <J2 extends J, P>(j: J2, p: P, stopAfter?: J, parent?: Cursor, styles?: NamedStyles[]): Promise<J2> =>
+    (await new AutoformatVisitor(stopAfter, styles).visit(j, p, parent) as J2);
 
+/**
+ * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
+ *
+ * Style resolution order (first match wins):
+ * 1. Styles passed to the constructor
+ * 2. Styles from source file markers (NamedStyles)
+ * 3. IntelliJ defaults
+ */
 export class AutoformatVisitor<P> extends JavaScriptVisitor<P> {
-    constructor(private stopAfter?: Tree) {
+    private readonly styles?: NamedStyles[];
+
+    constructor(private stopAfter?: Tree, styles?: NamedStyles[]) {
         super();
+        this.styles = styles;
     }
 
     async visit<R extends J>(tree: Tree, p: P, cursor?: Cursor): Promise<R | undefined> {
         const visitors = [
             new NormalizeWhitespaceVisitor(this.stopAfter),
             new MinimumViableSpacingVisitor(this.stopAfter),
-            new BlankLinesVisitor(styleFromSourceFile(StyleKind.BlankLinesStyle, tree) as BlankLinesStyle, this.stopAfter),
-            new WrappingAndBracesVisitor(styleFromSourceFile(StyleKind.WrappingAndBracesStyle, tree) as WrappingAndBracesStyle, this.stopAfter),
-            new SpacesVisitor(styleFromSourceFile(StyleKind.SpacesStyle, tree) as SpacesStyle, this.stopAfter),
-            new TabsAndIndentsVisitor(styleFromSourceFile(StyleKind.TabsAndIndentsStyle, tree) as TabsAndIndentsStyle, this.stopAfter),
+            new BlankLinesVisitor(getStyle(StyleKind.BlankLinesStyle, tree, this.styles) as BlankLinesStyle, this.stopAfter),
+            new WrappingAndBracesVisitor(getStyle(StyleKind.WrappingAndBracesStyle, tree, this.styles) as WrappingAndBracesStyle, this.stopAfter),
+            new SpacesVisitor(getStyle(StyleKind.SpacesStyle, tree, this.styles) as SpacesStyle, this.stopAfter),
+            new TabsAndIndentsVisitor(getStyle(StyleKind.TabsAndIndentsStyle, tree, this.styles) as TabsAndIndentsStyle, this.stopAfter),
         ]
 
         let t: R | undefined = tree as R;
@@ -208,7 +213,19 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
     public async visitContainer<T extends J>(container: J.Container<T>, p: P): Promise<J.Container<T>> {
         const ret = await super.visitContainer(container, p) as J.Container<T>;
         return produce(ret, draft => {
+            if (draft.elements.length > 0) {
+                // Apply beforeComma rule to all elements except the last
+                // (last element's after is before closing bracket, not a comma)
+                for (let i = 0; i < draft.elements.length - 1; i++) {
+                    const afterWs = draft.elements[i].after.whitespace;
+                    // Preserve newlines - only adjust when on same line
+                    if (!afterWs.includes("\n")) {
+                        draft.elements[i].after.whitespace = this.style.other.beforeComma ? " " : "";
+                    }
+                }
+            }
             if (draft.elements.length > 1) {
+                // Apply afterComma rule to elements after the first
                 for (let i = 1; i < draft.elements.length; i++) {
                     const currentWs = draft.elements[i].element.prefix.whitespace;
                     // Preserve original newlines - only adjust spacing when elements are on same line
@@ -228,8 +245,20 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                 if (draft.exportClause.kind == JS.Kind.NamedExports) {
                     const ne = (draft.exportClause as Draft<JS.NamedExports>);
                     if (ne.elements.elements.length > 0) {
-                        ne.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                        ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                        // Check if this is a multi-line export (any element's prefix has a newline)
+                        const isMultiLine = ne.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
+                        if (!isMultiLine) {
+                            // Single-line: adjust brace spacing
+                            ne.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                            ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                        } else {
+                            // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
+                            // If it has only spaces (no newline), it's the space before a trailing comma
+                            const lastAfter = ne.elements.elements[ne.elements.elements.length - 1].after.whitespace;
+                            if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
+                                ne.elements.elements[ne.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
+                            }
+                        }
                     }
                 }
             }
@@ -290,8 +319,20 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
                     draft.importClause.namedBindings.prefix.whitespace = " ";
                     if (draft.importClause.namedBindings.kind == JS.Kind.NamedImports) {
                         const ni = draft.importClause.namedBindings as Draft<JS.NamedImports>;
-                        ni.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
-                        ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                        // Check if this is a multi-line import (any element's prefix has a newline)
+                        const isMultiLine = ni.elements.elements.some(e => e.element.prefix.whitespace.includes("\n"));
+                        if (!isMultiLine) {
+                            // Single-line: adjust brace spacing
+                            ni.elements.elements[0].element.prefix.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                            ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.within.es6ImportExportBraces ? " " : "";
+                        } else {
+                            // Multi-line: apply beforeComma rule to last element's after (for trailing commas)
+                            // If it has only spaces (no newline), it's the space before a trailing comma
+                            const lastAfter = ni.elements.elements[ni.elements.elements.length - 1].after.whitespace;
+                            if (!lastAfter.includes("\n") && lastAfter.trim() === "") {
+                                ni.elements.elements[ni.elements.elements.length - 1].after.whitespace = this.style.other.beforeComma ? " " : "";
+                            }
+                        }
                     }
                 }
             }
@@ -363,9 +404,14 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
 
     protected async visitPropertyAssignment(propertyAssignment: JS.PropertyAssignment, p: P): Promise<J | undefined> {
         const pa = await super.visitPropertyAssignment(propertyAssignment, p) as JS.PropertyAssignment;
-        return produceAsync(pa, draft => {
-            draft.name.after.whitespace = this.style.other.beforePropertyNameValueSeparator ? " " : "";
-        });
+        // Only adjust the space before the colon if there's an initializer (not a shorthand property)
+        // For shorthand properties like { headers }, name.after.whitespace is the space before }
+        if (pa.initializer) {
+            return produceAsync(pa, draft => {
+                draft.name.after.whitespace = this.style.other.beforePropertyNameValueSeparator ? " " : "";
+            });
+        }
+        return pa;
     }
 
     protected async visitSwitch(switchNode: J.Switch, p: P): Promise<J | undefined> {
@@ -432,6 +478,21 @@ export class SpacesVisitor<P> extends JavaScriptVisitor<P> {
         });
     }
 
+    protected async visitTypeLiteral(typeLiteral: JS.TypeLiteral, p: P): Promise<J | undefined> {
+        const ret = await super.visitTypeLiteral(typeLiteral, p) as JS.TypeLiteral;
+        // Apply objectLiteralTypeBraces spacing for single-line type literals
+        const isSingleLine = !ret.members.end.whitespace.includes("\n") &&
+            ret.members.statements.every(s => !s.element.prefix.whitespace.includes("\n"));
+        if (isSingleLine && ret.members.statements.length > 0) {
+            return produce(ret, draft => {
+                const space = this.style.within.objectLiteralTypeBraces ? " " : "";
+                draft.members.statements[0].element.prefix.whitespace = space;
+                draft.members.end.whitespace = space;
+            });
+        }
+        return ret;
+    }
+
     protected async visitUnary(unary: J.Unary, p: P): Promise<J | undefined> {
         const ret = await super.visitUnary(unary, p) as J.Unary;
         return produce(ret, draft => {
@@ -681,9 +742,10 @@ export class WrappingAndBracesVisitor<P> extends JavaScriptVisitor<P> {
         const b = await super.visitBlock(block, p) as J.Block;
         return produce(b, draft => {
             if (!draft.end.whitespace.includes("\n") && (draft.statements.length == 0 || !draft.statements[draft.statements.length - 1].after.whitespace.includes("\n"))) {
-                // Skip newline for object literals and empty lambda/function bodies
+                // Skip newline for object literals, type literals, and empty lambda/function bodies
                 const parentKind = this.cursor.parent?.value.kind;
                 if (parentKind !== J.Kind.NewClass &&
+                    parentKind !== JS.Kind.TypeLiteral &&
                     !(draft.statements.length === 0 && (parentKind === J.Kind.Lambda || parentKind === J.Kind.MethodDeclaration))) {
                     draft.end = this.withNewlineSpace(draft.end);
                 }
@@ -1012,14 +1074,21 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
             if (statements.length > 0) {
                 this.keepMaximumBlankLines(draft.body.statements[0].element, 0);
 
+                const isInterface = draft.classKind.type === J.ClassDeclaration.Kind.Type.Interface;
                 for (let i = 1; i < statements.length; i++) {
                     const previousElement = statements[i - 1].element;
                     let currentElement = statements[i].element;
                     if (previousElement.kind == J.Kind.VariableDeclarations || currentElement.kind == J.Kind.VariableDeclarations) {
-                        this.minimumBlankLines(currentElement, 1 + this.style.minimum.aroundField) // TODO aroundFieldInInterface
+                        const fieldBlankLines = isInterface
+                            ? this.style.minimum.aroundFieldInInterface ?? 0
+                            : this.style.minimum.aroundField;
+                        this.minimumBlankLines(currentElement, fieldBlankLines);
                     }
                     if (previousElement.kind == J.Kind.MethodDeclaration || currentElement.kind == J.Kind.MethodDeclaration) {
-                        this.minimumBlankLines(currentElement, 1 + this.style.minimum.aroundMethod) // TODO aroundMethodInInterface
+                        const methodBlankLines = isInterface
+                            ? this.style.minimum.aroundMethodInInterface ?? 0
+                            : this.style.minimum.aroundMethod;
+                        this.minimumBlankLines(currentElement, methodBlankLines);
                     }
                     this.keepMaximumBlankLines(currentElement, this.style.keepMaximum.inCode);
                     draft.body.statements[i].element = currentElement;
@@ -1072,7 +1141,7 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
                     }
                     this.keepMaximumBlankLines(draft, this.style.keepMaximum.inCode);
                 }
-            } else if (parent?.kind === J.Kind.Block && grandparent?.kind !== J.Kind.NewClass ||
+            } else if (parent?.kind === J.Kind.Block && grandparent?.kind !== J.Kind.NewClass && grandparent?.kind !== JS.Kind.TypeLiteral ||
                       (parent?.kind === JS.Kind.CompilationUnit && (parent! as JS.CompilationUnit).statements[0].element.id != draft.id) ||
                       (parent?.kind === J.Kind.Case)) {
                 if (draft.kind != J.Kind.Case) {
@@ -1086,8 +1155,8 @@ export class BlankLinesVisitor<P> extends JavaScriptVisitor<P> {
         const b = await super.visitBlock(block, p) as J.Block;
         return produce(b, draft => {
             const parentKind = this.cursor.parent?.value.kind;
-            // Skip newline only for object literals (NewClass) - they should preserve single-line formatting
-            if (parentKind != J.Kind.NewClass) {
+            // Skip newline for object literals (NewClass) and type literals (TypeLiteral)
+            if (parentKind != J.Kind.NewClass && parentKind != JS.Kind.TypeLiteral) {
                 draft.end = replaceLastWhitespace(draft.end, ws =>
                     ws.includes("\n") ? ws : ws.replace(/[ \t]+$/, '') + "\n"
                 );

package/src/javascript/index.ts

@@ -26,6 +26,7 @@ export * from "./preconditions";
 export * from "./templating/index";
 export * from "./method-matcher";
 export * from "./format";
+export * from "./autodetect";
 
 export * from "./add-import";
 export * from "./remove-import";

package/src/javascript/recipes/auto-format.ts

@@ -14,31 +14,66 @@
  * limitations under the License.
  */
 
-import {Recipe} from "../../recipe";
+import {ScanningRecipe} from "../../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
 import {AutoformatVisitor} from "../format";
+import {Autodetect, Detector} from "../autodetect";
+import {JavaScriptVisitor} from "../visitor";
+import {JS} from "../tree";
+import {J} from "../../java";
+
+/**
+ * Accumulator for the AutoFormat scanning recipe.
+ * Holds the Detector that collects formatting statistics during the scan phase.
+ */
+interface AutoFormatAccumulator {
+    detector: Detector;
+    detectedStyles?: Autodetect;
+}
 
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
  *
- * This recipe applies the following formatting:
- * - Normalizes whitespace
- * - Ensures minimum viable spacing
- * - Applies blank line rules
- * - Applies wrapping and braces rules
- * - Applies spacing rules
- * - Applies tabs and indentation rules
+ * This is a scanning recipe that:
+ * 1. Scans all source files to detect the project's existing formatting style
+ * 2. Applies consistent formatting based on the detected style
+ *
+ * The detected formatting includes:
+ * - Tabs vs spaces preference
+ * - Indent size (2, 4, etc.)
+ * - ES6 import/export brace spacing
  *
- * The formatting rules are determined by the style settings attached to the source file,
- * or defaults to IntelliJ IDEA style if no custom style is specified.
+ * If no clear style is detected, defaults to IntelliJ IDEA style.
  */
-export class AutoFormat extends Recipe {
+export class AutoFormat extends ScanningRecipe<AutoFormatAccumulator> {
     readonly name = "org.openrewrite.javascript.format.auto-format";
     readonly displayName = "Auto-format JavaScript/TypeScript code";
-    readonly description = "Format JavaScript and TypeScript code using a comprehensive set of formatting rules based on the project's style settings.";
+    readonly description = "Format JavaScript and TypeScript code using formatting rules auto-detected from the project's existing code style.";
+
+    initialValue(_ctx: ExecutionContext): AutoFormatAccumulator {
+        return {
+            detector: Autodetect.detector()
+        };
+    }
+
+    async scanner(acc: AutoFormatAccumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+            protected async visitJsCompilationUnit(cu: JS.CompilationUnit, ctx: ExecutionContext): Promise<J | undefined> {
+                await acc.detector.sample(cu);
+                return cu;
+            }
+        };
+    }
+
+    async editorWithData(acc: AutoFormatAccumulator): Promise<TreeVisitor<any, ExecutionContext>> {
+        // Build detected styles once (lazily on first edit)
+        if (!acc.detectedStyles) {
+            acc.detectedStyles = acc.detector.build();
+        }
 
-    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
-        return new AutoformatVisitor();
+        // Pass detected styles to the AutoformatVisitor
+        // Autodetect is a NamedStyles, so pass it as an array
+        return new AutoformatVisitor(undefined, [acc.detectedStyles]);
     }
 }

package/src/javascript/style.ts

@@ -498,3 +498,35 @@ export function styleFromSourceFile(styleKind: string, sourceFile: Tree): Style
     }
     return IntelliJ.TypeScript.defaults.styles.find(style => style.kind === styleKind) as Style;
 }
+
+/**
+ * Get a style by kind, with passed-in styles taking precedence over source file styles.
+ * Falls back to IntelliJ defaults if no style is found.
+ *
+ * @param styleKind The kind of style to retrieve
+ * @param sourceFile The source file to check for styles
+ * @param styles Optional array of NamedStyles that take precedence over source file styles
+ */
+export function getStyle(styleKind: string, sourceFile: Tree, styles?: NamedStyles[]): Style | undefined {
+    // First check passed-in styles (highest precedence)
+    if (styles) {
+        for (const namedStyle of styles) {
+            const found = namedStyle.styles.find(s => s.kind === styleKind);
+            if (found) {
+                return found;
+            }
+        }
+    }
+
+    // Then check source file markers
+    const namedStyles = sourceFile.markers.markers.filter(marker => marker.kind === MarkersKind.NamedStyles) as NamedStyles[];
+    for (const namedStyle of namedStyles) {
+        const found = namedStyle.styles.find(s => s.kind === styleKind);
+        if (found) {
+            return found;
+        }
+    }
+
+    // Fall back to defaults
+    return IntelliJ.TypeScript.defaults.styles.find(style => style.kind === styleKind) as Style;
+}