@openrewrite/rewrite 8.70.2 → 8.70.4

package/src/javascript/recipes/upgrade-dependency-version.ts

@@ -17,11 +17,15 @@
 import {Option, ScanningRecipe} from "../../recipe";
 import {ExecutionContext} from "../../execution";
 import {TreeVisitor} from "../../visitor";
-import {getMemberKeyName, isLiteral, Json, JsonVisitor} from "../../json";
+import {Tree} from "../../tree";
+import {getMemberKeyName, isJson, isLiteral, Json, JsonVisitor} from "../../json";
+import {isDocuments, isYaml, Yaml} from "../../yaml";
+import {isPlainText, PlainText} from "../../text";
 import {
     allDependencyScopes,
     DependencyScope,
     findNodeResolutionResult,
+    NpmrcScope,
     PackageManager
 } from "../node-resolution-result";
 import * as path from "path";
@@ -33,6 +37,7 @@ import {
     createLockFileEditor,
     DependencyRecipeAccumulator,
     getAllLockFileNames,
+    getLockFileName,
     parseLockFileContent,
     runInstallIfNeeded,
     runInstallInTempDir,
@@ -44,8 +49,6 @@ import {
  * Information about a project that needs updating
  */
 interface ProjectUpdateInfo {
-    /** Absolute path to the project directory */
-    projectDir: string;
     /** Relative path to package.json (from source root) */
     packageJsonPath: string;
     /** Original package.json content */
@@ -63,9 +66,14 @@ interface ProjectUpdateInfo {
      * already satisfies the new constraint. Only package.json needs updating.
      */
     skipInstall: boolean;
+    /** Config file contents extracted from the project (e.g., .npmrc) */
+    configFiles?: Record<string, string>;
 }
 
-type Accumulator = DependencyRecipeAccumulator<ProjectUpdateInfo>;
+interface Accumulator extends DependencyRecipeAccumulator<ProjectUpdateInfo> {
+    /** Original lock file content, keyed by lock file path */
+    originalLockFiles: Map<string, string>;
+}
 
 /**
  * Upgrades the version of a direct dependency in package.json and updates the lock file.
@@ -101,7 +109,10 @@ export class UpgradeDependencyVersion extends ScanningRecipe<Accumulator> {
     newVersion!: string;
 
     initialValue(_ctx: ExecutionContext): Accumulator {
-        return createDependencyRecipeAccumulator();
+        return {
+            ...createDependencyRecipeAccumulator<ProjectUpdateInfo>(),
+            originalLockFiles: new Map()
+        };
     }
 
     /**
@@ -139,10 +150,38 @@ export class UpgradeDependencyVersion extends ScanningRecipe<Accumulator> {
 
     async scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
         const recipe = this;
+        const LOCK_FILE_NAMES = getAllLockFileNames();
+
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            protected async accept(tree: Tree, ctx: ExecutionContext): Promise<Tree | undefined> {
+                // Handle JSON documents (package.json and JSON lock files)
+                if (isJson(tree) && tree.kind === Json.Kind.Document) {
+                    return this.handleJsonDocument(tree as Json.Document, ctx);
+                }
+
+                // Handle YAML documents (pnpm-lock.yaml)
+                if (isYaml(tree) && isDocuments(tree)) {
+                    return this.handleYamlDocument(tree, ctx);
+                }
+
+                // Handle PlainText files (yarn.lock for Yarn Classic)
+                if (isPlainText(tree)) {
+                    return this.handlePlainTextDocument(tree as PlainText, ctx);
+                }
+
+                return tree;
+            }
+
+            private async handleJsonDocument(doc: Json.Document, _ctx: ExecutionContext): Promise<Json | undefined> {
+                const basename = path.basename(doc.sourcePath);
 
-        return new class extends JsonVisitor<ExecutionContext> {
-            protected async visitDocument(doc: Json.Document, _ctx: ExecutionContext): Promise<Json | undefined> {
-                // Only process package.json files
+                // Capture JSON lock file content (package-lock.json, bun.lock)
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(doc.sourcePath, await TreePrinters.print(doc));
+                    return doc;
+                }
+
+                // Only process package.json files for dependency analysis
                 if (!doc.sourcePath.endsWith('package.json')) {
                     return doc;
                 }
@@ -152,8 +191,6 @@ export class UpgradeDependencyVersion extends ScanningRecipe<Accumulator> {
                     return doc;
                 }
 
-                // Get the project directory and package manager
-                const projectDir = path.dirname(path.resolve(doc.sourcePath));
                 const pm = marker.packageManager ?? PackageManager.Npm;
 
                 // Check each dependency scope for the target package
@@ -189,22 +226,43 @@ export class UpgradeDependencyVersion extends ScanningRecipe<Accumulator> {
                 const skipInstall = resolvedDep !== undefined &&
                     semver.satisfies(resolvedDep.version, recipe.newVersion);
 
+                // Extract project-level .npmrc config from marker
+                const configFiles: Record<string, string> = {};
+                const projectNpmrc = marker.npmrcConfigs?.find(c => c.scope === NpmrcScope.Project);
+                if (projectNpmrc) {
+                    const lines = Object.entries(projectNpmrc.properties)
+                        .map(([key, value]) => `${key}=${value}`);
+                    configFiles['.npmrc'] = lines.join('\n');
+                }
+
                 acc.projectsToUpdate.set(doc.sourcePath, {
-                    projectDir,
                     packageJsonPath: doc.sourcePath,
-                    originalPackageJson: await this.printDocument(doc),
+                    originalPackageJson: await TreePrinters.print(doc),
                     dependencyScope: foundScope,
                     currentVersion,
                     newVersion: recipe.newVersion,
                     packageManager: pm,
-                    skipInstall
+                    skipInstall,
+                    configFiles: Object.keys(configFiles).length > 0 ? configFiles : undefined
                 });
 
                 return doc;
             }
 
-            private async printDocument(doc: Json.Document): Promise<string> {
-                return TreePrinters.print(doc);
+            private async handleYamlDocument(docs: Yaml.Documents, _ctx: ExecutionContext): Promise<Yaml.Documents | undefined> {
+                const basename = path.basename(docs.sourcePath);
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(docs.sourcePath, await TreePrinters.print(docs));
+                }
+                return docs;
+            }
+
+            private async handlePlainTextDocument(text: PlainText, _ctx: ExecutionContext): Promise<PlainText | undefined> {
+                const basename = path.basename(text.sourcePath);
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(text.sourcePath, await TreePrinters.print(text));
+                }
+                return text;
             }
         };
     }
@@ -281,6 +339,7 @@ export class UpgradeDependencyVersion extends ScanningRecipe<Accumulator> {
     /**
      * Runs the package manager in a temporary directory to update the lock file.
      * Writes a modified package.json with the new version, then runs install to update the lock file.
+     * All file contents are provided from in-memory sources (SourceFiles), not read from disk.
      */
     private async runPackageManagerInstall(
         acc: Accumulator,
@@ -294,10 +353,23 @@ export class UpgradeDependencyVersion extends ScanningRecipe<Accumulator> {
             updateInfo.newVersion
         );
 
+        // Get the lock file path based on package manager
+        const lockFileName = getLockFileName(updateInfo.packageManager);
+        const packageJsonDir = path.dirname(updateInfo.packageJsonPath);
+        const lockFilePath = packageJsonDir === '.'
+            ? lockFileName
+            : path.join(packageJsonDir, lockFileName);
+
+        // Look up the original lock file content from captured SourceFiles
+        const originalLockFileContent = acc.originalLockFiles.get(lockFilePath);
+
         const result = await runInstallInTempDir(
-            updateInfo.projectDir,
             updateInfo.packageManager,
-            modifiedPackageJson
+            modifiedPackageJson,
+            {
+                originalLockFileContent,
+                configFiles: updateInfo.configFiles
+            }
         );
 
         storeInstallResult(result, acc, updateInfo, modifiedPackageJson);

package/src/javascript/recipes/upgrade-transitive-dependency-version.ts

@@ -17,11 +17,15 @@
 import {Option, ScanningRecipe} from "../../recipe";
 import {ExecutionContext} from "../../execution";
 import {TreeVisitor} from "../../visitor";
-import {Json, JsonParser, JsonVisitor} from "../../json";
+import {Tree} from "../../tree";
+import {isJson, Json, JsonParser, JsonVisitor} from "../../json";
+import {isDocuments, isYaml, Yaml} from "../../yaml";
+import {isPlainText, PlainText} from "../../text";
 import {
     allDependencyScopes,
     findNodeResolutionResult,
     NodeResolutionResultQueries,
+    NpmrcScope,
     PackageManager
 } from "../node-resolution-result";
 import * as path from "path";
@@ -33,6 +37,7 @@ import {
     createLockFileEditor,
     DependencyRecipeAccumulator,
     getAllLockFileNames,
+    getLockFileName,
     parseLockFileContent,
     runInstallIfNeeded,
     runInstallInTempDir,
@@ -45,8 +50,6 @@ import {applyOverrideToPackageJson, DependencyPathSegment, parseDependencyPath}
  * Information about a project that needs updating
  */
 interface ProjectUpdateInfo {
-    /** Absolute path to the project directory */
-    projectDir: string;
     /** Relative path to package.json (from source root) */
     packageJsonPath: string;
     /** Original package.json content */
@@ -62,9 +65,14 @@ interface ProjectUpdateInfo {
     skipInstall: boolean;
     /** Parsed dependency path for scoped overrides (if specified) */
     dependencyPathSegments?: DependencyPathSegment[];
+    /** Config file contents extracted from the project (e.g., .npmrc) */
+    configFiles?: Record<string, string>;
 }
 
-type Accumulator = DependencyRecipeAccumulator<ProjectUpdateInfo>;
+interface Accumulator extends DependencyRecipeAccumulator<ProjectUpdateInfo> {
+    /** Original lock file content, keyed by lock file path */
+    originalLockFiles: Map<string, string>;
+}
 
 /**
  * Upgrades the version of a transitive dependency by adding override entries to package.json.
@@ -108,15 +116,46 @@ export class UpgradeTransitiveDependencyVersion extends ScanningRecipe<Accumulat
     dependencyPath?: string;
 
     initialValue(_ctx: ExecutionContext): Accumulator {
-        return createDependencyRecipeAccumulator();
+        return {
+            ...createDependencyRecipeAccumulator<ProjectUpdateInfo>(),
+            originalLockFiles: new Map()
+        };
     }
 
     async scanner(acc: Accumulator): Promise<TreeVisitor<any, ExecutionContext>> {
         const recipe = this;
+        const LOCK_FILE_NAMES = getAllLockFileNames();
+
+        return new class extends TreeVisitor<Tree, ExecutionContext> {
+            protected async accept(tree: Tree, ctx: ExecutionContext): Promise<Tree | undefined> {
+                // Handle JSON documents (package.json and JSON lock files)
+                if (isJson(tree) && tree.kind === Json.Kind.Document) {
+                    return this.handleJsonDocument(tree as Json.Document, ctx);
+                }
+
+                // Handle YAML documents (pnpm-lock.yaml)
+                if (isYaml(tree) && isDocuments(tree)) {
+                    return this.handleYamlDocument(tree, ctx);
+                }
 
-        return new class extends JsonVisitor<ExecutionContext> {
-            protected async visitDocument(doc: Json.Document, _ctx: ExecutionContext): Promise<Json | undefined> {
-                // Only process package.json files
+                // Handle PlainText files (yarn.lock for Yarn Classic)
+                if (isPlainText(tree)) {
+                    return this.handlePlainTextDocument(tree as PlainText, ctx);
+                }
+
+                return tree;
+            }
+
+            private async handleJsonDocument(doc: Json.Document, _ctx: ExecutionContext): Promise<Json | undefined> {
+                const basename = path.basename(doc.sourcePath);
+
+                // Capture JSON lock file content (package-lock.json, bun.lock)
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(doc.sourcePath, await TreePrinters.print(doc));
+                    return doc;
+                }
+
+                // Only process package.json files for dependency analysis
                 if (!doc.sourcePath.endsWith('package.json')) {
                     return doc;
                 }
@@ -126,8 +165,6 @@ export class UpgradeTransitiveDependencyVersion extends ScanningRecipe<Accumulat
                     return doc;
                 }
 
-                // Get the project directory and package manager
-                const projectDir = path.dirname(path.resolve(doc.sourcePath));
                 const pm = marker.packageManager ?? PackageManager.Npm;
 
                 // Check if package is a direct dependency - if so, skip (use UpgradeDependencyVersion instead)
@@ -167,21 +204,42 @@ export class UpgradeTransitiveDependencyVersion extends ScanningRecipe<Accumulat
                     ? parseDependencyPath(recipe.dependencyPath)
                     : undefined;
 
+                // Extract project-level .npmrc config from marker
+                const configFiles: Record<string, string> = {};
+                const projectNpmrc = marker.npmrcConfigs?.find(c => c.scope === NpmrcScope.Project);
+                if (projectNpmrc) {
+                    const lines = Object.entries(projectNpmrc.properties)
+                        .map(([key, value]) => `${key}=${value}`);
+                    configFiles['.npmrc'] = lines.join('\n');
+                }
+
                 acc.projectsToUpdate.set(doc.sourcePath, {
-                    projectDir,
                     packageJsonPath: doc.sourcePath,
-                    originalPackageJson: await this.printDocument(doc),
+                    originalPackageJson: await TreePrinters.print(doc),
                     newVersion: recipe.newVersion,
                     packageManager: pm,
                     skipInstall: false, // Always need to run install for overrides
-                    dependencyPathSegments
+                    dependencyPathSegments,
+                    configFiles: Object.keys(configFiles).length > 0 ? configFiles : undefined
                 });
 
                 return doc;
             }
 
-            private async printDocument(doc: Json.Document): Promise<string> {
-                return TreePrinters.print(doc);
+            private async handleYamlDocument(docs: Yaml.Documents, _ctx: ExecutionContext): Promise<Yaml.Documents | undefined> {
+                const basename = path.basename(docs.sourcePath);
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(docs.sourcePath, await TreePrinters.print(docs));
+                }
+                return docs;
+            }
+
+            private async handlePlainTextDocument(text: PlainText, _ctx: ExecutionContext): Promise<PlainText | undefined> {
+                const basename = path.basename(text.sourcePath);
+                if (LOCK_FILE_NAMES.includes(basename)) {
+                    acc.originalLockFiles.set(text.sourcePath, await TreePrinters.print(text));
+                }
+                return text;
             }
         };
     }
@@ -289,6 +347,7 @@ export class UpgradeTransitiveDependencyVersion extends ScanningRecipe<Accumulat
 
     /**
      * Runs the package manager in a temporary directory to update the lock file.
+     * All file contents are provided from in-memory sources (SourceFiles), not read from disk.
      */
     private async runPackageManagerInstall(
         acc: Accumulator,
@@ -301,10 +360,23 @@ export class UpgradeTransitiveDependencyVersion extends ScanningRecipe<Accumulat
             updateInfo
         );
 
+        // Get the lock file path based on package manager
+        const lockFileName = getLockFileName(updateInfo.packageManager);
+        const packageJsonDir = path.dirname(updateInfo.packageJsonPath);
+        const lockFilePath = packageJsonDir === '.'
+            ? lockFileName
+            : path.join(packageJsonDir, lockFileName);
+
+        // Look up the original lock file content from captured SourceFiles
+        const originalLockFileContent = acc.originalLockFiles.get(lockFilePath);
+
         const result = await runInstallInTempDir(
-            updateInfo.projectDir,
             updateInfo.packageManager,
-            modifiedPackageJson
+            modifiedPackageJson,
+            {
+                originalLockFileContent,
+                configFiles: updateInfo.configFiles
+            }
         );
 
         storeInstallResult(result, acc, updateInfo, modifiedPackageJson);

package/src/path-utils.ts

@@ -0,0 +1,208 @@
+/*
+ * 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 fsp from "fs/promises";
+import * as path from "path";
+import {spawnSync} from "child_process";
+
+/**
+ * Default directory exclusions for file/directory discovery.
+ */
+export const DEFAULT_DIR_EXCLUSIONS = new Set([
+    "node_modules",
+    ".git",
+    ".svn",
+    ".hg",
+    "dist",
+    "build",
+    "out",
+    "coverage",
+    ".next",
+    ".nuxt",
+    ".output"
+]);
+
+/**
+ * Checks if a path is ignored by Git.
+ * Returns true if the path is ignored, false otherwise.
+ * Falls back to false if not in a git repository.
+ */
+export function isGitIgnored(filePath: string, cwd?: string): boolean {
+    const result = spawnSync("git", ["check-ignore", "-q", filePath], {
+        cwd: cwd || path.dirname(filePath),
+        encoding: "utf8"
+    });
+    // Exit code 0 means the file IS ignored
+    // Exit code 1 means the file is NOT ignored
+    // Other exit codes indicate git errors (not a repo, etc.)
+    return result.status === 0;
+}
+
+/**
+ * Checks if we're in a git repository.
+ */
+export function isInGitRepo(dir: string): boolean {
+    const result = spawnSync("git", ["rev-parse", "--git-dir"], {
+        cwd: dir,
+        encoding: "utf8"
+    });
+    return result.status === 0;
+}
+
+export interface WalkDirsOptions {
+    /**
+     * Maximum depth to descend. 0 means only immediate children.
+     * undefined means unlimited.
+     */
+    maxDepth?: number;
+
+    /**
+     * Directory names to exclude. Defaults to DEFAULT_DIR_EXCLUSIONS.
+     */
+    excludeDirs?: Set<string>;
+
+    /**
+     * Whether to respect .gitignore. Defaults to false.
+     */
+    respectGitIgnore?: boolean;
+
+    /**
+     * Only include directories containing a file with this name.
+     * Useful for finding package directories by looking for package.json.
+     */
+    mustContainFile?: string;
+}
+
+/**
+ * Recursively walks directories starting from a given path.
+ * Returns all subdirectory paths (not including the root).
+ */
+export async function walkDirs(
+    rootDir: string,
+    options: WalkDirsOptions = {}
+): Promise<string[]> {
+    const {
+        maxDepth,
+        excludeDirs = DEFAULT_DIR_EXCLUSIONS,
+        respectGitIgnore = false,
+        mustContainFile
+    } = options;
+
+    const results: string[] = [];
+    const inGitRepo = respectGitIgnore && isInGitRepo(rootDir);
+
+    async function walk(dir: string, depth: number): Promise<void> {
+        if (maxDepth !== undefined && depth > maxDepth) {
+            return;
+        }
+
+        let entries: fs.Dirent[];
+        try {
+            entries = await fsp.readdir(dir, {withFileTypes: true});
+        } catch {
+            return;
+        }
+
+        for (const entry of entries) {
+            if (!entry.isDirectory()) {
+                continue;
+            }
+
+            // Skip excluded directories
+            if (excludeDirs.has(entry.name)) {
+                continue;
+            }
+
+            // Skip hidden directories
+            if (entry.name.startsWith('.')) {
+                continue;
+            }
+
+            const fullPath = path.join(dir, entry.name);
+
+            // Check git ignore if enabled
+            if (inGitRepo && isGitIgnored(fullPath, rootDir)) {
+                continue;
+            }
+
+            // Check for required file if specified
+            if (mustContainFile) {
+                const requiredFile = path.join(fullPath, mustContainFile);
+                if (fs.existsSync(requiredFile)) {
+                    results.push(fullPath);
+                }
+            } else {
+                results.push(fullPath);
+            }
+
+            // Recurse into subdirectory
+            await walk(fullPath, depth + 1);
+        }
+    }
+
+    await walk(rootDir, 0);
+    return results;
+}
+
+/**
+ * Gets files tracked by git (and untracked but not ignored files).
+ * Falls back to empty array if not in a git repository.
+ */
+export function getGitTrackedFiles(dir: string): string[] {
+    const files: string[] = [];
+
+    // Get tracked files
+    const tracked = spawnSync("git", ["ls-files"], {
+        cwd: dir,
+        encoding: "utf8"
+    });
+
+    if (tracked.status !== 0 || tracked.error) {
+        return [];
+    }
+
+    if (tracked.stdout) {
+        for (const line of tracked.stdout.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed) {
+                const fullPath = path.join(dir, trimmed);
+                if (fs.existsSync(fullPath)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+
+    // Get untracked but not ignored files
+    const untracked = spawnSync("git", ["ls-files", "--others", "--exclude-standard"], {
+        cwd: dir,
+        encoding: "utf8"
+    });
+
+    if (untracked.stdout) {
+        for (const line of untracked.stdout.split("\n")) {
+            const trimmed = line.trim();
+            if (trimmed) {
+                const fullPath = path.join(dir, trimmed);
+                if (fs.existsSync(fullPath)) {
+                    files.push(fullPath);
+                }
+            }
+        }
+    }
+
+    return files;
+}

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

@@ -43,7 +43,13 @@ export interface ParseProjectResponseItem {
 export class ParseProject {
     constructor(
         private readonly projectPath: string,
-        private readonly exclusions?: string[]
+        private readonly exclusions?: string[],
+        /**
+         * Optional path to make source file paths relative to.
+         * If not specified, paths are relative to projectPath.
+         * Use this when parsing a subdirectory but wanting paths relative to the repository root.
+         */
+        private readonly relativeTo?: string
     ) {}
 
     static handle(
@@ -61,6 +67,8 @@ export class ParseProject {
 
                     const projectPath = path.resolve(request.projectPath);
                     const exclusions = request.exclusions ?? DEFAULT_EXCLUSIONS;
+                    // Use relativeTo if specified, otherwise default to projectPath
+                    const relativeTo = request.relativeTo ? path.resolve(request.relativeTo) : projectPath;
 
                     // Use ProjectParser for file discovery and Prettier detection
                     const projectParser = new ProjectParser(projectPath, {exclusions});
@@ -74,7 +82,7 @@ export class ParseProject {
                     if (discovered.packageJsonFiles.length > 0) {
                         const parser = Parsers.createParser("packageJson", {
                             ctx,
-                            relativeTo: projectPath
+                            relativeTo
                         });
                         const generator = parser.parse(...discovered.packageJsonFiles);
 
@@ -93,7 +101,7 @@ export class ParseProject {
 
                     // Parse JSON lock files
                     if (discovered.lockFiles.json.length > 0) {
-                        const parser = Parsers.createParser("json", {ctx, relativeTo: projectPath});
+                        const parser = Parsers.createParser("json", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.lockFiles.json);
 
                         for (const _ of discovered.lockFiles.json) {
@@ -111,7 +119,7 @@ export class ParseProject {
 
                     // Parse YAML lock files
                     if (discovered.lockFiles.yaml.length > 0) {
-                        const parser = Parsers.createParser("yaml", {ctx, relativeTo: projectPath});
+                        const parser = Parsers.createParser("yaml", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.lockFiles.yaml);
 
                         for (const _ of discovered.lockFiles.yaml) {
@@ -129,7 +137,7 @@ export class ParseProject {
 
                     // Parse text lock files (yarn.lock Classic)
                     if (discovered.lockFiles.text.length > 0) {
-                        const parser = Parsers.createParser("plainText", {ctx, relativeTo: projectPath});
+                        const parser = Parsers.createParser("plainText", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.lockFiles.text);
 
                         for (const _ of discovered.lockFiles.text) {
@@ -149,7 +157,7 @@ export class ParseProject {
                     if (discovered.jsFiles.length > 0) {
                         const parser = Parsers.createParser("javascript", {
                             ctx,
-                            relativeTo: projectPath
+                            relativeTo
                         });
 
                         // Check if Prettier is available
@@ -211,7 +219,7 @@ export class ParseProject {
 
                     // Parse other YAML files
                     if (discovered.yamlFiles.length > 0) {
-                        const parser = Parsers.createParser("yaml", {ctx, relativeTo: projectPath});
+                        const parser = Parsers.createParser("yaml", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.yamlFiles);
 
                         for (const _ of discovered.yamlFiles) {
@@ -229,7 +237,7 @@ export class ParseProject {
 
                     // Parse other JSON files
                     if (discovered.jsonFiles.length > 0) {
-                        const parser = Parsers.createParser("json", {ctx, relativeTo: projectPath});
+                        const parser = Parsers.createParser("json", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.jsonFiles);
 
                         for (const _ of discovered.jsonFiles) {
@@ -247,7 +255,7 @@ export class ParseProject {
 
                     // Parse text config files (.prettierignore, .gitignore, etc.)
                     if (discovered.textFiles.length > 0) {
-                        const parser = Parsers.createParser("plainText", {ctx, relativeTo: projectPath});
+                        const parser = Parsers.createParser("plainText", {ctx, relativeTo});
                         const generator = parser.parse(...discovered.textFiles);
 
                         for (const _ of discovered.textFiles) {