@openrewrite/rewrite 8.67.0 → 8.67.1

package/src/java/tree.ts

@@ -37,6 +37,7 @@ export namespace J {
 }
 
 export interface Expression extends J {
+    readonly type?: Type;
 }
 
 export interface MethodCall extends Expression {
@@ -834,15 +835,20 @@ export interface DocComment extends Comment {
     // TODO implement me!
 }
 
-export const isClassDeclaration = (n: any): n is J.ClassDeclaration => n.kind === J.Kind.ClassDeclaration;
+export const isBinary = (n: any): n is J.Binary => n.kind === J.Kind.Binary;
 export const isBlock = (n: any): n is J.Block => n.kind === J.Kind.Block;
+export const isClassDeclaration = (n: any): n is J.ClassDeclaration => n.kind === J.Kind.ClassDeclaration;
+export const isFieldAccess = (n: any): n is J.FieldAccess => n.kind === J.Kind.FieldAccess;
 export const isIdentifier = (tree: any): tree is J.Identifier => tree["kind"] === J.Kind.Identifier;
 export const isIf = (tree: any): tree is J.If => tree["kind"] === J.Kind.If;
+export const isImport = (tree: any): tree is J.Import => tree["kind"] === J.Kind.Import;
 export const isLambda = (tree: any): tree is J.Lambda => tree["kind"] === J.Kind.Lambda;
 export const isLiteral = (tree: any): tree is J.Literal => tree["kind"] === J.Kind.Literal;
 export const isMethodDeclaration = (n: any): n is J.MethodDeclaration => n.kind === J.Kind.MethodDeclaration;
 export const isMethodInvocation = (n: any): n is J.MethodInvocation => n.kind === J.Kind.MethodInvocation;
+export const isNamedVariable = (n: any): n is J.VariableDeclarations.NamedVariable => n.kind === J.Kind.NamedVariable;
 export const isNewClass = (n: any): n is J.NewClass => n.kind === J.Kind.NewClass;
+export const isReturn = (n: any): n is J.Return => n.kind === J.Kind.Return;
 export const isVariableDeclarations = (n: any): n is J.VariableDeclarations => n.kind === J.Kind.VariableDeclarations;
 
 export function rightPadded<T extends J | boolean>(t: T, trailing: J.Space, markers?: Markers): J.RightPadded<T> {

package/src/javascript/add-import.ts

@@ -1,9 +1,8 @@
 import {JavaScriptVisitor} from "./visitor";
-import {J, emptySpace, rightPadded, space, Statement, singleSpace, Type} from "../java";
+import {emptySpace, J, rightPadded, singleSpace, space, Statement, Type} from "../java";
 import {JS} from "./tree";
 import {randomId} from "../uuid";
 import {emptyMarkers, markers} from "../markers";
-import {ExecutionContext} from "../execution";
 
 export enum ImportStyle {
     ES6Named,      // import { x } from 'module'
@@ -449,21 +448,52 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
                 // We found a matching import with named bindings - merge into it
                 return this.produceJavaScript<JS.CompilationUnit>(compilationUnit, p, async draft => {
                     const namedImports = importClause.namedBindings as JS.NamedImports;
+                    const existingElements = namedImports.elements.elements;
+
+                    // Find the correct insertion position (alphabetical, case-insensitive)
+                    const newName = (this.alias || this.member!).toLowerCase();
+                    let insertIndex = existingElements.findIndex(elem => {
+                        if (elem.element?.kind === JS.Kind.ImportSpecifier) {
+                            const name = this.getImportAlias(elem.element) || this.getImportName(elem.element);
+                            return newName.localeCompare(name.toLowerCase()) < 0;
+                        }
+                        return false;
+                    });
+                    if (insertIndex === -1) insertIndex = existingElements.length;
 
-                    // Create the new specifier with a space prefix (since it's not the first element)
-                    const newSpecifierBase = this.createImportSpecifier();
-                    const newSpecifier = {...newSpecifierBase, prefix: singleSpace};
-
-                    // Add the new specifier to the elements
+                    // Build the new elements array with proper spacing
                     const updatedNamedImports: JS.NamedImports = await this.produceJavaScript<JS.NamedImports>(
                         namedImports, p, async namedDraft => {
-                            namedDraft.elements = {
-                                ...namedImports.elements,
-                                elements: [
-                                    ...namedImports.elements.elements,
-                                    rightPadded(newSpecifier, emptySpace)
-                                ]
-                            };
+                            const lastIndex = existingElements.length - 1;
+                            const trailingSpace = existingElements[lastIndex].after;
+                            const newSpecifier = this.createImportSpecifier();
+
+                            const newElements = existingElements.flatMap((elem, j) => {
+                                const results: J.RightPadded<JS.ImportSpecifier>[] = [];
+                                if (j === insertIndex) {
+                                    // Insert new element here; first element gets no prefix, others get space
+                                    const prefix = j === 0 ? emptySpace : singleSpace;
+                                    results.push(rightPadded({...newSpecifier, prefix}, emptySpace));
+                                }
+                                // Adjust existing element: first after insertion gets space prefix
+                                let adjusted = elem;
+                                if (j === 0 && insertIndex === 0 && elem.element) {
+                                    adjusted = {...elem, element: {...elem.element, prefix: singleSpace}};
+                                }
+                                // Last element before a new trailing element loses its trailing space
+                                if (j === lastIndex && insertIndex > lastIndex) {
+                                    adjusted = {...adjusted, after: emptySpace};
+                                }
+                                results.push(adjusted);
+                                return results;
+                            });
+
+                            // Append at end if inserting after all existing elements
+                            if (insertIndex > lastIndex) {
+                                newElements.push(rightPadded({...newSpecifier, prefix: singleSpace}, trailingSpace));
+                            }
+
+                            namedDraft.elements = {...namedImports.elements, elements: newElements};
                         }
                     );
 
@@ -660,41 +690,176 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
      * Check if the identifier is actually referenced in the file
      */
     private async checkIdentifierReferenced(compilationUnit: JS.CompilationUnit): Promise<boolean> {
-        // Use type attribution to detect if the identifier is referenced
-        // Map of module name -> Set of member names used from that module
-        const usedImports = new Map<string, Set<string>>();
-
-        // Helper to record usage of a method from a module
-        const recordMethodUsage = (methodType: Type.Method) => {
-            const moduleName = Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
-            if (moduleName) {
-                if (!usedImports.has(moduleName)) {
-                    usedImports.set(moduleName, new Set());
+        // For namespace imports, we cannot use type attribution to detect usage
+        // because the namespace itself is used as an identifier, not individual members.
+        // For simplicity, we skip the onlyIfReferenced check for namespace imports.
+        if (this.member === '*') {
+            // TODO: Implement proper namespace usage detection by checking if alias identifier is used
+            return true;
+        }
+
+        // Step 1: Find the expected declaring type by examining existing imports from the same module
+        let expectedDeclaringType: string | undefined;
+
+        for (const stmt of compilationUnit.statements) {
+            const statement = stmt.element;
+
+            if (statement?.kind === JS.Kind.Import) {
+                const jsImport = statement as JS.Import;
+                const moduleSpecifier = jsImport.moduleSpecifier?.element;
+
+                if (!moduleSpecifier) {
+                    continue;
+                }
+
+                const moduleName = this.getModuleName(moduleSpecifier);
+                if (moduleName !== this.module) {
+                    continue;  // Not the module we're interested in
+                }
+
+                // Found an existing import from our target module
+                // Extract the declaring type from any imported member with type attribution
+                const importClause = jsImport.importClause;
+                if (importClause?.namedBindings?.kind === JS.Kind.NamedImports) {
+                    const namedImports = importClause.namedBindings as JS.NamedImports;
+                    for (const elem of namedImports.elements.elements) {
+                        const specifier = elem.element;
+                        if (specifier?.kind === JS.Kind.ImportSpecifier) {
+                            const importSpec = specifier as JS.ImportSpecifier;
+                            let identifier: J.Identifier | undefined;
+                            if (importSpec.specifier?.kind === J.Kind.Identifier) {
+                                identifier = importSpec.specifier as J.Identifier;
+                            } else if (importSpec.specifier?.kind === JS.Kind.Alias) {
+                                const aliasSpec = importSpec.specifier as JS.Alias;
+                                if (aliasSpec.alias?.kind === J.Kind.Identifier) {
+                                    identifier = aliasSpec.alias as J.Identifier;
+                                }
+                            }
+
+                            // Try to extract declaring type from either type or fieldType
+                            if (identifier?.type && Type.isMethod(identifier.type)) {
+                                const methodType = identifier.type as Type.Method;
+                                expectedDeclaringType = Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                                if (expectedDeclaringType) {
+                                    break;  // Found it!
+                                }
+                            } else if (identifier?.fieldType?.kind === Type.Kind.Variable) {
+                                const variableType = identifier.fieldType as Type.Variable;
+                                if (variableType.owner) {
+                                    expectedDeclaringType = Type.FullyQualified.getFullyQualifiedName(variableType.owner);
+                                    if (expectedDeclaringType) {
+                                        break;  // Found it!
+                                    }
+                                }
+                            }
+                        }
+                    }
+                }
+
+                if (expectedDeclaringType) {
+                    break;  // No need to scan more imports
                 }
-                usedImports.get(moduleName)!.add(methodType.name);
             }
-        };
+        }
+
+        // Step 2: Look for references that match
+        const targetName = this.alias || this.member;
+        const targetModule = this.module;
+        let found = false;
+
+        // If no existing imports from this module, look for unresolved references
+        // If there ARE existing imports, look for references with the expected declaring type
 
-        // Create a visitor to collect used identifiers with their type attribution
         const collector = new class extends JavaScriptVisitor<void> {
             override async visitIdentifier(identifier: J.Identifier, p: void): Promise<J | undefined> {
-                const type = identifier.type;
-                if (type && Type.isMethod(type)) {
-                    recordMethodUsage(type as Type.Method);
+                if (identifier.simpleName === targetName) {
+                    const type = identifier.type;
+                    const fieldType = identifier.fieldType;
+                    if (expectedDeclaringType) {
+                        // We have an expected declaring type - check for exact match
+                        // Check method type (for functions)
+                        if (type && Type.isMethod(type)) {
+                            const methodType = type as Type.Method;
+                            const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                            if (declaringTypeName === expectedDeclaringType) {
+                                found = true;
+                            }
+                        }
+                        // Also check field type (for objects, variables, etc.)
+                        else if (fieldType?.kind === Type.Kind.Variable) {
+                            const variableType = fieldType as Type.Variable;
+                            // For variables, the owner is the declaring module/namespace
+                            if (variableType.owner) {
+                                const ownerTypeName = Type.FullyQualified.getFullyQualifiedName(variableType.owner);
+                                if (ownerTypeName === expectedDeclaringType) {
+                                    found = true;
+                                }
+                            }
+                        }
+                        // Even with expectedDeclaringType, also check for unresolved references
+                        // This handles the case where the member isn't imported yet
+                        else if (!type && !fieldType) {
+                            found = true;
+                        }
+                    } else {
+                        // No existing imports from this module - look for references that match
+                        // 1. Unresolved references (no type/unknown type and no fieldType)
+                        const isUnknownType = !type || type.kind === Type.Kind.Unknown;
+                        if (isUnknownType && !fieldType) {
+                            found = true;
+                        }
+                        // 2. References with fieldType matching the target module
+                        else if (fieldType?.kind === Type.Kind.Variable) {
+                            const variableType = fieldType as Type.Variable;
+                            if (variableType.owner && Type.isClass(variableType.owner)) {
+                                // Traverse owningClass chain to find the root module (handles nested namespaces)
+                                // For example: React.forwardRef -> owner is "React" namespace -> owningClass is "react" module
+                                let current: Type.Class = variableType.owner as Type.Class;
+
+                                // Walk up the owningClass chain until we reach the root
+                                while (current.owningClass && Type.isClass(current.owningClass)) {
+                                    current = current.owningClass as Type.Class;
+                                }
+
+                                const moduleName = Type.FullyQualified.getFullyQualifiedName(current);
+                                if (moduleName === targetModule) {
+                                    found = true;
+                                }
+                            }
+                        }
+                        // 3. References with method type matching the target module
+                        else if (type && Type.isMethod(type)) {
+                            const methodType = type as Type.Method;
+                            const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                            if (declaringTypeName === targetModule) {
+                                found = true;
+                            }
+                        }
+                    }
                 }
                 return super.visitIdentifier(identifier, p);
             }
 
             override async visitMethodInvocation(methodInvocation: J.MethodInvocation, p: void): Promise<J | undefined> {
-                if (methodInvocation.methodType) {
-                    recordMethodUsage(methodInvocation.methodType);
+                if (methodInvocation.methodType && methodInvocation.methodType.name === targetName) {
+                    if (expectedDeclaringType) {
+                        const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(methodInvocation.methodType.declaringType);
+                        if (declaringTypeName === expectedDeclaringType) {
+                            found = true;
+                        }
+                    }
                 }
                 return super.visitMethodInvocation(methodInvocation, p);
             }
 
             override async visitFunctionCall(functionCall: JS.FunctionCall, p: void): Promise<J | undefined> {
-                if (functionCall.methodType) {
-                    recordMethodUsage(functionCall.methodType);
+                if (functionCall.methodType && functionCall.methodType.name === targetName) {
+                    if (expectedDeclaringType) {
+                        const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(functionCall.methodType.declaringType);
+                        if (declaringTypeName === expectedDeclaringType) {
+                            found = true;
+                        }
+                    }
                 }
                 return super.visitFunctionCall(functionCall, p);
             }
@@ -702,7 +867,15 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
             override async visitFieldAccess(fieldAccess: J.FieldAccess, p: void): Promise<J | undefined> {
                 const type = fieldAccess.type;
                 if (type && Type.isMethod(type)) {
-                    recordMethodUsage(type as Type.Method);
+                    const methodType = type as Type.Method;
+                    if (methodType.name === targetName) {
+                        if (expectedDeclaringType) {
+                            const declaringTypeName = Type.FullyQualified.getFullyQualifiedName(methodType.declaringType);
+                            if (declaringTypeName === expectedDeclaringType) {
+                                found = true;
+                            }
+                        }
+                    }
                 }
                 return super.visitFieldAccess(fieldAccess, p);
             }
@@ -710,23 +883,7 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
 
         await collector.visit(compilationUnit, undefined);
 
-        // For namespace imports (member === '*'), we cannot use type attribution to detect usage
-        // because the namespace itself is used as an identifier, not individual members.
-        // We would need to traverse the AST looking for the alias identifier.
-        // For simplicity, we skip the onlyIfReferenced check for namespace imports.
-        if (this.member === '*') {
-            // TODO: Implement proper namespace usage detection by checking if alias identifier is used
-            return true;
-        }
-
-        // Check if our target import is used based on type attribution
-        const moduleMembers = usedImports.get(this.module);
-        if (!moduleMembers) {
-            return false;
-        }
-
-        // For specific members, check if that member is used; otherwise check if any member is used
-        return this.member ? moduleMembers.has(this.member) : moduleMembers.size > 0;
+        return found;
     }
 
     /**
@@ -740,12 +897,13 @@ export class AddImport<P> extends JavaScriptVisitor<P> {
         // For side-effect imports, use emptySpace since space comes from LeftPadded.before
         // For regular imports with import clause, use emptySpace since space comes from LeftPadded.before
         // However, the printer expects the space after 'from' in the literal's prefix
+        // Note: value contains the unquoted string, valueSource contains the quoted version for printing
         const moduleSpecifier: J.Literal = {
             id: randomId(),
             kind: J.Kind.Literal,
             prefix: this.sideEffectOnly ? emptySpace : singleSpace,
             markers: emptyMarkers,
-            value: `'${this.module}'`,
+            value: this.module,
             valueSource: `'${this.module}'`,
             unicodeEscapes: [],
             type: undefined

package/src/javascript/cleanup/index.ts

@@ -0,0 +1,17 @@
+/*
+ * 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.
+ */
+
+export {UseObjectPropertyShorthand} from "./use-object-property-shorthand";

package/src/javascript/cleanup/use-object-property-shorthand.ts

@@ -0,0 +1,154 @@
+/*
+ * 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 {Recipe} from "../../recipe";
+import {TreeVisitor} from "../../visitor";
+import {ExecutionContext} from "../../execution";
+import {JavaScriptVisitor} from "../visitor";
+import {J} from "../../java";
+import {JS} from "../tree";
+import {produce} from "immer";
+
+/**
+ * Simplifies object properties where the key and value have the same name,
+ * in both destructuring patterns and object literals.
+ *
+ * Destructuring examples:
+ * - `const { x: x } = obj` becomes `const { x } = obj`
+ * - `function({ ref: ref, ...props })` becomes `function({ ref, ...props })`
+ *
+ * Object literal examples:
+ * - `{ x: x }` becomes `{ x }`
+ * - `{ foo: foo, bar: bar }` becomes `{ foo, bar }`
+ */
+export class UseObjectPropertyShorthand extends Recipe {
+    name = "org.openrewrite.javascript.cleanup.use-object-property-shorthand";
+    displayName = "Use object property shorthand";
+    description = "Simplifies object properties where the property name and value/variable name are the same (e.g., `{ x: x }` becomes `{ x }`). Applies to both destructuring patterns and object literals.";
+
+    async editor(): Promise<TreeVisitor<any, ExecutionContext>> {
+        return new class extends JavaScriptVisitor<ExecutionContext> {
+
+            /**
+             * Handle object binding patterns (destructuring): const { x: x } = obj
+             */
+            protected async visitObjectBindingPattern(pattern: JS.ObjectBindingPattern, p: ExecutionContext): Promise<J | undefined> {
+                const visited = await super.visitObjectBindingPattern(pattern, p) as JS.ObjectBindingPattern;
+
+                let hasChanges = false;
+
+                const simplifiedBindings = visited.bindings.elements.map(right => {
+                    const element = right.element;
+
+                    if (element.kind === JS.Kind.BindingElement) {
+                        const binding = element as JS.BindingElement;
+
+                        if (binding.propertyName?.element.kind === J.Kind.Identifier) {
+                            const propName = (binding.propertyName.element as J.Identifier).simpleName;
+
+                            if (binding.name?.kind === J.Kind.Identifier) {
+                                const bindingName = (binding.name as J.Identifier).simpleName;
+
+                                if (propName === bindingName) {
+                                    hasChanges = true;
+                                    return {
+                                        ...right,
+                                        element: {
+                                            ...binding,
+                                            propertyName: undefined,
+                                            name: {
+                                                ...binding.name,
+                                                prefix: binding.propertyName.element.prefix
+                                            }
+                                        }
+                                    } as J.RightPadded<JS.BindingElement>;
+                                }
+                            }
+                        }
+                    }
+
+                    return right;
+                });
+
+                if (!hasChanges) {
+                    return visited;
+                }
+
+                return produce(visited, draft => {
+                    draft.bindings.elements = simplifiedBindings;
+                });
+            }
+
+            /**
+             * Handle object literals: { x: x }
+             * Object literals are represented as J.NewClass with a body containing JS.PropertyAssignment statements.
+             */
+            protected async visitNewClass(newClass: J.NewClass, ctx: ExecutionContext): Promise<J | undefined> {
+                const visited = await super.visitNewClass(newClass, ctx) as J.NewClass;
+
+                // Only process object literals (NewClass with body but no class or arguments)
+                if (!visited.body || visited.class || (visited.arguments?.elements && visited.arguments.elements.length > 0)) {
+                    return visited;
+                }
+
+                const statements = visited.body.statements;
+                if (!statements || statements.length === 0) {
+                    return visited;
+                }
+
+                let hasChanges = false;
+
+                const simplifiedStatements = statements.map(stmt => {
+                    if (stmt.element.kind === JS.Kind.PropertyAssignment) {
+                        const prop = stmt.element as JS.PropertyAssignment;
+
+                        // Check if the property name is an identifier
+                        if (prop.name.element.kind === J.Kind.Identifier) {
+                            const propName = (prop.name.element as J.Identifier).simpleName;
+
+                            // Check if the initializer is also an identifier with the same name
+                            if (prop.initializer?.kind === J.Kind.Identifier) {
+                                const initName = (prop.initializer as J.Identifier).simpleName;
+
+                                if (propName === initName) {
+                                    hasChanges = true;
+                                    // Remove the initializer to use shorthand syntax
+                                    return {
+                                        ...stmt,
+                                        element: {
+                                            ...prop,
+                                            initializer: undefined
+                                        }
+                                    } as J.RightPadded<JS.PropertyAssignment>;
+                                }
+                            }
+                        }
+                    }
+
+                    return stmt;
+                });
+
+                if (!hasChanges) {
+                    return visited;
+                }
+
+                return produce(visited, draft => {
+                    draft.body!.statements = simplifiedStatements;
+                });
+            }
+        };
+    }
+}

package/src/javascript/comparator.ts

@@ -840,6 +840,17 @@ export class JavaScriptComparatorVisitor extends JavaScriptVisitor<J> {
         return this.visitElement(scopedVariableDeclarations, other as JS.ScopedVariableDeclarations);
     }
 
+    /**
+     * Overrides the visitShebang method to compare shebangs.
+     *
+     * @param shebang The shebang to visit
+     * @param other The other shebang to compare with
+     * @returns The visited shebang, or undefined if the visit was aborted
+     */
+    override async visitShebang(shebang: JS.Shebang, other: J): Promise<J | undefined> {
+        return this.visitElement(shebang, other as JS.Shebang);
+    }
+
     /**
      * Overrides the visitStatementExpression method to compare statement expressions.
      * 

package/src/javascript/dependency-workspace.ts

@@ -47,6 +47,42 @@ export class DependencyWorkspace {
             // Create/update workspace in target directory
             fs.mkdirSync(targetDir, {recursive: true});
 
+            // Check if we can reuse a cached workspace by symlinking node_modules
+            const hash = this.hashDependencies(dependencies);
+            const cachedWorkspaceDir = path.join(this.WORKSPACE_BASE, hash);
+            const cachedNodeModules = path.join(cachedWorkspaceDir, 'node_modules');
+
+            if (fs.existsSync(cachedNodeModules) && this.isWorkspaceValid(cachedWorkspaceDir, dependencies)) {
+                // Symlink node_modules from cached workspace
+                try {
+                    const targetNodeModules = path.join(targetDir, 'node_modules');
+
+                    // Remove existing node_modules if present (might be invalid)
+                    if (fs.existsSync(targetNodeModules)) {
+                        fs.rmSync(targetNodeModules, {recursive: true, force: true});
+                    }
+
+                    // Create symlink to cached node_modules
+                    fs.symlinkSync(cachedNodeModules, targetNodeModules, 'dir');
+
+                    // Write package.json
+                    const packageJson = {
+                        name: "openrewrite-template-workspace",
+                        version: "1.0.0",
+                        private: true,
+                        dependencies: dependencies
+                    };
+                    fs.writeFileSync(
+                        path.join(targetDir, 'package.json'),
+                        JSON.stringify(packageJson, null, 2)
+                    );
+
+                    return targetDir;
+                } catch (symlinkError) {
+                    // Symlink failed (e.g., cross-device, permissions) - fall through to npm install
+                }
+            }
+
             try {
                 const packageJson = {
                     name: "openrewrite-template-workspace",
@@ -214,6 +250,7 @@ export class DependencyWorkspace {
 
     /**
      * Checks if a workspace is valid (has node_modules and matching package.json).
+     * Handles both real node_modules directories and symlinks to cached workspaces.
      *
      * @param workspaceDir Directory to check
      * @param expectedDependencies Optional dependencies to check against package.json
@@ -222,10 +259,25 @@ export class DependencyWorkspace {
         const nodeModules = path.join(workspaceDir, 'node_modules');
         const packageJsonPath = path.join(workspaceDir, 'package.json');
 
+        // Check node_modules exists (as directory or symlink)
         if (!fs.existsSync(nodeModules) || !fs.existsSync(packageJsonPath)) {
             return false;
         }
 
+        // If node_modules is a symlink, verify the target still exists
+        try {
+            const stats = fs.lstatSync(nodeModules);
+            if (stats.isSymbolicLink()) {
+                const target = fs.readlinkSync(nodeModules);
+                const absoluteTarget = path.isAbsolute(target) ? target : path.resolve(path.dirname(nodeModules), target);
+                if (!fs.existsSync(absoluteTarget)) {
+                    return false;
+                }
+            }
+        } catch {
+            return false;
+        }
+
         // If dependencies provided, check if they match
         if (expectedDependencies) {
             try {