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

package/src/cli/cli-utils.ts

@@ -14,22 +14,11 @@
  * limitations under the License.
  */
 import * as fs from 'fs';
-import * as fsp from 'fs/promises';
 import * as path from 'path';
-import {spawn, spawnSync} from 'child_process';
+import {spawn} from 'child_process';
 import {Recipe, RecipeRegistry} from '../recipe';
 import {SourceFile} from '../tree';
-import {
-    isYarnBerryLockFile,
-    JavaScriptParser,
-    JSON_LOCK_FILE_NAMES,
-    PackageJsonParser,
-    TEXT_LOCK_FILE_NAMES,
-    YAML_LOCK_FILE_NAMES
-} from '../javascript';
-import {JsonParser} from '../json';
-import {PlainTextParser} from '../text';
-import {YamlParser} from '../yaml';
+import {ProjectParser} from '../javascript/project-parser';
 
 // ANSI color codes
 const colors = {
@@ -339,123 +328,28 @@ export function findRecipe(
 }
 
 /**
- * Discover source files in a project directory, respecting .gitignore
+ * Discover source files in a project directory, respecting .gitignore.
+ * Delegates to ProjectParser for file discovery.
  */
 export async function discoverFiles(projectRoot: string, verbose: boolean = false): Promise<string[]> {
-    const files: string[] = [];
-
-    if (verbose) {
-        console.log(`Discovering files in ${projectRoot}...`);
-    }
-
-    // Get list of git-ignored files
-    const ignoredFiles = new Set<string>();
-    try {
-        const result = spawnSync('git', ['ls-files', '--ignored', '--exclude-standard', '-o'], {
-            cwd: projectRoot,
-            encoding: 'utf8'
-        });
-        if (result.stdout) {
-            for (const line of result.stdout.split('\n')) {
-                if (line.trim()) {
-                    ignoredFiles.add(path.join(projectRoot, line.trim()));
-                }
-            }
-        }
-    } catch {
-        // Git not available or not a git repository
-    }
-
-    // Get tracked and untracked (but not ignored) files
-    const trackedFiles = new Set<string>();
-    try {
-        // Get tracked files
-        const tracked = spawnSync('git', ['ls-files'], {
-            cwd: projectRoot,
-            encoding: 'utf8'
-        });
-        // Check if git command failed (not a git repository)
-        if (tracked.status !== 0 || tracked.error) {
-            // Not a git repository, fall back to recursive directory scan
-            await walkDirectory(projectRoot, files, ignoredFiles, projectRoot);
-            return files.filter(isAcceptedFile);
-        }
-        if (tracked.stdout) {
-            for (const line of tracked.stdout.split('\n')) {
-                if (line.trim()) {
-                    trackedFiles.add(path.join(projectRoot, line.trim()));
-                }
-            }
-        }
-
-        // Get untracked but not ignored files
-        const untracked = spawnSync('git', ['ls-files', '--others', '--exclude-standard'], {
-            cwd: projectRoot,
-            encoding: 'utf8'
-        });
-        if (untracked.stdout) {
-            for (const line of untracked.stdout.split('\n')) {
-                if (line.trim()) {
-                    trackedFiles.add(path.join(projectRoot, line.trim()));
-                }
-            }
-        }
-    } catch {
-        // Not a git repository, fall back to recursive directory scan
-        await walkDirectory(projectRoot, files, ignoredFiles, projectRoot);
-        return files.filter(isAcceptedFile);
-    }
-
-    // Filter to accepted file types that exist on disk
-    // (git ls-files returns deleted files that are still tracked)
-    for (const file of trackedFiles) {
-        if (!ignoredFiles.has(file) && isAcceptedFile(file) && fs.existsSync(file)) {
-            files.push(file);
-        }
-    }
-
-    return files;
-}
-
-/**
- * Walk a directory recursively, collecting files
- */
-export async function walkDirectory(
-    dir: string,
-    files: string[],
-    ignored: Set<string>,
-    projectRoot: string
-): Promise<void> {
-    const entries = await fsp.readdir(dir, {withFileTypes: true});
-
-    for (const entry of entries) {
-        const fullPath = path.join(dir, entry.name);
-
-        // Skip hidden files and common ignore patterns
-        if (entry.name.startsWith('.') || entry.name === 'node_modules' || entry.name === 'dist' ||
-            entry.name === 'build' || entry.name === 'coverage') {
-            continue;
-        }
-
-        if (ignored.has(fullPath)) {
-            continue;
-        }
-
-        if (entry.isDirectory()) {
-            await walkDirectory(fullPath, files, ignored, projectRoot);
-        } else if (entry.isFile() && isAcceptedFile(fullPath)) {
-            files.push(fullPath);
-        }
-    }
+    const parser = new ProjectParser(projectRoot, {verbose});
+    const discovered = await parser.discoverFiles();
+
+    // Flatten all discovered files into a single array
+    return [
+        ...discovered.packageJsonFiles,
+        ...discovered.lockFiles.json,
+        ...discovered.lockFiles.yaml,
+        ...discovered.lockFiles.text,
+        ...discovered.jsFiles,
+        ...discovered.jsonFiles,
+        ...discovered.yamlFiles,
+        ...discovered.textFiles
+    ];
 }
 
 /**
- * All lock file names (typed as string[] for easier comparison)
- */
-const ALL_LOCK_FILE_NAMES: readonly string[] = [...JSON_LOCK_FILE_NAMES, ...YAML_LOCK_FILE_NAMES, ...TEXT_LOCK_FILE_NAMES];
-
-/**
- * Check if a file is accepted for parsing based on its extension
+ * Check if a file is accepted for parsing based on its extension.
  */
 export function isAcceptedFile(filePath: string): boolean {
     const ext = path.extname(filePath).toLowerCase();
@@ -466,7 +360,7 @@ export function isAcceptedFile(filePath: string): boolean {
         return true;
     }
 
-    // JSON files (including package.json which gets special parsing)
+    // JSON files
     if (ext === '.json') {
         return true;
     }
@@ -476,8 +370,13 @@ export function isAcceptedFile(filePath: string): boolean {
         return true;
     }
 
-    // Lock files (some have non-standard extensions like yarn.lock)
-    if (ALL_LOCK_FILE_NAMES.includes(basename)) {
+    // Lock files (yarn.lock has no extension)
+    if (['yarn.lock', 'pnpm-lock.yaml', 'package-lock.json', 'bun.lock'].includes(basename)) {
+        return true;
+    }
+
+    // Text config files
+    if (['.prettierignore', '.gitignore', '.npmignore', '.eslintignore'].includes(basename)) {
         return true;
     }
 
@@ -491,127 +390,37 @@ export interface ParseFilesOptions {
     onProgress?: ProgressCallback;
 }
 
-/**
- * Internal context for file parsing progress tracking.
- */
-interface ParseContext {
-    current: number;
-    total: number;
-    verbose: boolean;
-    onProgress?: ProgressCallback;
-}
-
-/**
- * Helper to parse files with a given parser, handling verbose logging and progress.
- */
-async function* parseWithParser(
-    files: string[],
-    parser: { parse(...files: string[]): AsyncGenerator<SourceFile> },
-    fileType: string,
-    ctx: ParseContext
-): AsyncGenerator<SourceFile, ParseContext> {
-    if (files.length === 0) {
-        return ctx;
-    }
-
-    if (ctx.verbose) {
-        console.log(`Parsing ${files.length} ${fileType} files...`);
-    }
-
-    for await (const sf of parser.parse(...files)) {
-        ctx.current++;
-        ctx.onProgress?.(ctx.current, ctx.total, sf.sourcePath);
-        yield sf;
-    }
-
-    return ctx;
-}
-
-/**
- * Classifies a yarn.lock file as YAML (Berry) or text (Classic) based on its content.
- * Returns 'yaml' for Yarn Berry (v2+) and 'text' for Yarn Classic (v1).
- */
-async function classifyYarnLockFile(filePath: string): Promise<'yaml' | 'text'> {
-    try {
-        const content = await fsp.readFile(filePath, 'utf-8');
-        return isYarnBerryLockFile(content) ? 'yaml' : 'text';
-    } catch {
-        // Default to text format if we can't read the file
-        return 'text';
-    }
-}
-
 /**
  * Parse source files using appropriate parsers (streaming version).
  * Yields source files as they are parsed, allowing immediate processing.
+ *
+ * Uses ProjectParser with a file filter to parse only the specified files.
+ * This handles Prettier detection, file classification, and appropriate parser selection.
  */
 export async function* parseFilesStreaming(
     filePaths: string[],
     projectRoot: string,
     options: ParseFilesOptions = {}
 ): AsyncGenerator<SourceFile, void, undefined> {
-    const { verbose = false, onProgress } = options;
-    const total = filePaths.length;
-    let current = 0;
+    const {verbose = false, onProgress} = options;
 
-    // Group files by type
-    const jsFiles: string[] = [];
-    const packageJsonFiles: string[] = [];
-    const jsonFiles: string[] = [];
-    const jsonLockFiles: string[] = [];
-    const yamlLockFiles: string[] = [];
-    const yamlFiles: string[] = [];
-    const textLockFiles: string[] = [];
-
-    // Collect yarn.lock files for content-based classification
-    const yarnLockFiles: string[] = [];
-
-    for (const filePath of filePaths) {
-        const basename = path.basename(filePath);
-        const ext = path.extname(filePath).toLowerCase();
-
-        if (basename === 'package.json') {
-            packageJsonFiles.push(filePath);
-        } else if (['.js', '.jsx', '.ts', '.tsx', '.mjs', '.mts', '.cjs', '.cts'].includes(ext)) {
-            jsFiles.push(filePath);
-        } else if ((JSON_LOCK_FILE_NAMES as readonly string[]).includes(basename)) {
-            jsonLockFiles.push(filePath);
-        } else if ((YAML_LOCK_FILE_NAMES as readonly string[]).includes(basename)) {
-            yamlLockFiles.push(filePath);
-        } else if (basename === 'yarn.lock') {
-            // yarn.lock needs content-based classification
-            yarnLockFiles.push(filePath);
-        } else if ((TEXT_LOCK_FILE_NAMES as readonly string[]).includes(basename)) {
-            // Other text lock files (if any besides yarn.lock)
-            textLockFiles.push(filePath);
-        } else if (ext === '.json') {
-            jsonFiles.push(filePath);
-        } else if (['.yaml', '.yml'].includes(ext)) {
-            yamlFiles.push(filePath);
-        }
-    }
+    // Create a set for fast lookup
+    const fileSet = new Set(filePaths.map(f => path.resolve(f)));
+    let current = 0;
+    const total = filePaths.length;
 
-    // Classify yarn.lock files by content (Yarn Berry uses YAML, Classic uses text)
-    for (const yarnLockPath of yarnLockFiles) {
-        const format = await classifyYarnLockFile(yarnLockPath);
-        if (format === 'yaml') {
-            yamlLockFiles.push(yarnLockPath);
-        } else {
-            textLockFiles.push(yarnLockPath);
-        }
-    }
+    const parser = new ProjectParser(projectRoot, {
+        verbose,
+        fileFilter: (absolutePath) => fileSet.has(absolutePath),
+        onProgress: onProgress ? (phase, cur, tot, filePath) => {
+            if (phase === "parsing" && filePath) {
+                current++;
+                onProgress(current, total, filePath);
+            }
+        } : undefined
+    });
 
-    // Create parse context for tracking progress
-    const ctx: ParseContext = { current, total, verbose, onProgress };
-
-    // Parse files by type using helper
-    yield* parseWithParser(jsFiles, new JavaScriptParser({relativeTo: projectRoot}), 'JavaScript/TypeScript', ctx);
-    yield* parseWithParser(packageJsonFiles, new PackageJsonParser({relativeTo: projectRoot}), 'package.json', ctx);
-    yield* parseWithParser(jsonLockFiles, new JsonParser({relativeTo: projectRoot}), 'JSON lock', ctx);
-    yield* parseWithParser(yamlLockFiles, new YamlParser({relativeTo: projectRoot}), 'YAML lock', ctx);
-    yield* parseWithParser(textLockFiles, new PlainTextParser({relativeTo: projectRoot}), 'text lock', ctx);
-    yield* parseWithParser(yamlFiles, new YamlParser({relativeTo: projectRoot}), 'YAML', ctx);
-    yield* parseWithParser(jsonFiles, new JsonParser({relativeTo: projectRoot}), 'JSON', ctx);
+    yield* parser.parse();
 }
 
 /**

package/src/javascript/assertions.ts

@@ -21,8 +21,12 @@ import ts from 'typescript';
 import {json, Json} from "../json";
 import {DependencyWorkspace} from "./dependency-workspace";
 import {setTemplateSourceFileCache} from "./templating/engine";
+import {PrettierConfigLoader} from "./format/prettier-config-loader";
+import {produce} from "immer";
 import * as fs from "fs";
 import * as path from "path";
+import {Autodetect} from "./autodetect";
+import {Marker} from "../markers";
 
 /**
  * Shared TypeScript source file cache for test parsers.
@@ -51,6 +55,20 @@ export async function* npm(relativeTo: string, ...sourceSpecs: SourceSpec<any>[]
         );
     }
 
+    // Write non-JS/TS files to disk FIRST so Prettier config detection can find them
+    for (const spec of sourceSpecs) {
+        if (spec.path !== 'package.json' && spec.path !== 'package-lock.json' && spec.kind !== JS.Kind.CompilationUnit) {
+            if (spec.before && spec.path) {
+                const filePath = path.join(relativeTo, spec.path);
+                const dir = path.dirname(filePath);
+                if (!fs.existsSync(dir)) {
+                    fs.mkdirSync(dir, { recursive: true });
+                }
+                fs.writeFileSync(filePath, spec.before);
+            }
+        }
+    }
+
     // Yield package.json FIRST so its PackageJsonParser is used for all JSON specs
     // (The test framework uses the first spec's parser for all specs of the same kind)
     if (packageJsonSpec) {
@@ -100,23 +118,69 @@ export async function* npm(relativeTo: string, ...sourceSpecs: SourceSpec<any>[]
         yield packageLockSpec;
     }
 
+    // Detect Prettier configuration for the project
+    const prettierLoader = new PrettierConfigLoader(relativeTo);
+    const detection = await prettierLoader.detectPrettier();
+
+    // Collect JS/TS specs for potential auto-detection
+    const jsSpecs = sourceSpecs.filter(
+        spec => spec.path !== 'package.json' && spec.path !== 'package-lock.json' && spec.kind === JS.Kind.CompilationUnit
+    );
+
+    // Build style marker: either PrettierStyle per-file or Autodetect for all
+    let autodetectMarker: Marker | null = null;
+    if (!detection.available && jsSpecs.length > 0) {
+        // Prettier is NOT available: auto-detect styles from the source files
+        // Pre-parse all JS specs to sample them
+        const detector = Autodetect.detector();
+        const tempParser = new JavaScriptParser({sourceFileCache, relativeTo});
+
+        for (const spec of jsSpecs) {
+            if (spec.before) {
+                const fileName = spec.path ?? `file.${spec.ext}`;
+                const filePath = path.join(relativeTo, fileName);
+                for await (const sf of tempParser.parse({text: spec.before, sourcePath: filePath})) {
+                    if (sf.kind === JS.Kind.CompilationUnit) {
+                        await detector.sample(sf as JS.CompilationUnit);
+                    }
+                }
+            }
+        }
+        autodetectMarker = detector.build();
+    }
+
     for (const spec of sourceSpecs) {
         if (spec.path !== 'package.json' && spec.path !== 'package-lock.json') {
             if (spec.kind === JS.Kind.CompilationUnit) {
+                // For JS/TS files, use a parser that adds style marker if available
+                // spec.path may be undefined, so generate a reasonable path from the extension
+                const fileName = spec.path ?? `file.${spec.ext}`;
+                const filePath = path.join(relativeTo, fileName);
+
+                // Get the appropriate style marker
+                let styleMarker: Marker | undefined;
+                if (detection.available) {
+                    // Use per-file PrettierStyle marker
+                    styleMarker = await prettierLoader.getConfigMarker(filePath);
+                } else {
+                    // Use shared Autodetect marker
+                    styleMarker = autodetectMarker ?? undefined;
+                }
+
                 yield {
                     ...spec,
-                    parser: () => new JavaScriptParser({sourceFileCache, relativeTo})
+                    parser: () => new JavaScriptParser({sourceFileCache, relativeTo}),
+                    // Add style marker before recipe runs if available
+                    // Compose with existing beforeRecipe if present
+                    beforeRecipe: styleMarker ? (sf: JS.CompilationUnit) => {
+                        const withMarker = produce(sf, draft => {
+                            draft.markers.markers = draft.markers.markers.concat([styleMarker]);
+                        });
+                        return spec.beforeRecipe ? spec.beforeRecipe(withMarker) : withMarker;
+                    } : spec.beforeRecipe
                 }
             } else {
-                // Write non-JS/TS files to disk so tools like Prettier can find config files
-                if (spec.before && spec.path) {
-                    const filePath = path.join(relativeTo, spec.path);
-                    const dir = path.dirname(filePath);
-                    if (!fs.existsSync(dir)) {
-                        fs.mkdirSync(dir, { recursive: true });
-                    }
-                    fs.writeFileSync(filePath, spec.before);
-                }
+                // Non-JS/TS files were already written to disk above
                 yield spec;
             }
         }

package/src/javascript/autodetect.ts

@@ -28,6 +28,7 @@ import {
     WrappingAndBracesStyle,
     WrappingAndBracesStyleDetailKind
 } from "./style";
+import {UUID} from "../uuid";
 
 /**
  * Auto-detected styles for JavaScript/TypeScript code.
@@ -36,21 +37,27 @@ import {
  * - 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;
-    }
+export interface Autodetect extends NamedStyles<typeof StyleKind.Autodetect> {
+    readonly kind: typeof StyleKind.Autodetect;
+    readonly name: "org.openrewrite.javascript.Autodetect";
+    readonly displayName: "Auto-detected";
+    readonly description: "Automatically detect styles from a repository's existing code.";
+}
+
+export function autodetect(id: UUID, styles: Style[]): Autodetect {
+    return {
+        kind: StyleKind.Autodetect,
+        id,
+        name: "org.openrewrite.javascript.Autodetect",
+        displayName: "Auto-detected",
+        description: "Automatically detect styles from a repository's existing code.",
+        tags: [],
+        styles
+    };
+}
 
-    static detector(): Detector {
+export namespace Autodetect {
+    export function detector(): Detector {
         return new Detector();
     }
 }
@@ -85,7 +92,7 @@ export class Detector {
      * Build the auto-detected styles from collected statistics.
      */
     build(): Autodetect {
-        return new Autodetect(randomId(), [
+        return autodetect(randomId(), [
             this.tabsAndIndentsStats.getTabsAndIndentsStyle(),
             this.spacesStats.getSpacesStyle(),
             this.getWrappingAndBracesStyle(),

package/src/javascript/format/prettier-config-loader.ts

@@ -18,7 +18,7 @@ import * as fs from 'fs';
 import * as fsp from 'fs/promises';
 import * as os from 'os';
 import {spawnSync} from 'child_process';
-import {PrettierStyle} from '../style';
+import {prettierStyle, PrettierStyle} from '../style';
 import {randomId} from '../../uuid';
 
 /**
@@ -336,7 +336,7 @@ export class PrettierConfigLoader {
             }
 
             // Create new PrettierStyle instance
-            marker = new PrettierStyle(randomId(), config, this.detection.version, ignored);
+            marker = prettierStyle(randomId(), config, this.detection.version, ignored);
 
             // Cache and return
             this.configCache.set(configKey, marker);

package/src/javascript/index.ts

@@ -29,6 +29,7 @@ export * from "./method-matcher";
 export * from "./format";
 export * from "./autodetect";
 export * from "./tree-debug";
+export * from "./project-parser";
 
 export * from "./add-import";
 export * from "./remove-import";