@openrewrite/rewrite 8.69.0 → 8.69.1

package/src/javascript/format/whitespace-reconciler.ts

@@ -0,0 +1,345 @@
+/*
+ * 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 {isIdentifier, isLiteral, isSpace, J, Type} from '../../java';
+import {produce} from "immer";
+
+/**
+ * Union type for all tree node types that the reconciler handles.
+ * This includes J nodes and their wrapper types.
+ */
+type TreeNode = J | J.RightPadded<J> | J.LeftPadded<J> | J.Container<J> | J.Space;
+
+/**
+ * Type guard to check if a value has a kind property (is a tree node or wrapper).
+ */
+function hasKind(value: unknown): value is { kind: string } {
+    return value !== null &&
+        typeof value === 'object' &&
+        'kind' in value &&
+        typeof (value as { kind: unknown }).kind === 'string';
+}
+
+/**
+ * Tree nodes that can be visited by visitNode (excludes Space which is handled separately).
+ */
+type VisitableNode = Exclude<TreeNode, J.Space>;
+
+/**
+ * Type guard to check if a value is a VisitableNode (J, LeftPadded, RightPadded, or Container).
+ * This is used after hasKind() to further narrow the type for visitNode().
+ */
+function isVisitableNode(value: { kind: string }): value is VisitableNode {
+    const kind = value.kind;
+    // Check for wrapper kinds first (more specific)
+    if (kind === J.Kind.LeftPadded || kind === J.Kind.RightPadded || kind === J.Kind.Container) {
+        return true;
+    }
+    // All other non-Space tree nodes with valid kind strings are J nodes
+    // Space is handled separately before this check
+    return kind !== J.Kind.Space && !kind.startsWith('org.openrewrite.java.tree.JavaType$');
+}
+
+/**
+ * A visitor that reconciles whitespace from a formatted tree into the original tree.
+ * Walks both trees in parallel and copies whitespace (prefix, before, after) from
+ * the formatted tree to the original.
+ *
+ * The result preserves the original AST's structure, types, and markers while
+ * applying the formatted tree's whitespace.
+ *
+ * When a target subtree is specified, the reconciler only applies whitespace changes
+ * to that subtree and its descendants, leaving surrounding code unchanged.
+ *
+ * When stopAfter is specified, the reconciler stops applying changes after exiting
+ * that node, leaving all subsequent nodes with their original whitespace.
+ */
+export class WhitespaceReconciler {
+    /**
+     * Flag indicating whether the trees have compatible structure.
+     */
+    private compatible: boolean = true;
+
+    /**
+     * The subtree to reconcile (by reference). If undefined, reconcile everything.
+     * Can be a J node, RightPadded, LeftPadded, or Container.
+     */
+    private targetSubtree?: TreeNode;
+
+    /**
+     * The node to stop after (by reference). Once we exit this node, stop reconciling.
+     * Can be a J node, RightPadded, LeftPadded, or Container.
+     */
+    private stopAfterNode?: TreeNode;
+
+    /**
+     * Tracks the reconciliation state:
+     * - 'searching': Walking but not yet inside target subtree
+     * - 'reconciling': Inside target subtree, applying changes
+     * - 'done': Exited target subtree or stopAfter node, no more changes
+     */
+    private reconcileState: 'searching' | 'reconciling' | 'done' = 'reconciling';
+
+    /**
+     * Reconciles whitespace from a formatted tree into the original tree.
+     *
+     * @param original The original tree (with types, markers, etc.)
+     * @param formatted The formatted tree (with desired whitespace)
+     * @param targetSubtree Optional subtree to limit reconciliation to (by reference).
+     *                      Can be a J node, RightPadded, LeftPadded, or Container.
+     *                      If provided, only this subtree and its descendants will have
+     *                      whitespace and markers applied.
+     * @param stopAfter Optional node to stop reconciliation after (by reference).
+     *                  Once we exit this node, no more changes are applied.
+     * @returns The original tree with whitespace from the formatted tree
+     */
+    reconcile(original: J, formatted: J, targetSubtree?: TreeNode, stopAfter?: TreeNode): J {
+        this.compatible = true;
+        this.targetSubtree = targetSubtree;
+        this.stopAfterNode = stopAfter;
+        this.reconcileState = targetSubtree ? 'searching' : 'reconciling';
+
+        // We know original and formatted are J nodes, so result will be J
+        return this.visitNode(original, formatted) as J;
+    }
+
+    /**
+     * Returns whether the reconciliation was successful (structures were compatible).
+     */
+    isCompatible(): boolean {
+        return this.compatible;
+    }
+
+    /**
+     * Marks structure as incompatible and returns the original unchanged.
+     */
+    private structureMismatch<T>(t: T): T {
+        this.compatible = false;
+        return t;
+    }
+
+    /**
+     * Visit a property value, handling all the different types appropriately.
+     * This is the central entry point for visiting any node, including wrappers.
+     *
+     * @returns The reconciled value (original structure with formatted whitespace)
+     */
+    private visitProperty(original: unknown, formatted: unknown): unknown {
+        // Handle null/undefined
+        if (original == null || formatted == null) {
+            if (original !== formatted) {
+                return this.structureMismatch(original);
+            }
+            return original;
+        }
+
+        // Type nodes - short-circuit, keep original (types are expensive to compute)
+        // Check this first as isType already validates the kind property
+        if (Type.isType(original)) {
+            return original;
+        }
+
+        // Check if this is a tree node (has a kind property)
+        if (!hasKind(original)) {
+            // Primitive values or non-tree objects - copy from formatted when reconciling
+            // This handles things like valueSource (quote style) which is formatting
+            if (this.shouldReconcile() && formatted !== original) {
+                return formatted;
+            }
+            return original;
+        }
+
+        // Space nodes - copy when reconciling, don't recurse
+        if (isSpace(original)) {
+            return this.shouldReconcile() ? formatted : original;
+        }
+
+        // Track entering target subtree (using referential equality)
+        const isTargetSubtree = this.targetSubtree !== undefined && original === this.targetSubtree;
+        const isStopAfterNode = this.stopAfterNode !== undefined && original === this.stopAfterNode;
+        const previousState = this.reconcileState;
+        if (isTargetSubtree && this.reconcileState === 'searching') {
+            this.reconcileState = 'reconciling';
+        }
+
+        try {
+            // All tree nodes (J, RightPadded, LeftPadded, Container) go through visitNode
+            // After hasKind() and isSpace()/isType() checks, we know this is a VisitableNode
+            if (!isVisitableNode(original) || !hasKind(formatted) || !isVisitableNode(formatted)) {
+                return this.structureMismatch(original);
+            }
+            return this.visitNode(original, formatted);
+        } finally {
+            // Track exiting the target subtree
+            if (isTargetSubtree && previousState === 'searching') {
+                this.reconcileState = 'done';
+            }
+            // Track exiting the stopAfter node - stop reconciling after this
+            if (isStopAfterNode && previousState === 'reconciling') {
+                this.reconcileState = 'done';
+            }
+        }
+    }
+
+    /**
+     * Visit all properties of a tree node (J, RightPadded, LeftPadded, Container).
+     * Copies Space values and markers when reconciling, visits everything else.
+     *
+     * Note: The return type may differ from the input type in cases of semantic
+     * equivalence (e.g., Identifier↔Literal with quoteProps), but will always
+     * be a valid VisitableNode.
+     *
+     * @param original Tree node with kind property
+     * @param formatted Corresponding formatted tree node
+     * @returns The original with whitespace from formatted applied
+     */
+    private visitNode(
+        original: VisitableNode,
+        formatted: VisitableNode
+    ): VisitableNode {
+        if (!this.compatible) {
+            return original;
+        }
+
+        // Check if kinds match
+        if (original.kind !== formatted.kind) {
+            // Check if this is a valid semantic equivalence (e.g., quoteProps changing Identifier↔Literal)
+            if (this.shouldReconcile() && this.isSemanticEquivalent(original, formatted)) {
+                // Use the formatted node but preserve type information from original
+                // isSemanticEquivalent only returns true for Identifier/Literal pairs
+                return this.copyWithPreservedTypes(
+                    original as J.Identifier | J.Literal,
+                    formatted as J.Identifier | J.Literal
+                );
+            }
+            return this.structureMismatch(original);
+        }
+
+        let result: VisitableNode = original;
+
+        // Visit all properties
+        for (const key of Object.keys(original)) {
+            // Skip: kind, id, type properties
+            if (key === 'kind' || key === 'id' ||
+                key === 'type' || key === 'fieldType' || key === 'variableType' ||
+                key === 'methodType' || key === 'constructorType') {
+                continue;
+            }
+
+            const originalValue = (original as Record<string, unknown>)[key];
+            const formattedValue = (formatted as Record<string, unknown>)[key];
+
+            // Space values and markers: copy from formatted when reconciling
+            if ((isSpace(originalValue)) || key === 'markers') {
+                if (this.shouldReconcile() && formattedValue !== originalValue) {
+                    result = produce(result, (draft) => {
+                        (draft as Record<string, unknown>)[key] = formattedValue;
+                    });
+                }
+                continue;
+            }
+
+            // Handle arrays
+            if (Array.isArray(originalValue)) {
+                if (!Array.isArray(formattedValue) || originalValue.length !== formattedValue.length) {
+                    return this.structureMismatch(original);
+                }
+
+                const newArray: unknown[] = [];
+                let changed = false;
+                for (let i = 0; i < originalValue.length; i++) {
+                    const visited = this.visitProperty(originalValue[i], formattedValue[i]);
+                    if (!this.compatible) return original;
+                    newArray.push(visited);
+                    if (visited !== originalValue[i]) {
+                        changed = true;
+                    }
+                }
+
+                if (changed) {
+                    result = produce(result, (draft) => {
+                        (draft as Record<string, unknown>)[key] = newArray;
+                    });
+                }
+            } else {
+                // Visit the property
+                const visited = this.visitProperty(originalValue, formattedValue);
+                if (!this.compatible) return original;
+
+                if (visited !== originalValue) {
+                    result = produce(result, (draft) => {
+                        (draft as Record<string, unknown>)[key] = visited;
+                    });
+                }
+            }
+        }
+
+        return result;
+    }
+
+    /**
+     * Check if we should apply whitespace changes at the current position.
+     */
+    private shouldReconcile(): boolean {
+        return this.reconcileState === 'reconciling';
+    }
+
+    /**
+     * Checks if two nodes with different kinds are semantically equivalent.
+     * This handles cases like Prettier's quoteProps option which can change
+     * property names between Identifier and Literal forms.
+     */
+    private isSemanticEquivalent(original: VisitableNode, formatted: VisitableNode): boolean {
+        // Identifier → Literal equivalence (for property names with quoteProps)
+        if (isIdentifier(original) && isLiteral(formatted)) {
+            return original.simpleName === formatted.value;
+        }
+
+        // Literal → Identifier equivalence
+        if (isLiteral(original) && isIdentifier(formatted)) {
+            return original.value === formatted.simpleName;
+        }
+
+        return false;
+    }
+
+    /**
+     * Creates a copy of the formatted node with type information preserved from the original.
+     * Used when we accept a structural change from Prettier (Identifier ↔ Literal)
+     * but need to keep type attribution from the original.
+     *
+     * Only preserves `type` and `fieldType` since those are the only type-related
+     * fields on J.Identifier and J.Literal.
+     */
+    private copyWithPreservedTypes(
+        original: J.Identifier | J.Literal,
+        formatted: J.Identifier | J.Literal
+    ): J.Identifier | J.Literal {
+        const result: Record<string, unknown> = { ...formatted };
+
+        // Preserve type attribution - both Identifier and Literal have `type`
+        if (original.type !== undefined) {
+            result.type = original.type;
+        }
+
+        // Preserve fieldType - only Identifier has this, but safe to check
+        if ('fieldType' in original && original.fieldType !== undefined) {
+            result.fieldType = original.fieldType;
+        }
+
+        // Cast via unknown since we're modifying a copy of a valid Identifier/Literal
+        return result as unknown as J.Identifier | J.Literal;
+    }
+}

package/src/javascript/markers.ts

@@ -18,6 +18,7 @@ import {J} from "../java";
 import {JS} from "./tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "../rpc";
 import {createDraft, finishDraft} from "immer";
+import {PrettierStyle, StyleKind} from "./style";
 
 declare module "./tree" {
     namespace JS {
@@ -104,3 +105,21 @@ registerPrefixedMarkerCodec<Generator>(JS.Markers.Generator);
 registerPrefixedMarkerCodec<NonNullAssertion>(JS.Markers.NonNullAssertion);
 registerPrefixedMarkerCodec<Spread>(JS.Markers.Spread);
 registerPrefixedMarkerCodec<FunctionDeclaration>(JS.Markers.FunctionDeclaration);
+
+// Register codec for PrettierStyle (a NamedStyles that contains Prettier configuration)
+// Only serialize the variable fields; constant fields are defined in the class
+RpcCodecs.registerCodec(StyleKind.PrettierStyle, {
+    async rpcReceive(before: PrettierStyle, q: RpcReceiveQueue): Promise<PrettierStyle> {
+        const draft = createDraft(before);
+        (draft as any).id = await q.receive(before.id);
+        (draft as any).config = await q.receive(before.config);
+        (draft as any).prettierVersion = await q.receive(before.prettierVersion);
+        return finishDraft(draft) as PrettierStyle;
+    },
+
+    async rpcSend(after: PrettierStyle, q: RpcSendQueue): Promise<void> {
+        await q.getAndSend(after, a => a.id);
+        await q.getAndSend(after, a => a.config);
+        await q.getAndSend(after, a => a.prettierVersion);
+    }
+});

package/src/javascript/parser.ts

@@ -48,6 +48,7 @@ import {
 } from "./parser-utils";
 import {JavaScriptTypeMapping} from "./type-mapping";
 import {produce} from "immer";
+import {PrettierConfigLoader} from "./format/prettier-config-loader";
 import Kind = JS.Kind;
 import ComputedPropertyName = JS.ComputedPropertyName;
 import Attribute = JSX.Attribute;
@@ -55,20 +56,24 @@ import SpreadAttribute = JSX.SpreadAttribute;
 
 export interface JavaScriptParserOptions extends ParserOptions {
     styles?: NamedStyles[],
-    sourceFileCache?: Map<string, ts.SourceFile>
+    sourceFileCache?: Map<string, ts.SourceFile>,
 }
 
 function getScriptKindFromFileName(fileName: string): ts.ScriptKind {
-    const ext = fileName.toLowerCase();
-    if (ext.endsWith('.tsx')) return ts.ScriptKind.TSX;
-    if (ext.endsWith('.jsx')) return ts.ScriptKind.JSX;
-    if (ext.endsWith('.ts')) return ts.ScriptKind.TS;
-    if (ext.endsWith('.js')) return ts.ScriptKind.JS;
-    if (ext.endsWith('.mjs')) return ts.ScriptKind.JS;
-    if (ext.endsWith('.cjs')) return ts.ScriptKind.JS;
-    if (ext.endsWith('.mts')) return ts.ScriptKind.TS;
-    if (ext.endsWith('.cts')) return ts.ScriptKind.TS;
-    return ts.ScriptKind.TS;
+    const dotIndex = fileName.lastIndexOf('.');
+    if (dotIndex === -1) return ts.ScriptKind.TS;
+    const ext = fileName.slice(dotIndex);
+    switch (ext) {
+        case '.tsx': return ts.ScriptKind.TSX;
+        case '.jsx': return ts.ScriptKind.JSX;
+        case '.ts':
+        case '.mts':
+        case '.cts': return ts.ScriptKind.TS;
+        case '.js':
+        case '.mjs':
+        case '.cjs': return ts.ScriptKind.JS;
+        default: return ts.ScriptKind.TS;
+    }
 }
 
 export class JavaScriptParser extends Parser {
@@ -83,7 +88,7 @@ export class JavaScriptParser extends Parser {
             ctx,
             relativeTo,
             styles,
-            sourceFileCache
+            sourceFileCache,
         }: JavaScriptParserOptions = {},
     ) {
         super({ctx, relativeTo});
@@ -91,6 +96,7 @@ export class JavaScriptParser extends Parser {
             target: ts.ScriptTarget.Latest,
             module: ts.ModuleKind.CommonJS,
             moduleResolution: ts.ModuleResolutionKind.Node10,
+            noEmit: true,
             allowJs: true,
             checkJs: true,
             esModuleInterop: true,
@@ -105,6 +111,75 @@ export class JavaScriptParser extends Parser {
         this.sourceFileCache = sourceFileCache;
     }
 
+    /**
+     * Parses a single source file using only ts.createSourceFile(), bypassing
+     * the TypeScript type checker entirely. This is significantly faster than
+     * the full parse() method when type information is not needed.
+     *
+     * Use this method for formatting-only operations where AST structure is
+     * needed but type attribution is not required.
+     *
+     * @param input The parser input containing the source code
+     * @returns The parsed SourceFile, or a ParseExceptionResult if parsing failed
+     */
+    async parseOnly(input: ParserInput): Promise<SourceFile> {
+        const filePath = parserInputFile(input);
+        const sourcePath = this.relativeTo && !path.isAbsolute(filePath)
+            ? path.join(this.relativeTo, filePath)
+            : filePath;
+
+        const sourceText = parserInputRead(input);
+        const scriptKind = getScriptKindFromFileName(sourcePath);
+
+        // Create source file directly without a Program
+        const sourceFileOptions: ts.CreateSourceFileOptions = {
+            languageVersion: ts.ScriptTarget.Latest,
+            jsDocParsingMode: ts.JSDocParsingMode.ParseNone
+        };
+
+        const tsSourceFile = ts.createSourceFile(
+            sourcePath,
+            sourceText,
+            sourceFileOptions,
+            true, // setParentNodes
+            scriptKind
+        );
+
+        // Check for parse-time syntax errors (accessible via internal parseDiagnostics)
+        // TypeScript stores parse errors directly on the source file
+        const parseDiagnostics = (tsSourceFile as any).parseDiagnostics as ts.Diagnostic[] | undefined;
+        if (parseDiagnostics && parseDiagnostics.length > 0) {
+            const errors = parseDiagnostics.filter(d => d.category === ts.DiagnosticCategory.Error);
+            if (errors.length > 0) {
+                const errorMessages = errors.map(e => {
+                    if (e.file && e.start !== undefined) {
+                        const { line, character } = ts.getLineAndCharacterOfPosition(e.file, e.start);
+                        const message = ts.flattenDiagnosticMessageText(e.messageText, "\n");
+                        return `(${line + 1},${character + 1}): ${message} [${e.code}]`;
+                    }
+                    return `${ts.flattenDiagnosticMessageText(e.messageText, "\n")} [${e.code}]`;
+                }).join('; ');
+                return this.error(input, new SyntaxError(`Compiler error(s): ${errorMessages}`));
+            }
+        }
+
+        try {
+            // Parse without type mapping (no type checker available)
+            const result = new JavaScriptParserVisitor(tsSourceFile, this.relativePath(input), undefined)
+                .visit(tsSourceFile) as SourceFile;
+
+            if (this.styles) {
+                const styles = this.styles;
+                return produce(result, draft => {
+                    draft.markers.markers = draft.markers.markers.concat(styles);
+                });
+            }
+            return result;
+        } catch (error) {
+            return this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
+        }
+    }
+
     // noinspection JSUnusedGlobalSymbols
     reset(): this {
         this.sourceFileCache && this.sourceFileCache.clear();
@@ -255,11 +330,16 @@ export class JavaScriptParser extends Parser {
         // Update the oldProgram reference
         this.oldProgram = program;
 
-        const typeChecker = program.getTypeChecker();
+        // Detect Prettier config for the project
+        const prettierLoader = this.relativeTo ? new PrettierConfigLoader(this.relativeTo) : undefined;
+        if (prettierLoader) {
+            await prettierLoader.detectPrettier();
+        }
 
         // Create a single JavaScriptTypeMapping instance to be shared across all files in this parse batch.
         // This ensures that TypeScript types with the same type.id map to the same Type instance,
         // preventing duplicate Type.Class, Type.Parameterized, etc. instances.
+        const typeChecker = program.getTypeChecker();
         const typeMapping = new JavaScriptTypeMapping(typeChecker);
 
         for (const input of inputFiles.values()) {
@@ -283,6 +363,9 @@ export class JavaScriptParser extends Parser {
             }
 
             try {
+                // Get Prettier config marker for this file (if Prettier is available)
+                const prettierConfigMarker = await prettierLoader?.getConfigMarker(filePath);
+
                 yield produce(
                     new JavaScriptParserVisitor(sourceFile, this.relativePath(input), typeMapping)
                         .visit(sourceFile) as SourceFile,
@@ -290,6 +373,9 @@ export class JavaScriptParser extends Parser {
                         if (this.styles) {
                             draft.markers.markers = draft.markers.markers.concat(this.styles);
                         }
+                        if (prettierConfigMarker) {
+                            draft.markers.markers = draft.markers.markers.concat([prettierConfigMarker]);
+                        }
                     });
             } catch (error) {
                 yield this.error(input, error instanceof Error ? error : new Error('Parser threw unknown error: ' + error));
@@ -309,12 +395,12 @@ for (const [key, value] of Object.entries(ts.SyntaxKind)) {
 
 // noinspection JSUnusedGlobalSymbols
 export class JavaScriptParserVisitor {
-    private readonly typeMapping: JavaScriptTypeMapping;
+    private readonly typeMapping?: JavaScriptTypeMapping;
 
     constructor(
         private readonly sourceFile: ts.SourceFile,
         private readonly sourcePath: string,
-        typeMapping: JavaScriptTypeMapping) {
+        typeMapping?: JavaScriptTypeMapping) {
         this.typeMapping = typeMapping;
     }
 
@@ -396,6 +482,7 @@ export class JavaScriptParserVisitor {
             });
         }
 
+        const eof = this.prefix(node.endOfFileToken);
         let statements = this.semicolonPaddedStatementList(node.statements);
 
         // If there's trailing whitespace/comments after the shebang, prepend to first statement's prefix
@@ -425,7 +512,7 @@ export class JavaScriptParserVisitor {
             statements: shebangStatement
                 ? [shebangStatement, ...statements]
                 : statements,
-            eof: this.prefix(node.endOfFileToken)
+            eof
         };
     }
 
@@ -4284,19 +4371,19 @@ export class JavaScriptParserVisitor {
     }
 
     private mapType(node: ts.Node): Type | undefined {
-        return this.typeMapping.type(node);
+        return this.typeMapping?.type(node);
     }
 
     private mapPrimitiveType(node: ts.Node): Type.Primitive {
-        return this.typeMapping.primitiveType(node);
+        return this.typeMapping?.primitiveType(node) ?? Type.Primitive.None;
     }
 
     private mapVariableType(node: ts.NamedDeclaration): Type.Variable | undefined {
-        return this.typeMapping.variableType(node);
+        return this.typeMapping?.variableType(node);
     }
 
     private mapMethodType(node: ts.Node): Type.Method | undefined {
-        return this.typeMapping.methodType(node);
+        return this.typeMapping?.methodType(node);
     }
 
     private mapCommaSeparatedList<T extends J>(nodes: readonly ts.Node[]): J.Container<T> {

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

@@ -22,6 +22,9 @@ import {Autodetect, Detector} from "../autodetect";
 import {JavaScriptVisitor} from "../visitor";
 import {JS} from "../tree";
 import {J} from "../../java";
+import {findMarker, MarkersKind} from "../../markers";
+import {StyleKind} from "../style";
+import {NamedStyles} from "../../style";
 
 /**
  * Accumulator for the AutoFormat scanning recipe.
@@ -32,6 +35,24 @@ interface AutoFormatAccumulator {
     detectedStyles?: Autodetect;
 }
 
+/**
+ * Checks if a compilation unit already has formatting styles attached.
+ * Returns true if either PrettierStyle or Autodetect markers are present.
+ */
+function hasFormattingStyles(cu: JS.CompilationUnit): boolean {
+    // Check for PrettierStyle marker
+    if (findMarker(cu, StyleKind.PrettierStyle)) {
+        return true;
+    }
+
+    // Check for Autodetect marker (NamedStyles with specific name)
+    const namedStyles = cu.markers.markers.filter(
+        m => m.kind === MarkersKind.NamedStyles
+    ) as NamedStyles[];
+
+    return namedStyles.some(s => s.name === "org.openrewrite.javascript.Autodetect");
+}
+
 /**
  * Formats JavaScript/TypeScript code using a comprehensive set of formatting rules.
  *
@@ -45,6 +66,9 @@ interface AutoFormatAccumulator {
  * - ES6 import/export brace spacing
  *
  * If no clear style is detected, defaults to IntelliJ IDEA style.
+ *
+ * Files with existing formatting styles (PrettierStyle or Autodetect markers)
+ * are skipped during style detection since they already have their formatting configured.
  */
 export class AutoFormat extends ScanningRecipe<AutoFormatAccumulator> {
     readonly name = "org.openrewrite.javascript.format.auto-format";
@@ -60,7 +84,10 @@ export class AutoFormat extends ScanningRecipe<AutoFormatAccumulator> {
     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);
+                // Skip sampling files that already have formatting styles attached
+                if (!hasFormattingStyles(cu)) {
+                    await acc.detector.sample(cu);
+                }
                 return cu;
             }
         };