@openrewrite/rewrite 8.70.0-20251219-160440 → 8.70.0-20251219-215811

package/src/javascript/style.ts

@@ -28,7 +28,8 @@ export const StyleKind = {
     WrappingAndBracesStyle: "org.openrewrite.javascript.style.WrappingAndBracesStyle",
     BlankLinesStyle: "org.openrewrite.javascript.style.BlankLinesStyle",
     TabsAndIndentsStyle: "org.openrewrite.javascript.style.TabsAndIndentsStyle",
-    PrettierStyle: "org.openrewrite.javascript.style.PrettierStyle"
+    PrettierStyle: "org.openrewrite.javascript.style.PrettierStyle",
+    Autodetect: "org.openrewrite.javascript.style.Autodetect"
 } as const;
 
 /**
@@ -41,32 +42,46 @@ export const StyleKind = {
  * When this style is present, AutoformatVisitor will use Prettier for formatting
  * instead of the built-in formatting visitors.
  */
-export class PrettierStyle implements NamedStyles<typeof StyleKind.PrettierStyle> {
-    readonly kind = StyleKind.PrettierStyle;
-    readonly name = "org.openrewrite.javascript.Prettier";
-    readonly displayName = "Prettier";
-    readonly description = "Prettier code formatter configuration.";
-    readonly tags: string[] = [];
-    readonly styles: Style[] = [];
-
-    constructor(
-        readonly id: string,
-        /**
-         * The resolved Prettier options for this file (with overrides applied).
-         */
-        readonly config: Record<string, unknown>,
-        /**
-         * The Prettier version from the project's package.json.
-         * At formatting time, this version of Prettier will be loaded dynamically
-         * to ensure consistent formatting.
-         */
-        readonly prettierVersion?: string,
-        /**
-         * Whether this file is ignored by .prettierignore.
-         * When true, Prettier formatting should be skipped for this file.
-         */
-        readonly ignored: boolean = false
-    ) {}
+export interface PrettierStyle extends NamedStyles<typeof StyleKind.PrettierStyle> {
+    readonly kind: typeof StyleKind.PrettierStyle;
+    readonly name: "org.openrewrite.javascript.Prettier";
+    readonly displayName: "Prettier";
+    readonly description: "Prettier code formatter configuration.";
+    /**
+     * The resolved Prettier options for this file (with overrides applied).
+     */
+    readonly config: Record<string, unknown>;
+    /**
+     * The Prettier version from the project's package.json.
+     * At formatting time, this version of Prettier will be loaded dynamically
+     * to ensure consistent formatting.
+     */
+    readonly prettierVersion?: string;
+    /**
+     * Whether this file is ignored by .prettierignore.
+     * When true, Prettier formatting should be skipped for this file.
+     */
+    readonly ignored: boolean;
+}
+
+export function prettierStyle(
+    id: string,
+    config: Record<string, unknown>,
+    prettierVersion?: string,
+    ignored: boolean = false
+): PrettierStyle {
+    return {
+        kind: StyleKind.PrettierStyle,
+        id,
+        name: "org.openrewrite.javascript.Prettier",
+        displayName: "Prettier",
+        description: "Prettier code formatter configuration.",
+        tags: [],
+        styles: [],
+        config,
+        prettierVersion,
+        ignored
+    };
 }
 
 export const SpacesStyleDetailKind = {
@@ -187,7 +202,7 @@ export namespace SpacesStyle {
 }
 
 export const WrappingAndBracesStyleDetailKind = {
-    WrappingAndBracesStyleIfStatement: "org.openrewrite.java.style.WrappingAndBracesStyle$IfStatement",
+    WrappingAndBracesStyleIfStatement: "org.openrewrite.javascript.style.WrappingAndBracesStyle$IfStatement",
     WrappingAndBracesStyleKeepWhenReformatting: "org.openrewrite.javascript.style.WrappingAndBracesStyle$KeepWhenReformatting",
 } as const;
 

package/src/json/parser.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {emptyMarkers, markers, MarkersKind, ParseExceptionResult} from "../markers";
-import {Parser, ParserInput, parserInputRead} from "../parser";
+import {Parser, ParserInput, parserInputRead, Parsers} from "../parser";
 import {randomId} from "../uuid";
 import {SourceFile} from "../tree";
 import {emptySpace, Json, space} from "./tree";
@@ -534,3 +534,5 @@ class JsoncParserReader {
         } satisfies Json.Literal as Json.Literal;
     }
 }
+
+Parsers.registerParser("json", JsonParser);

package/src/markers.ts

@@ -18,7 +18,7 @@ import {asRef} from "./reference";
 
 export const MarkersKind = {
     Markers: "org.openrewrite.marker.Markers",
-    NamedStyles: "org.openrewrite.marker.NamedStyles",
+    NamedStyles: "org.openrewrite.style.NamedStyles",
     SearchResult: "org.openrewrite.marker.SearchResult",
     ParseExceptionResult: "org.openrewrite.ParseExceptionResult",
 

package/src/parser.ts

@@ -148,7 +148,7 @@ export function readSourceSync(sourcePath: ParserInput) {
 
 type ParserConstructor<T extends Parser> = new (options?: ParserOptions) => T;
 
-export type ParserType = "javascript" | "packageJson";
+export type ParserType = "javascript" | "packageJson" | "json" | "yaml" | "plainText";
 
 export class Parsers {
     private static registry = new Map<ParserType, ParserConstructor<Parser>>();

package/src/rpc/index.ts

@@ -16,11 +16,13 @@
 import {Checksum, FileAttributes, TreeKind} from "../tree";
 import {RpcCodecs, RpcReceiveQueue, RpcSendQueue} from "./queue";
 import {createDraft, finishDraft} from "immer";
-import {Markers, MarkersKind, SearchResult, MarkupError, MarkupWarn, MarkupInfo, MarkupDebug} from "../markers";
+import {Markers, MarkersKind, MarkupDebug, MarkupError, MarkupInfo, MarkupWarn, SearchResult} from "../markers";
+import {asRef} from "../reference";
 
-export * from "./queue"
-export * from "../reference"
-export * from "./rewrite-rpc"
+export * from "./queue";
+export * from "../reference";
+// rewrite-rpc is not exported here to avoid circular dependency
+// Import directly from "./rewrite-rpc" if needed
 
 RpcCodecs.registerCodec(TreeKind.Checksum, {
     async rpcReceive(before: Checksum, q: RpcReceiveQueue): Promise<Checksum> {
@@ -70,7 +72,7 @@ RpcCodecs.registerCodec(MarkersKind.Markers, {
 
     async rpcSend(after: Markers, q: RpcSendQueue): Promise<void> {
         await q.getAndSend(after, m => m.id);
-        await q.getAndSendList(after, m => m.markers, m => m.id);
+        await q.getAndSendList(after, m => m.markers.map(marker => asRef(marker)), m => m.id);
     }
 });
 

package/src/rpc/request/index.ts

@@ -17,6 +17,7 @@ export * from "./generate";
 export * from "./get-object";
 export * from "./get-recipes";
 export * from "./parse";
+export * from "./parse-project";
 export * from "./prepare-recipe";
 export * from "./print";
 export * from "./visit";

package/src/rpc/request/parse-project.ts

@@ -0,0 +1,283 @@
+/*
+ * 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 * as rpc from "vscode-jsonrpc/node";
+import * as path from "path";
+import {ExecutionContext} from "../../execution";
+import {randomId, UUID} from "../../uuid";
+import {produce} from "immer";
+import {SourceFile} from "../../tree";
+import {Parsers} from "../../parser";
+import {withMetrics} from "./metrics";
+import {DEFAULT_EXCLUSIONS, ProjectParser} from "../../javascript";
+
+/**
+ * Response item with object ID and source file type for proper deserialization.
+ */
+export interface ParseProjectResponseItem {
+    id: UUID;
+    sourceFileType: string;
+}
+
+/**
+ * RPC request to parse an entire project directory.
+ * Discovers and parses:
+ * - JavaScript/TypeScript source files
+ * - package.json files (with NodeResolutionResult markers)
+ * - Lock files (package-lock.json as JSON, yarn.lock/pnpm-lock.yaml as YAML)
+ *
+ * Uses ProjectParser for file discovery and Prettier detection.
+ */
+export class ParseProject {
+    constructor(
+        private readonly projectPath: string,
+        private readonly exclusions?: string[]
+    ) {}
+
+    static handle(
+        connection: rpc.MessageConnection,
+        localObjects: Map<string, ((input: string) => any) | any>,
+        metricsCsv?: string
+    ): void {
+        connection.onRequest(
+            new rpc.RequestType<ParseProject, ParseProjectResponseItem[], Error>("ParseProject"),
+            withMetrics<ParseProject, ParseProjectResponseItem[]>(
+                "ParseProject",
+                metricsCsv,
+                (context) => async (request) => {
+                    context.target = request.projectPath;
+
+                    const projectPath = path.resolve(request.projectPath);
+                    const exclusions = request.exclusions ?? DEFAULT_EXCLUSIONS;
+
+                    // Use ProjectParser for file discovery and Prettier detection
+                    const projectParser = new ProjectParser(projectPath, {exclusions});
+                    const discovered = await projectParser.discoverFiles();
+                    const prettierLoader = await projectParser.createPrettierLoader();
+
+                    const resultItems: ParseProjectResponseItem[] = [];
+                    const ctx = new ExecutionContext();
+
+                    // Parse package.json files (these get NodeResolutionResult markers)
+                    if (discovered.packageJsonFiles.length > 0) {
+                        const parser = Parsers.createParser("packageJson", {
+                            ctx,
+                            relativeTo: projectPath
+                        });
+                        const generator = parser.parse(...discovered.packageJsonFiles);
+
+                        for (const _ of discovered.packageJsonFiles) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.json.tree.Json$Document" // break cycle
+                            });
+                        }
+                    }
+
+                    // Parse JSON lock files
+                    if (discovered.lockFiles.json.length > 0) {
+                        const parser = Parsers.createParser("json", {ctx, relativeTo: projectPath});
+                        const generator = parser.parse(...discovered.lockFiles.json);
+
+                        for (const _ of discovered.lockFiles.json) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.json.tree.Json$Document" // break cycle
+                            });
+                        }
+                    }
+
+                    // Parse YAML lock files
+                    if (discovered.lockFiles.yaml.length > 0) {
+                        const parser = Parsers.createParser("yaml", {ctx, relativeTo: projectPath});
+                        const generator = parser.parse(...discovered.lockFiles.yaml);
+
+                        for (const _ of discovered.lockFiles.yaml) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.yaml.tree.Yaml$Documents" // break cycle
+                            });
+                        }
+                    }
+
+                    // Parse text lock files (yarn.lock Classic)
+                    if (discovered.lockFiles.text.length > 0) {
+                        const parser = Parsers.createParser("plainText", {ctx, relativeTo: projectPath});
+                        const generator = parser.parse(...discovered.lockFiles.text);
+
+                        for (const _ of discovered.lockFiles.text) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.text.PlainText" // break cycle
+                            });
+                        }
+                    }
+
+                    // Parse JavaScript/TypeScript source files
+                    if (discovered.jsFiles.length > 0) {
+                        const parser = Parsers.createParser("javascript", {
+                            ctx,
+                            relativeTo: projectPath
+                        });
+
+                        // Check if Prettier is available
+                        const detection = await prettierLoader.detectPrettier();
+
+                        if (detection.available) {
+                            // Prettier is available: add per-file PrettierStyle markers
+                            const generator = parser.parse(...discovered.jsFiles);
+
+                            for (const filePath of discovered.jsFiles) {
+                                const id = randomId();
+                                localObjects.set(id, async (id: string) => {
+                                    const sourceFile: SourceFile = (await generator.next()).value;
+                                    // Add PrettierStyle marker if Prettier is available
+                                    const prettierMarker = await prettierLoader.getConfigMarker(filePath);
+                                    return produce(sourceFile, (draft) => {
+                                        draft.id = id;
+                                        if (prettierMarker) {
+                                            draft.markers.markers = draft.markers.markers.concat([prettierMarker]);
+                                        }
+                                    });
+                                });
+                                resultItems.push({
+                                    id,
+                                    sourceFileType: "org.openrewrite.javascript.tree.JS$CompilationUnit" // break cycle
+                                });
+                            }
+                        } else {
+                            // Prettier is NOT available: auto-detect styles from parsed files
+                            // Parse all files first to sample them
+                            const parsedFiles: {id: string, sourceFile: SourceFile}[] = [];
+                            for await (const sourceFile of parser.parse(...discovered.jsFiles)) {
+                                const id = randomId();
+                                parsedFiles.push({id, sourceFile});
+                            }
+
+                            // Sample all parsed files and build Autodetect marker using ProjectParser helper
+                            const autodetectMarker = await projectParser.buildAutodetectMarker(
+                                parsedFiles.map(p => p.sourceFile)
+                            );
+
+                            // Store thunks that add the Autodetect marker
+                            for (const {id, sourceFile} of parsedFiles) {
+                                localObjects.set(id, async (newId: string) => {
+                                    return produce(sourceFile, (draft) => {
+                                        draft.id = newId;
+                                        draft.markers.markers = draft.markers.markers.concat([autodetectMarker]);
+                                    });
+                                });
+                                resultItems.push({
+                                    id,
+                                    sourceFileType: "org.openrewrite.javascript.tree.JS$CompilationUnit" // break cycle
+                                });
+                            }
+                        }
+                    }
+
+                    // Parse other YAML files
+                    if (discovered.yamlFiles.length > 0) {
+                        const parser = Parsers.createParser("yaml", {ctx, relativeTo: projectPath});
+                        const generator = parser.parse(...discovered.yamlFiles);
+
+                        for (const _ of discovered.yamlFiles) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.yaml.tree.Yaml$Documents" // break cycle
+                            });
+                        }
+                    }
+
+                    // Parse other JSON files
+                    if (discovered.jsonFiles.length > 0) {
+                        const parser = Parsers.createParser("json", {ctx, relativeTo: projectPath});
+                        const generator = parser.parse(...discovered.jsonFiles);
+
+                        for (const _ of discovered.jsonFiles) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.json.tree.Json$Document" // break cycle
+                            });
+                        }
+                    }
+
+                    // Parse text config files (.prettierignore, .gitignore, etc.)
+                    if (discovered.textFiles.length > 0) {
+                        const parser = Parsers.createParser("plainText", {ctx, relativeTo: projectPath});
+                        const generator = parser.parse(...discovered.textFiles);
+
+                        for (const _ of discovered.textFiles) {
+                            const id = randomId();
+                            localObjects.set(id, async (id: string) => {
+                                const sourceFile: SourceFile = (await generator.next()).value;
+                                return produce(sourceFile, (draft) => {
+                                    draft.id = id;
+                                });
+                            });
+                            resultItems.push({
+                                id,
+                                sourceFileType: "org.openrewrite.text.PlainText" // break cycle
+                            });
+                        }
+                    }
+
+                    return resultItems;
+                }
+            )
+        );
+    }
+}

package/src/rpc/rewrite-rpc.ts

@@ -24,6 +24,7 @@ import {
     GetObject,
     GetRecipes,
     Parse,
+    ParseProject,
     PrepareRecipe,
     PrepareRecipeResponse,
     Print,
@@ -90,6 +91,7 @@ export class RewriteRpc {
         GetLanguages.handle(this.connection, options.metricsCsv);
         PrepareRecipe.handle(this.connection, registry, preparedRecipes, options.metricsCsv);
         Parse.handle(this.connection, this.localObjects, options.metricsCsv);
+        ParseProject.handle(this.connection, this.localObjects, options.metricsCsv);
         Print.handle(this.connection, getObject, options.logger, options.metricsCsv);
         InstallRecipes.handle(this.connection, options.recipeInstallDir ?? ".rewrite", registry, options.logger, options.metricsCsv);
 

package/src/text/parser.ts

@@ -13,7 +13,7 @@
  * See the License for the specific language governing permissions and
  * limitations under the License.
  */
-import {Parser, ParserInput, readSourceSync} from "../parser";
+import {Parser, ParserInput, readSourceSync, Parsers} from "../parser";
 import {PlainText} from "./tree";
 import {randomId} from "../uuid";
 import {emptyMarkers} from "../markers";
@@ -32,3 +32,5 @@ export class PlainTextParser extends Parser {
         }
     }
 }
+
+Parsers.registerParser("plainText", PlainTextParser);

package/src/yaml/parser.ts

@@ -14,7 +14,7 @@
  * limitations under the License.
  */
 import {emptyMarkers, markers, MarkersKind, ParseExceptionResult} from "../markers";
-import {Parser, ParserInput, parserInputRead} from "../parser";
+import {Parser, ParserInput, parserInputRead, Parsers} from "../parser";
 import {randomId} from "../uuid";
 import {SourceFile} from "../tree";
 import {Yaml} from "./tree";
@@ -389,15 +389,49 @@ class YamlCstReader {
 
     private convertSequenceEntry(item: CstCollectionItem, dash: boolean, pendingPrefix: string = ""): {entry: Yaml.SequenceEntry, trailingContent: string} {
         // Build prefix from start tokens, but exclude the dash indicator itself
+        // Also extract anchor and tag if present
         let prefix = pendingPrefix;
         let afterDashSpace = "";
         let seenDash = false;
+        let anchorForValue: Yaml.Anchor | undefined;
+        let tagForValue: Yaml.Tag | undefined;
 
-        for (const token of item.start || []) {
+        const startTokens = item.start || [];
+        for (let i = 0; i < startTokens.length; i++) {
+            const token = startTokens[i];
             if (token.type === 'seq-item-ind') {
                 seenDash = true;
             } else if (seenDash) {
-                afterDashSpace += token.source;
+                if (token.type === 'anchor') {
+                    // Collect all remaining tokens after anchor as postfix
+                    let postfix = "";
+                    for (let j = i + 1; j < startTokens.length; j++) {
+                        const nextToken = startTokens[j];
+                        if (nextToken.type === 'tag') {
+                            tagForValue = this.parseTagTokenWithSuffix(nextToken.source, postfix, startTokens, j + 1);
+                            postfix = "";
+                            break;
+                        } else {
+                            postfix += nextToken.source;
+                        }
+                    }
+                    anchorForValue = {
+                        kind: Yaml.Kind.Anchor,
+                        id: randomId(),
+                        prefix: afterDashSpace,
+                        markers: emptyMarkers,
+                        postfix,
+                        key: token.source.substring(1) // Remove &
+                    };
+                    afterDashSpace = "";
+                    break; // We've consumed all remaining tokens
+                } else if (token.type === 'tag') {
+                    tagForValue = this.parseTagTokenWithSuffix(token.source, afterDashSpace, startTokens, i + 1);
+                    afterDashSpace = "";
+                    break; // Tag handler consumed remaining tokens
+                } else {
+                    afterDashSpace += token.source;
+                }
             } else {
                 prefix += token.source;
             }
@@ -410,8 +444,20 @@ class YamlCstReader {
             const valueResult = this.convertTokenWithTrailing(item.value);
             block = valueResult.node as Yaml.Block;
             trailing = valueResult.trailing;
-            // Prepend the space after dash to the block's prefix
-            block = {...block, prefix: afterDashSpace + block.prefix} as Yaml.Block;
+
+            // Apply anchor and tag if found in start tokens
+            if (anchorForValue && 'anchor' in block) {
+                block = {...block, anchor: anchorForValue} as Yaml.Block;
+            }
+            if (tagForValue && 'tag' in block) {
+                block = {...block, tag: tagForValue} as Yaml.Block;
+            }
+
+            // Prepend the space after dash to the block
+            // Use prependWhitespaceToValue to ensure Mapping/Sequence keep empty prefix
+            if (afterDashSpace) {
+                block = this.prependWhitespaceToValue(block, afterDashSpace);
+            }
         } else {
             block = this.createEmptyScalar(afterDashSpace);
         }
@@ -848,3 +894,5 @@ class YamlCstReader {
         return tokens.map(t => t.source).join('');
     }
 }
+
+Parsers.registerParser("yaml", YamlParser);