@openrewrite/rewrite 8.68.0-20251204-151952 → 8.68.0-20251204-174357

package/src/cli/rewrite.ts

@@ -0,0 +1,185 @@
+#!/usr/bin/env node
+/*
+ * 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 {Command} from 'commander';
+import * as fsp from 'fs/promises';
+import * as path from 'path';
+import {RecipeRegistry} from '../recipe';
+import {ExecutionContext} from '../execution';
+import {scheduleRun} from '../run';
+import {TreePrinters} from '../print';
+import {activate} from '../index';
+import {
+    parseRecipeSpec,
+    parseRecipeOptions,
+    installRecipePackage,
+    loadLocalRecipes,
+    findRecipe,
+    discoverFiles,
+    parseFiles
+} from './cli-utils';
+
+// Import language modules to register printers
+import '../text';
+import '../json';
+import '../java';
+import '../javascript';
+
+// Set stack size for complex parsing
+require('v8').setFlagsFromString('--stack-size=8000');
+
+const DEFAULT_RECIPE_DIR = path.join(process.env.HOME || '', '.rewrite', 'javascript', 'recipes');
+
+interface CliOptions {
+    dryRun: boolean;
+    recipeDir?: string;
+    option: string[];
+    verbose: boolean;
+}
+
+async function main() {
+    const program = new Command();
+    program
+        .name('rewrite')
+        .description('Run OpenRewrite recipes on your codebase')
+        .argument('<recipe>', 'Recipe to run in format "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")')
+        .option('-n, --dry-run', 'Show what changes would be made without applying them', false)
+        .option('-d, --recipe-dir <dir>', 'Directory for recipe installation', DEFAULT_RECIPE_DIR)
+        .option('-o, --option <option...>', 'Recipe options in format "key=value"', [])
+        .option('-v, --verbose', 'Enable verbose output', false)
+        .parse();
+
+    const recipeArg = program.args[0];
+    const opts = program.opts() as CliOptions;
+    opts.option = opts.option || [];
+
+    // Parse recipe specification
+    const recipeSpec = parseRecipeSpec(recipeArg);
+    if (!recipeSpec) {
+        console.error(`Invalid recipe format: ${recipeArg}`);
+        console.error('Expected format: "package:recipe" (e.g., "@openrewrite/recipes-nodejs:replace-deprecated-slice")');
+        process.exit(1);
+    }
+
+    if (opts.verbose) {
+        console.log(`Package: ${recipeSpec.packageName}`);
+        console.log(`Recipe: ${recipeSpec.recipeName}`);
+    }
+
+    // Parse recipe options
+    const recipeOptions = parseRecipeOptions(opts.option);
+    if (opts.verbose && Object.keys(recipeOptions).length > 0) {
+        console.log(`Options: ${JSON.stringify(recipeOptions)}`);
+    }
+
+    // Set up recipe registry
+    const registry = new RecipeRegistry();
+
+    // Register built-in recipes
+    await activate(registry);
+
+    // Load recipes from local path or install from NPM
+    try {
+        if (recipeSpec.isLocalPath) {
+            await loadLocalRecipes(recipeSpec.packageName, registry, opts.verbose);
+        } else {
+            await installRecipePackage(recipeSpec.packageName, opts.recipeDir || DEFAULT_RECIPE_DIR, registry, opts.verbose);
+        }
+    } catch (e: any) {
+        console.error(`Failed to load recipes: ${e.message}`);
+        process.exit(1);
+    }
+
+    // Find the recipe
+    const recipe = findRecipe(registry, recipeSpec.recipeName, recipeOptions);
+    if (!recipe) {
+        process.exit(1);
+    }
+
+    if (opts.verbose) {
+        console.log(`Running recipe: ${recipe.name}`);
+    }
+
+    // Discover source files
+    const projectRoot = process.cwd();
+    const sourceFiles = await discoverFiles(projectRoot, opts.verbose);
+
+    if (sourceFiles.length === 0) {
+        console.log('No source files found to process.');
+        return;
+    }
+
+    if (opts.verbose) {
+        console.log(`Found ${sourceFiles.length} source files`);
+    }
+
+    // Parse all source files
+    const parsedFiles = await parseFiles(sourceFiles, projectRoot, opts.verbose);
+
+    if (parsedFiles.length === 0) {
+        console.log('No files could be parsed.');
+        return;
+    }
+
+    // Run the recipe
+    const ctx = new ExecutionContext();
+    const {changeset} = await scheduleRun(recipe, parsedFiles, ctx);
+
+    if (changeset.length === 0) {
+        console.log('No changes to make.');
+        return;
+    }
+
+    console.log(`\n${changeset.length} file(s) ${opts.dryRun ? 'would be ' : ''}changed:\n`);
+
+    // Handle results
+    for (const result of changeset) {
+        if (opts.dryRun) {
+            // Print diff
+            const diff = await result.diff();
+            console.log(diff);
+        } else {
+            // Apply changes
+            if (result.after) {
+                const filePath = path.join(projectRoot, result.after.sourcePath);
+                const content = await TreePrinters.print(result.after);
+
+                // Ensure directory exists
+                await fsp.mkdir(path.dirname(filePath), {recursive: true});
+                await fsp.writeFile(filePath, content);
+
+                if (result.before) {
+                    console.log(`  Modified: ${result.after.sourcePath}`);
+                } else {
+                    console.log(`  Created: ${result.after.sourcePath}`);
+                }
+            } else if (result.before) {
+                const filePath = path.join(projectRoot, result.before.sourcePath);
+                await fsp.unlink(filePath);
+                console.log(`  Deleted: ${result.before.sourcePath}`);
+            }
+        }
+    }
+
+    if (!opts.dryRun) {
+        console.log('\nChanges applied successfully.');
+    }
+}
+
+main().catch((err) => {
+    console.error('Fatal error:', err.message);
+    process.exit(1);
+});

package/src/javascript/package-json-parser.ts

@@ -187,12 +187,15 @@ export class PackageJsonParser extends Parser {
                 : filePath;
 
             // Try to read lock file if dependency resolution is not skipped
-            // Use relativeTo directory if available (for tests), otherwise use the directory from input path
+            // First try the directory containing the package.json, then walk up toward relativeTo
             let lockContent: PackageLockContent | undefined = undefined;
             let packageManager: PackageManager | undefined = undefined;
             if (!this.skipDependencyResolution) {
-                const lockDir = this.relativeTo || dir;
-                const lockResult = await this.tryReadLockFile(lockDir);
+                // Resolve dir relative to relativeTo if dir is relative (e.g., '.' when package.json is at root)
+                const absoluteDir = this.relativeTo && !path.isAbsolute(dir)
+                    ? path.resolve(this.relativeTo, dir)
+                    : dir;
+                const lockResult = await this.tryReadLockFileWithWalkUp(absoluteDir, this.relativeTo);
                 lockContent = lockResult?.content;
                 packageManager = lockResult?.packageManager;
             }
@@ -215,6 +218,50 @@ export class PackageJsonParser extends Parser {
         }
     }
 
+    /**
+     * Attempts to find and read a lock file by walking up the directory tree.
+     * Starts from the directory containing the package.json and walks up toward
+     * the root directory (or relativeTo if specified).
+     *
+     * This handles both standalone projects (lock file next to package.json) and
+     * workspace scenarios (lock file at workspace root).
+     *
+     * @param startDir The directory containing the package.json being parsed
+     * @param rootDir Optional root directory to stop walking at (e.g., relativeTo/git root)
+     * @returns Object with parsed lock file content and detected package manager, or undefined if none found
+     */
+    private async tryReadLockFileWithWalkUp(
+        startDir: string,
+        rootDir?: string
+    ): Promise<{ content: PackageLockContent; packageManager: PackageManager } | undefined> {
+        // Normalize paths for comparison
+        const normalizedRoot = rootDir ? path.resolve(rootDir) : undefined;
+        let currentDir = path.resolve(startDir);
+
+        // Walk up the directory tree looking for a lock file
+        while (true) {
+            const result = await this.tryReadLockFile(currentDir);
+            if (result) {
+                return result;
+            }
+
+            // If we've reached rootDir, stop walking (don't go above it)
+            if (normalizedRoot && currentDir === normalizedRoot) {
+                break;
+            }
+
+            // Check if we've reached the filesystem root
+            const parentDir = path.dirname(currentDir);
+            if (parentDir === currentDir) {
+                break;
+            }
+
+            currentDir = parentDir;
+        }
+
+        return undefined;
+    }
+
     /**
      * Attempts to read and parse a lock file from the given directory.
      * Supports npm (package-lock.json), bun (bun.lock), pnpm, and yarn.

package/src/javascript/search/find-dependency.ts

@@ -88,6 +88,9 @@ export class FindDependency extends Recipe {
 
     constructor(options: FindDependencyOptions) {
         super(options);
+        // Handle string values from RPC serialization (e.g., "false" instead of false)
+        // and default to true if not specified
+        this.onlyDirect = !(this.onlyDirect === false || (this.onlyDirect as any === "false"));
     }
 
     override instanceName(): string {
@@ -97,8 +100,7 @@ export class FindDependency extends Recipe {
     async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
         const packageName = this.packageName;
         const version = this.version;
-        // Default to true if not specified (only search direct dependencies)
-        const onlyDirect = this.onlyDirect ?? true;
+        const onlyDirect = this.onlyDirect;
 
         // Create a picomatch matcher for the package name pattern
         // For patterns without '/', use { contains: true } so that '*jest*' matches '@types/jest'