@openrewrite/rewrite 8.62.6 → 8.62.7

package/src/javascript/type-mapping.ts

@@ -25,6 +25,9 @@ class NonDraftableType {
 export class JavaScriptTypeMapping {
     private readonly typeCache: Map<string | number, Type> = new Map();
     private readonly regExpSymbol: ts.Symbol | undefined;
+    private readonly stringWrapperType: ts.Type | undefined;
+    private readonly numberWrapperType: ts.Type | undefined;
+    private readonly booleanWrapperType: ts.Type | undefined;
 
     constructor(
         private readonly checker: ts.TypeChecker
@@ -35,6 +38,24 @@ export class JavaScriptTypeMapping {
             ts.SymbolFlags.Type,
             false
         );
+
+        // Resolve global wrapper types for primitives from TypeScript's lib
+        const stringSymbol = checker.resolveName("String", undefined, ts.SymbolFlags.Type, false);
+        const numberSymbol = checker.resolveName("Number", undefined, ts.SymbolFlags.Type, false);
+        const booleanSymbol = checker.resolveName("Boolean", undefined, ts.SymbolFlags.Type, false);
+
+        // Store the TypeScript types; conversion to Type happens on-demand
+        if (stringSymbol) {
+            this.stringWrapperType = checker.getDeclaredTypeOfSymbol(stringSymbol);
+        }
+
+        if (numberSymbol) {
+            this.numberWrapperType = checker.getDeclaredTypeOfSymbol(numberSymbol);
+        }
+
+        if (booleanSymbol) {
+            this.booleanWrapperType = checker.getDeclaredTypeOfSymbol(booleanSymbol);
+        }
     }
 
     type(node: ts.Node): Type | undefined {
@@ -171,6 +192,19 @@ export class JavaScriptTypeMapping {
         }) as Type.Method;
     }
 
+    private wrapperType(declaringType: (Type.FullyQualified & Type.Primitive) | Type.FullyQualified) {
+        if (declaringType == Type.Primitive.String && this.stringWrapperType) {
+            return this.getType(this.stringWrapperType) as Type.FullyQualified;
+        } else if ((declaringType == Type.Primitive.Double || declaringType == Type.Primitive.Long) && this.numberWrapperType) {
+            return this.getType(this.numberWrapperType) as Type.FullyQualified;
+        } else if (declaringType == Type.Primitive.Boolean && this.booleanWrapperType) {
+            return this.getType(this.booleanWrapperType) as Type.FullyQualified;
+        } else {
+            // This should not really happen, but we'll fallback to unknown if needed
+            return Type.unknownType as Type.FullyQualified;
+        }
+    }
+
     methodType(node: ts.Node): Type.Method | undefined {
 
         let signature: ts.Signature | undefined;
@@ -289,27 +323,12 @@ export class JavaScriptTypeMapping {
                     } else {
                         declaringType = mappedType as Type.FullyQualified;
                     }
+                } else if (mappedType && mappedType.kind === Type.Kind.Primitive) {
+                    // Box the primitive to its wrapper type
+                    declaringType = this.wrapperType(mappedType as Type.Primitive);
                 } else {
-                    // Handle primitive types and other non-class types
-                    if (mappedType) {
-                        if ((mappedType as any).keyword === 'String') {
-                            declaringType = {
-                                kind: Type.Kind.Class,
-                                fullyQualifiedName: 'String'
-                            } as Type.FullyQualified;
-                        } else if ((mappedType as any).keyword === 'Number') {
-                            declaringType = {
-                                kind: Type.Kind.Class,
-                                fullyQualifiedName: 'Number'
-                            } as Type.FullyQualified;
-                        } else {
-                            // Fallback for other types
-                            declaringType = mappedType as Type.FullyQualified;
-                        }
-                    } else {
-                        // Default to unknown if we can't determine the type
-                        declaringType = Type.unknownType as Type.FullyQualified;
-                    }
+                    // Default to unknown if we can't determine the type
+                    declaringType = Type.unknownType as Type.FullyQualified;
                 }
 
                 // For string methods like 'hello'.split(), ensure we have a proper declaring type for primitives
@@ -317,15 +336,11 @@ export class JavaScriptTypeMapping {
                     // If the expression type is a primitive string, use String as declaring type
                     const typeString = this.checker.typeToString(exprType);
                     if (typeString === 'string' || exprType.flags & ts.TypeFlags.String || exprType.flags & ts.TypeFlags.StringLiteral) {
-                        declaringType = {
-                            kind: Type.Kind.Class,
-                            fullyQualifiedName: 'string'
-                        } as Type.FullyQualified;
+                        declaringType = this.wrapperType(Type.Primitive.String);
                     } else if (typeString === 'number' || exprType.flags & ts.TypeFlags.Number || exprType.flags & ts.TypeFlags.NumberLiteral) {
-                        declaringType = {
-                            kind: Type.Kind.Class,
-                            fullyQualifiedName: 'number'
-                        } as Type.FullyQualified;
+                        declaringType = this.wrapperType(Type.Primitive.Double);
+                    } else if (typeString === 'boolean' || exprType.flags & ts.TypeFlags.Boolean || exprType.flags & ts.TypeFlags.BooleanLiteral) {
+                        declaringType = this.wrapperType(Type.Primitive.Boolean);
                     } else {
                         // Fallback for other primitive types or unknown
                         declaringType = Type.unknownType as Type.FullyQualified;
@@ -338,10 +353,10 @@ export class JavaScriptTypeMapping {
                 // Check if this is an import first
                 const symbol = this.checker.getSymbolAtLocation(node.expression);
                 let moduleSpecifier: string | undefined;
+                let aliasedSymbol: ts.Symbol | undefined;
 
                 if (symbol) {
                     // Check if this is an aliased symbol (i.e., an import)
-                    let aliasedSymbol: ts.Symbol | undefined;
                     if (symbol.flags & ts.SymbolFlags.Alias) {
                         aliasedSymbol = this.checker.getAliasedSymbol(symbol);
                     }
@@ -383,7 +398,12 @@ export class JavaScriptTypeMapping {
                             kind: Type.Kind.Class,
                             fullyQualifiedName: moduleSpecifier
                         } as Type.FullyQualified;
-                        methodName = '<default>';
+                        // For aliased imports, use the original function name from the aliased symbol
+                        if (aliasedSymbol && aliasedSymbol.name) {
+                            methodName = aliasedSymbol.name;
+                        } else {
+                            methodName = '<default>';
+                        }
                     }
                 } else {
                     // Fall back to the original logic for non-imported functions

package/src/rpc/request/generate.ts

@@ -17,6 +17,7 @@ import * as rpc from "vscode-jsonrpc/node";
 import {Recipe, ScanningRecipe} from "../../recipe";
 import {Cursor, rootCursor} from "../../tree";
 import {ExecutionContext} from "../../execution";
+import {withMetrics} from "./metrics";
 
 export interface GenerateResponse {
     ids: string[]
@@ -31,8 +32,11 @@ export class Generate {
                   localObjects: Map<string, any>,
                   preparedRecipes: Map<String, Recipe>,
                   recipeCursors: WeakMap<Recipe, Cursor>,
-                  getObject: (id: string) => any): void {
-        connection.onRequest(new rpc.RequestType<Generate, GenerateResponse, Error>("Generate"), async (request) => {
+                  getObject: (id: string) => any,
+                  metricsCsv?: string): void {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType<Generate, GenerateResponse, Error>("Generate"), withMetrics<Generate, GenerateResponse>("Generate", target, metricsCsv)(async (request) => {
+            target.target = request.id;
             const recipe = preparedRecipes.get(request.id);
             const response = {
                 ids: [],
@@ -57,6 +61,6 @@ export class Generate {
 
             }
             return response;
-        });
+        }));
     }
 }

package/src/rpc/request/get-languages.ts

@@ -1,16 +1,17 @@
 import * as rpc from "vscode-jsonrpc/node";
+import {withMetrics0} from "./metrics";
 
 export class GetLanguages {
-    static handle(connection: rpc.MessageConnection): void {
-        connection.onRequest(new rpc.RequestType0<string[], Error>("GetLanguages"), async () => {
+    static handle(connection: rpc.MessageConnection, metricsCsv?: string): void {
+        const target = {target: ''};
+        connection.onRequest(new rpc.RequestType0<string[], Error>("GetLanguages"), withMetrics0<string[]>("GetLanguages", target, metricsCsv)(async () => {
             // Include all languages you want this server to support receiving from a remote peer
-            const languages: string[] = [
+            return [
                 "org.openrewrite.text.PlainText",
                 "org.openrewrite.json.tree.Json$Document",
                 "org.openrewrite.java.tree.J$CompilationUnit",
                 "org.openrewrite.javascript.tree.JS$CompilationUnit",
             ];
-            return languages;
-        });
+        }));
     }
 }

package/src/rpc/request/get-object.ts

@@ -16,6 +16,7 @@
 import * as rpc from "vscode-jsonrpc/node";
 import {RpcObjectData, RpcObjectState, RpcSendQueue} from "../queue";
 import {ReferenceMap} from "../../reference";
+import {withMetrics, extractSourcePath} from "./metrics";
 
 export class GetObject {
     constructor(private readonly id: string,
@@ -28,11 +29,13 @@ export class GetObject {
         localObjects: Map<string, any | ((input: string) => any)>,
         localRefs: ReferenceMap,
         batchSize: number,
-        trace: boolean
+        trace: boolean,
+        metricsCsv?: string
     ): void {
         const pendingData = new Map<string, RpcObjectData[]>();
+        const target = { target: '' };
 
-        connection.onRequest(new rpc.RequestType<GetObject, any, Error>("GetObject"), async request => {
+        connection.onRequest(new rpc.RequestType<GetObject, any, Error>("GetObject"), withMetrics<GetObject, any>("GetObject", target, metricsCsv)(async request => {
             let objId = request.id;
             if (!localObjects.has(objId)) {
                 return [
@@ -47,9 +50,12 @@ export class GetObject {
                 localObjects.set(objId, obj);
             }
 
+            const obj = localObjects.get(objId);
+            target.target = extractSourcePath(obj);
+
             let allData = pendingData.get(objId);
             if (!allData) {
-                const after = localObjects.get(objId);
+                const after = obj;
                 const before = remoteObjects.get(objId);
 
                 allData = await new RpcSendQueue(localRefs, request.sourceFileType, trace).generate(after, before);
@@ -66,6 +72,6 @@ export class GetObject {
             }
 
             return batch;
-        });
+        }));
     }
 }

package/src/rpc/request/get-recipes.ts

@@ -15,15 +15,17 @@
  */
 import * as rpc from "vscode-jsonrpc/node";
 import {RecipeDescriptor, RecipeRegistry} from "../../recipe";
+import {withMetrics0} from "./metrics";
 
 export class GetRecipes {
-    static handle(connection: rpc.MessageConnection, registry: RecipeRegistry): void {
-        connection.onRequest(new rpc.RequestType0<({ name: string } & RecipeDescriptor)[], Error>("GetRecipes"), async () => {
+    static handle(connection: rpc.MessageConnection, registry: RecipeRegistry, metricsCsv?: string): void {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType0<({ name: string } & RecipeDescriptor)[], Error>("GetRecipes"), withMetrics0<({ name: string } & RecipeDescriptor)[]>("GetRecipes", target, metricsCsv)(async () => {
             const recipes = [];
             for (const [_name, recipe] of registry.all.entries()) {
                 recipes.push(await new recipe().descriptor());
             }
             return recipes;
-        });
+        }));
     }
 }

package/src/rpc/request/install-recipes.ts

@@ -18,6 +18,7 @@ import {RecipeRegistry} from "../../recipe";
 import * as path from "path";
 import * as fs from "fs";
 import {spawn, ChildProcess} from "child_process";
+import {withMetrics} from "./metrics";
 
 export interface InstallRecipesResponse {
     recipesInstalled: number
@@ -68,8 +69,10 @@ export class InstallRecipes {
     }
 
     static handle(connection: rpc.MessageConnection, installDir: string, registry: RecipeRegistry,
-                  logger?: rpc.Logger): void {
-        connection.onRequest(new rpc.RequestType<InstallRecipes, InstallRecipesResponse, Error>("InstallRecipes"), async (request) => {
+                  logger?: rpc.Logger, metricsCsv?: string): void {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType<InstallRecipes, InstallRecipesResponse, Error>("InstallRecipes"), withMetrics<InstallRecipes, InstallRecipesResponse>("InstallRecipes", target, metricsCsv)(async (request) => {
+            target.target = typeof request.recipes === "object" ? request.recipes.packageName : request.recipes;
             const beforeInstall = registry.all.size;
             let resolvedPath;
             let recipesName = request.recipes;
@@ -129,7 +132,7 @@ export class InstallRecipes {
             }
 
             return {recipesInstalled: registry.all.size - beforeInstall};
-        });
+        }));
     }
 }
 

package/src/rpc/request/metrics.ts

@@ -0,0 +1,167 @@
+/*
+ * 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 fs from 'fs';
+import * as rpc from "vscode-jsonrpc/node";
+import {Cursor, isSourceFile, SourceFile} from "../../tree";
+
+const CSV_HEADER = 'request,target,durationMs,memoryUsedBytes,memoryMaxBytes';
+
+/**
+ * Extracts the sourcePath from a tree object, either directly from a SourceFile
+ * or by finding the nearest SourceFile via a cursor.
+ *
+ * @param tree The tree object to extract sourcePath from
+ * @param cursor Optional cursor to find the nearest SourceFile
+ * @returns The sourcePath or empty string if not found
+ */
+export function extractSourcePath(tree: any, cursor?: Cursor): string {
+    if (isSourceFile(tree)) {
+        return (tree as SourceFile).sourcePath || '';
+    }
+
+    if (cursor) {
+        const sourceFile = cursor.firstEnclosing(t => isSourceFile(t));
+        if (sourceFile) {
+            return (sourceFile as SourceFile).sourcePath || '';
+        }
+    }
+
+    return '';
+}
+
+/**
+ * Initializes the metrics CSV file with a header if it doesn't already exist or is empty.
+ * If the file already contains the correct header, this function is a no-op.
+ *
+ * @param metricsCsv The path to the CSV file for recording metrics
+ * @param logger Optional logger for warnings
+ */
+export function initializeMetricsCsv(metricsCsv?: string, logger?: rpc.Logger): void {
+    if (!metricsCsv) {
+        return;
+    }
+
+    try {
+        // Check if file exists and has content
+        if (fs.existsSync(metricsCsv)) {
+            const content = fs.readFileSync(metricsCsv, 'utf8');
+            const firstLine = content.split('\n')[0];
+
+            // If file already has the correct header, skip initialization
+            if (firstLine.trim() === CSV_HEADER) {
+                return;
+            }
+
+            // File exists but has incorrect header - warn and reset
+            if (firstLine.trim()) {
+                logger?.warn(`Metrics CSV file ${metricsCsv} has incorrect header. Expected '${CSV_HEADER}' but found '${firstLine.trim()}'. Resetting file.`);
+            }
+        }
+
+        // Write header to new or empty file (overwrites existing file with incorrect header)
+        fs.writeFileSync(metricsCsv, CSV_HEADER + '\n');
+    } catch (err) {
+        console.error('Failed to initialize metrics CSV:', err);
+    }
+}
+
+/**
+ * Internal function to wrap a handler with metrics recording.
+ */
+async function wrapWithMetrics<R>(
+    handler: () => Promise<R>,
+    target: { target: string },
+    request: string,
+    metricsCsv?: string
+): Promise<R> {
+    if (!metricsCsv) {
+        // No metrics recording requested, just execute the handler
+        return handler();
+    }
+
+    const startTime = Date.now();
+
+    try {
+        const result = await handler();
+        recordMetrics(metricsCsv, target.target, request, startTime);
+        return result;
+    } catch (error) {
+        recordMetrics(metricsCsv, target.target, request, startTime);
+        throw error;
+    }
+}
+
+/**
+ * Wraps an RPC request handler to record performance metrics to a CSV file.
+ *
+ * @param request The request type name (e.g., "Visit", "GetObject")
+ * @param target A mutable object containing the target identifier for metrics
+ * @param metricsCsv Optional path to the CSV file for recording metrics
+ * @returns A function that wraps a request handler with metrics recording
+ */
+export function withMetrics<P, R>(
+    request: string,
+    target: { target: string },
+    metricsCsv?: string
+): (handler: (request: P) => Promise<R>) => (request: P) => Promise<R> {
+    return (handler: (requestParam: P) => Promise<R>) => {
+        return async (requestParam: P): Promise<R> => {
+            return wrapWithMetrics(() => handler(requestParam), target, request, metricsCsv);
+        };
+    };
+}
+
+/**
+ * Wraps an RPC request handler without parameters (RequestType0) to record performance metrics.
+ *
+ * @param request The request type name (e.g., "GetLanguages", "GetRecipes")
+ * @param target A mutable object containing the target identifier for metrics
+ * @param metricsCsv Optional path to the CSV file for recording metrics
+ * @returns A function that wraps a request handler with metrics recording
+ */
+export function withMetrics0<R>(
+    request: string,
+    target: { target: string },
+    metricsCsv?: string
+): (handler: () => Promise<R>) => (token: any) => Promise<R> {
+    return (handler: () => Promise<R>) => {
+        return async (_: any): Promise<R> => {
+            return wrapWithMetrics(handler, target, request, metricsCsv);
+        };
+    };
+}
+
+function recordMetrics(
+    metricsCsv: string,
+    target: string,
+    request: string,
+    startTime: number
+): void {
+    const endTime = Date.now();
+    const memEnd = process.memoryUsage();
+    const durationMs = endTime - startTime;
+
+    const memoryUsedBytes = memEnd.heapUsed;
+    const memoryMaxBytes = memEnd.heapTotal;
+
+    const csvRow = `${request},${target},${durationMs},${memoryUsedBytes},${memoryMaxBytes}\n`;
+
+    try {
+        fs.appendFileSync(metricsCsv, csvRow);
+    } catch (err) {
+        console.error('Failed to write metrics to CSV:', err);
+    }
+}

package/src/rpc/request/parse.ts

@@ -15,11 +15,11 @@
  */
 import * as rpc from "vscode-jsonrpc/node";
 import {ExecutionContext} from "../../execution";
-import {UUID} from "node:crypto";
 import {ParserInput, Parsers} from "../../parser";
-import {randomId} from "../../uuid";
+import {randomId, UUID} from "../../uuid";
 import {produce} from "immer";
 import {SourceFile} from "../../tree";
+import {withMetrics} from "./metrics";
 
 export class Parse {
     constructor(private readonly inputs: ParserInput[],
@@ -27,8 +27,14 @@ export class Parse {
     }
 
     static handle(connection: rpc.MessageConnection,
-                  localObjects: Map<string, ((input: string) => any) | any>): void {
-        connection.onRequest(new rpc.RequestType<Parse, UUID[], Error>("Parse"), async (request) => {
+                  localObjects: Map<string, ((input: string) => any) | any>,
+                  metricsCsv?: string): void {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType<Parse, UUID[], Error>("Parse"), withMetrics<Parse, UUID[]>("Parse", target, metricsCsv)(async (request) => {
+            // Set target to comma-separated list of file paths
+            target.target = request.inputs.map(input =>
+                typeof input === 'string' ? input : input.sourcePath
+            ).join(',');
             let parser = Parsers.createParser("javascript", {
                 ctx: new ExecutionContext(),
                 relativeTo: request.relativeTo
@@ -38,7 +44,7 @@ export class Parse {
                 return [];
             }
             const generator = parser.parse(...request.inputs);
-            const result: string[] = [];
+            const result: UUID[] = [];
 
             for (let i = 0; i < request.inputs.length; i++) {
                 const id = randomId();
@@ -50,6 +56,6 @@ export class Parse {
             }
 
             return result;
-        });
+        }));
     }
 }

package/src/rpc/request/prepare-recipe.ts

@@ -21,6 +21,7 @@ import {Check} from "../../preconditions";
 import {RpcRecipe} from "../recipe";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
+import {withMetrics} from "./metrics";
 
 export class PrepareRecipe {
     constructor(private readonly id: string, private readonly options?: any) {
@@ -28,9 +29,12 @@ export class PrepareRecipe {
 
     static handle(connection: MessageConnection,
                   registry: RecipeRegistry,
-                  preparedRecipes: Map<String, Recipe>) {
+                  preparedRecipes: Map<String, Recipe>,
+                  metricsCsv?: string) {
         const snowflake = SnowflakeId();
-        connection.onRequest(new rpc.RequestType<PrepareRecipe, PrepareRecipeResponse, Error>("PrepareRecipe"), async (request) => {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType<PrepareRecipe, PrepareRecipeResponse, Error>("PrepareRecipe"), withMetrics<PrepareRecipe, PrepareRecipeResponse>("PrepareRecipe", target, metricsCsv)(async (request) => {
+            target.target = request.id;
             const id = snowflake.generate();
             const recipeCtor = registry.all.get(request.id);
             if (!recipeCtor) {
@@ -54,7 +58,7 @@ export class PrepareRecipe {
                 scanVisitor: recipe instanceof ScanningRecipe ? `scan:${id}` : undefined,
                 scanPreconditions: scanPreconditions
             }
-        });
+        }));
     }
 
     /**

package/src/rpc/request/print.ts

@@ -17,6 +17,7 @@ import * as rpc from "vscode-jsonrpc/node";
 import {isSourceFile, Tree} from "../../tree";
 import {MarkerPrinter as PrintMarkerPrinter, printer, PrintOutputCapture} from "../../print";
 import {UUID} from "../../uuid";
+import {withMetrics, extractSourcePath} from "./metrics";
 
 export const enum MarkerPrinter {
     DEFAULT = "DEFAULT",
@@ -29,15 +30,18 @@ export class Print {
     }
 
     static handle(connection: rpc.MessageConnection,
-                  getObject: (id: string, sourceFileType?: string) => any): void {
-        connection.onRequest(new rpc.RequestType<Print, string, Error>("Print"), async request => {
+                  getObject: (id: string, sourceFileType?: string) => any,
+                  metricsCsv?: string): void {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType<Print, string, Error>("Print"), withMetrics<Print, string>("Print", target, metricsCsv)(async request => {
             const tree: Tree = await getObject(request.treeId.toString(), request.sourceFileType);
+            target.target = extractSourcePath(tree);
             const out = new PrintOutputCapture(PrintMarkerPrinter[request.markerPrinter]);
             if (isSourceFile(tree)) {
                 return await printer(tree).print(tree, out);
             } else {
                 return await printer(request.sourceFileType).print(tree, out);
             }
-        });
+        }));
     }
 }

package/src/rpc/request/visit.ts

@@ -18,6 +18,7 @@ import {Recipe, ScanningRecipe} from "../../recipe";
 import {Cursor, rootCursor, Tree} from "../../tree";
 import {TreeVisitor} from "../../visitor";
 import {ExecutionContext} from "../../execution";
+import {withMetrics, extractSourcePath} from "./metrics";
 
 export interface VisitResponse {
     modified: boolean
@@ -37,14 +38,18 @@ export class Visit {
                   preparedRecipes: Map<String, Recipe>,
                   recipeCursors: WeakMap<Recipe, Cursor>,
                   getObject: (id: string, sourceFileType?: string) => any,
-                  getCursor: (cursorIds: string[] | undefined, sourceFileType?: string) => Promise<Cursor>): void {
-        connection.onRequest(new rpc.RequestType<Visit, VisitResponse, Error>("Visit"), async (request) => {
+                  getCursor: (cursorIds: string[] | undefined, sourceFileType?: string) => Promise<Cursor>,
+                  metricsCsv?: string): void {
+        const target = { target: '' };
+        connection.onRequest(new rpc.RequestType<Visit, VisitResponse, Error>("Visit"), withMetrics<Visit, VisitResponse>("Visit", target, metricsCsv)(async (request) => {
             const p = await getObject(request.p, undefined);
             const before: Tree = await getObject(request.treeId, request.sourceFileType);
+            const cursor = await getCursor(request.cursor, request.sourceFileType);
+            target.target = extractSourcePath(before, cursor);
             localObjects.set(before.id.toString(), before);
 
             const visitor = await Visit.instantiateVisitor(request, preparedRecipes, recipeCursors, p);
-            const after = await visitor.visit(before, p, await getCursor(request.cursor, request.sourceFileType));
+            const after = await visitor.visit(before, p, cursor);
             if (!after) {
                 localObjects.delete(before.id.toString());
             } else if (after !== before) {
@@ -52,7 +57,7 @@ export class Visit {
             }
 
             return {modified: before !== after};
-        });
+        }));
     }
 
     private static async instantiateVisitor(request: Visit,

package/src/rpc/rewrite-rpc.ts

@@ -29,6 +29,7 @@ import {
     Visit,
     VisitResponse
 } from "./request";
+import {initializeMetricsCsv} from "./request/metrics";
 import {RpcObjectData, RpcObjectState, RpcReceiveQueue} from "./queue";
 import {RpcRecipe} from "./recipe";
 import {ExecutionContext} from "../execution";
@@ -61,10 +62,14 @@ export class RewriteRpc {
                     batchSize?: number,
                     registry?: RecipeRegistry,
                     logger?: rpc.Logger,
+                    metricsCsv?: string,
                     traceGetObjectOutput?: boolean,
                     traceGetObjectInput?: Writable,
                     recipeInstallDir?: string
                 }) {
+        // Initialize metrics CSV file if configured
+        initializeMetricsCsv(options.metricsCsv, options.logger);
+
         const preparedRecipes: Map<String, Recipe> = new Map();
         const recipeCursors: WeakMap<Recipe, Cursor> = new WeakMap()
 
@@ -74,16 +79,16 @@ export class RewriteRpc {
 
         const registry = options.registry || new RecipeRegistry();
 
-        Visit.handle(this.connection, this.localObjects, preparedRecipes, recipeCursors, getObject, getCursor);
-        Generate.handle(this.connection, this.localObjects, preparedRecipes, recipeCursors, getObject);
+        Visit.handle(this.connection, this.localObjects, preparedRecipes, recipeCursors, getObject, getCursor, options.metricsCsv);
+        Generate.handle(this.connection, this.localObjects, preparedRecipes, recipeCursors, getObject, options.metricsCsv);
         GetObject.handle(this.connection, this.remoteObjects, this.localObjects,
-            this.localRefs, options?.batchSize || 200, !!options?.traceGetObjectOutput);
-        GetRecipes.handle(this.connection, registry);
-        GetLanguages.handle(this.connection);
-        PrepareRecipe.handle(this.connection, registry, preparedRecipes);
-        Parse.handle(this.connection, this.localObjects);
-        Print.handle(this.connection, getObject);
-        InstallRecipes.handle(this.connection, options.recipeInstallDir ?? ".rewrite", registry, options.logger);
+            this.localRefs, options?.batchSize || 200, !!options?.traceGetObjectOutput, options.metricsCsv);
+        GetRecipes.handle(this.connection, registry, options.metricsCsv);
+        GetLanguages.handle(this.connection, options.metricsCsv);
+        PrepareRecipe.handle(this.connection, registry, preparedRecipes, options.metricsCsv);
+        Parse.handle(this.connection, this.localObjects, options.metricsCsv);
+        Print.handle(this.connection, getObject, options.metricsCsv);
+        InstallRecipes.handle(this.connection, options.recipeInstallDir ?? ".rewrite", registry, options.logger, options.metricsCsv);
 
         this.connection.listen();
     }