@wise/wds-codemods 0.0.1-experimental-6c2101b

package/src/utils/hasPackageVersion.ts

@@ -0,0 +1,482 @@
+import { existsSync, readdirSync, readFileSync, statSync } from 'node:fs';
+import path from 'node:path';
+
+import semver from 'semver';
+
+interface PackageJson {
+  name?: string;
+  version?: string;
+  dependencies?: Record<string, string>;
+  devDependencies?: Record<string, string>;
+  peerDependencies?: Record<string, string>;
+  optionalDependencies?: Record<string, string>;
+  workspaces?: string[] | { packages: string[] };
+}
+
+interface CheckOptions {
+  silent: boolean;
+  limitedScope: boolean;
+  checkType?: 'dependencies' | 'nodeModules';
+}
+
+export const packageVersionCache = new Map<string, boolean>();
+
+export default function hasPackageVersion(
+  packageName: string,
+  versionRequirement: string,
+): boolean {
+  return hasPackageVersionFromPath(packageName, versionRequirement, process.cwd(), false);
+}
+
+export function hasPackageVersionFromPath(
+  packageName: string,
+  versionRequirement: string,
+  startPath: string,
+  isMonorepo = false,
+): boolean {
+  const cacheKey = `${packageName}@${versionRequirement}@${startPath}@${isMonorepo}`;
+
+  if (packageVersionCache.has(cacheKey)) {
+    return packageVersionCache.get(cacheKey)!;
+  }
+
+  // Find project root and check for workspace packages
+  const projectRoot = findProjectRoot(startPath);
+  const workspacePackages = projectRoot ? getWorkspacePackages(projectRoot) : [];
+
+  const result =
+    workspacePackages.length > 0
+      ? checkWorkspacePackages(projectRoot!, packageName, versionRequirement, workspacePackages)
+      : isMonorepo
+        ? checkMonorepoPackages(startPath, packageName, versionRequirement)
+        : checkSinglePackage(startPath, packageName, versionRequirement);
+
+  packageVersionCache.set(cacheKey, result);
+  return result;
+}
+
+function getWorkspacePackages(projectRoot: string): string[] {
+  const packages: string[] = [];
+
+  // Check package.json workspaces
+  const packageJsonPath = path.join(projectRoot, 'package.json');
+  if (existsSync(packageJsonPath)) {
+    try {
+      const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8')) as PackageJson;
+      if (packageJson.workspaces) {
+        const workspaces = Array.isArray(packageJson.workspaces)
+          ? packageJson.workspaces
+          : packageJson.workspaces.packages;
+
+        for (const pattern of workspaces) {
+          const searchPath = path.join(projectRoot, pattern.replace('/*', ''));
+
+          if (existsSync(searchPath) && statSync(searchPath).isDirectory()) {
+            if (pattern.endsWith('/*')) {
+              const entries = readdirSync(searchPath);
+              const matchedPackages = entries
+                .map((entry) => path.join(searchPath, entry))
+                .filter((p) => {
+                  try {
+                    return statSync(p).isDirectory() && existsSync(path.join(p, 'package.json'));
+                  } catch {
+                    return false;
+                  }
+                });
+              packages.push(...matchedPackages);
+            } else if (existsSync(path.join(searchPath, 'package.json'))) {
+              packages.push(searchPath);
+            }
+          }
+        }
+      }
+    } catch {
+      // Silent fallback
+    }
+  }
+
+  // Check pnpm-workspace.yaml if no packages found yet
+  if (packages.length === 0) {
+    const pnpmWorkspacePath = path.join(projectRoot, 'pnpm-workspace.yaml');
+    if (existsSync(pnpmWorkspacePath)) {
+      try {
+        const content = readFileSync(pnpmWorkspacePath, 'utf8');
+        const lines = content.split('\n');
+        let inPackagesSection = false;
+        const patterns: string[] = [];
+
+        for (const line of lines) {
+          const trimmedLine = line.trim();
+
+          if (trimmedLine === 'packages:') {
+            inPackagesSection = true;
+          } else if (inPackagesSection) {
+            if (trimmedLine && !line.startsWith(' ') && !line.startsWith('\t')) {
+              break;
+            }
+
+            if (trimmedLine.startsWith('-')) {
+              const pattern = trimmedLine
+                .substring(1)
+                .trim()
+                .replace(/^['"]|['"]$/u, '');
+              if (pattern) {
+                patterns.push(pattern);
+              }
+            }
+          }
+        }
+
+        for (const pattern of patterns) {
+          const searchPath = path.join(projectRoot, pattern.replace('/*', ''));
+
+          if (existsSync(searchPath) && statSync(searchPath).isDirectory()) {
+            if (pattern.endsWith('/*')) {
+              const entries = readdirSync(searchPath);
+              const matchedPackages = entries
+                .map((entry) => path.join(searchPath, entry))
+                .filter((p) => {
+                  try {
+                    return statSync(p).isDirectory() && existsSync(path.join(p, 'package.json'));
+                  } catch {
+                    return false;
+                  }
+                });
+              packages.push(...matchedPackages);
+            } else if (existsSync(path.join(searchPath, 'package.json'))) {
+              packages.push(searchPath);
+            }
+          }
+        }
+      } catch {
+        // Silent fallback
+      }
+    }
+  }
+
+  return packages;
+}
+
+function checkWorkspacePackages(
+  projectRoot: string,
+  packageName: string,
+  versionRequirement: string,
+  workspacePaths: string[],
+): boolean {
+  const foundPackages: string[] = [];
+  const notFoundPackages: string[] = [];
+
+  for (const workspacePath of workspacePaths) {
+    const packageDir = path.basename(workspacePath);
+    const found = checkPackageInDirectory(workspacePath, packageName, versionRequirement, {
+      silent: true,
+      limitedScope: true,
+    });
+
+    (found ? foundPackages : notFoundPackages).push(packageDir);
+  }
+
+  console.log(`📁 Found ${workspacePaths.length} packages to check`);
+
+  if (foundPackages.length > 0) {
+    console.log(
+      `✅ Found ${packageName} in ${foundPackages.length}/${workspacePaths.length} packages:`,
+    );
+    console.log(`   📦 ${foundPackages.join(', ')}`);
+
+    if (notFoundPackages.length > 0) {
+      console.log(`❌ Not found in ${notFoundPackages.length} packages:`);
+      console.log(`   📦 ${notFoundPackages.join(', ')}`);
+    }
+  } else {
+    console.log(`❌ Package ${packageName} not found in any of ${workspacePaths.length} packages`);
+    if (notFoundPackages.length > 0) {
+      console.log(`   📦 Checked: ${notFoundPackages.join(', ')}`);
+    }
+  }
+
+  return foundPackages.length > 0;
+}
+
+function checkMonorepoPackages(
+  packagesPath: string,
+  packageName: string,
+  versionRequirement: string,
+): boolean {
+  console.log(`📦 Checking monorepo packages in: ${packagesPath}`);
+  try {
+    if (!existsSync(packagesPath)) {
+      return false;
+    }
+
+    const packageDirs = readdirSync(packagesPath).filter((entry) =>
+      statSync(path.join(packagesPath, entry)).isDirectory(),
+    );
+
+    console.log(`📁 Found ${packageDirs.length} packages to check`);
+
+    const foundPackages: string[] = [];
+    const notFoundPackages: string[] = [];
+
+    for (const entry of packageDirs) {
+      const packageDir = path.join(packagesPath, entry);
+      const found = checkPackageInDirectory(packageDir, packageName, versionRequirement, {
+        silent: true,
+        limitedScope: true,
+      });
+
+      (found ? foundPackages : notFoundPackages).push(entry);
+    }
+
+    if (foundPackages.length > 0) {
+      console.log(
+        `✅ Found ${packageName} in ${foundPackages.length}/${packageDirs.length} packages:`,
+      );
+      console.log(`   📦 ${foundPackages.join(', ')}`);
+
+      if (notFoundPackages.length > 0) {
+        console.log(`❌ Not found in ${notFoundPackages.length} packages:`);
+        console.log(`   📦 ${notFoundPackages.join(', ')}`);
+      }
+    } else {
+      console.log(`❌ Package ${packageName} not found in any of ${packageDirs.length} packages`);
+      console.log(`   📦 Checked: ${notFoundPackages.join(', ')}`);
+    }
+
+    return foundPackages.length > 0;
+  } catch (error) {
+    console.log(`⚠️ Error checking monorepo packages:`, error);
+    return false;
+  }
+}
+
+function checkSinglePackage(
+  packagePath: string,
+  packageName: string,
+  versionRequirement: string,
+): boolean {
+  const checks = [
+    { type: 'dependencies' as const, msg: 'package.json dependencies' },
+    { type: 'nodeModules' as const, msg: 'node_modules' },
+  ];
+
+  for (const { type } of checks) {
+    if (
+      checkPackageInDirectory(packagePath, packageName, versionRequirement, {
+        silent: true,
+        limitedScope: false,
+        checkType: type,
+      })
+    ) {
+      return true;
+    }
+  }
+
+  return false;
+}
+
+function checkPackageInDirectory(
+  startPath: string,
+  packageName: string,
+  versionRequirement: string,
+  options: CheckOptions,
+): boolean {
+  const { checkType } = options;
+  const packageJsonResult = checkDirectDependencies(
+    startPath,
+    packageName,
+    versionRequirement,
+    options,
+  );
+
+  if (checkType === 'dependencies') return packageJsonResult;
+  if (packageJsonResult) return true;
+  if (checkType === 'nodeModules')
+    return checkNodeModules(startPath, packageName, versionRequirement, options);
+
+  return checkNodeModules(startPath, packageName, versionRequirement, options);
+}
+
+function checkDirectDependencies(
+  startPath: string,
+  packageName: string,
+  versionRequirement: string,
+  { limitedScope }: CheckOptions,
+): boolean {
+  const checker = (dir: string) =>
+    checkPackageJsonInDirectory(dir, packageName, versionRequirement);
+  return limitedScope ? checker(startPath) : walkDirectoryTree(startPath, checker);
+}
+
+function checkNodeModules(
+  startPath: string,
+  packageName: string,
+  versionRequirement: string,
+  { limitedScope }: CheckOptions,
+): boolean {
+  const checker = (dir: string) =>
+    checkStandardNodeModules(dir, packageName, versionRequirement) ||
+    checkPnpmNodeModules(dir, packageName, versionRequirement);
+
+  return limitedScope ? checker(startPath) : walkDirectoryTree(startPath, checker);
+}
+
+function walkDirectoryTree(startPath: string, checkFunction: (dir: string) => boolean): boolean {
+  let currentDir =
+    existsSync(startPath) && statSync(startPath).isFile() ? path.dirname(startPath) : startPath;
+
+  currentDir = path.resolve(currentDir);
+
+  const { root } = path.parse(currentDir);
+  let dirCount = 0;
+  let previousDir = '';
+
+  while (currentDir !== root && currentDir !== previousDir && dirCount < 10) {
+    dirCount += 1;
+
+    if (checkFunction(currentDir)) {
+      return true;
+    }
+
+    previousDir = currentDir;
+    currentDir = path.dirname(currentDir);
+  }
+
+  return false;
+}
+
+function checkPackageJsonInDirectory(
+  dir: string,
+  packageName: string,
+  versionRequirement: string,
+): boolean {
+  const packageJsonPath = path.join(dir, 'package.json');
+
+  if (!existsSync(packageJsonPath)) return false;
+
+  try {
+    const packageJson: PackageJson = JSON.parse(
+      readFileSync(packageJsonPath, 'utf8'),
+    ) as PackageJson;
+    const allDeps = {
+      ...(packageJson.dependencies ?? {}),
+      ...(packageJson.devDependencies ?? {}),
+      ...(packageJson.peerDependencies ?? {}),
+      ...(packageJson.optionalDependencies ?? {}),
+    };
+
+    const installedVersion = allDeps[packageName];
+    return installedVersion ? isVersionSatisfied(installedVersion, versionRequirement) : false;
+  } catch {
+    return false;
+  }
+}
+
+function isVersionSatisfied(installedVersion: string, versionRequirement: string): boolean {
+  if (semver.valid(installedVersion) && semver.satisfies(installedVersion, versionRequirement)) {
+    return true;
+  }
+
+  const cleanVersion = semver.coerce(installedVersion);
+  return cleanVersion ? semver.satisfies(cleanVersion.version, versionRequirement) : false;
+}
+
+function checkStandardNodeModules(
+  baseDir: string,
+  packageName: string,
+  versionRequirement: string,
+): boolean {
+  const packagePath = path.join(baseDir, 'node_modules', packageName, 'package.json');
+  if (!existsSync(packagePath)) return false;
+
+  try {
+    const packageJson: PackageJson = JSON.parse(readFileSync(packagePath, 'utf8')) as PackageJson;
+    return packageJson.version ? semver.satisfies(packageJson.version, versionRequirement) : false;
+  } catch {
+    return false;
+  }
+}
+
+function checkPnpmNodeModules(
+  baseDir: string,
+  packageName: string,
+  versionRequirement: string,
+): boolean {
+  const pnpmDir = path.join(baseDir, 'node_modules', '.pnpm');
+  if (!existsSync(pnpmDir)) return false;
+
+  try {
+    const entries = readdirSync(pnpmDir);
+
+    for (const entry of entries) {
+      if (entry.startsWith(packageName.replace('/', '+')) || entry.includes(`${packageName}@`)) {
+        const packagePath = path.join(pnpmDir, entry, 'node_modules', packageName, 'package.json');
+
+        if (existsSync(packagePath)) {
+          const packageJson: PackageJson = JSON.parse(
+            readFileSync(packagePath, 'utf8'),
+          ) as PackageJson;
+          if (packageJson.version && semver.satisfies(packageJson.version, versionRequirement)) {
+            return true;
+          }
+        }
+      }
+    }
+  } catch {
+    // Silent
+  }
+
+  return false;
+}
+
+export function findClosestGitignore(startPath: string): string | null {
+  let currentDir =
+    existsSync(startPath) && statSync(startPath).isFile() ? path.dirname(startPath) : startPath;
+
+  currentDir = path.resolve(currentDir);
+
+  const { root } = path.parse(currentDir);
+  let dirCount = 0;
+  let previousDir = '';
+
+  while (currentDir !== root && currentDir !== previousDir && dirCount < 10) {
+    dirCount += 1;
+    const gitignorePath = path.join(currentDir, '.gitignore');
+
+    if (existsSync(gitignorePath)) {
+      return gitignorePath;
+    }
+
+    previousDir = currentDir;
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+}
+
+export function findProjectRoot(startPath: string): string | null {
+  let currentDir =
+    existsSync(startPath) && statSync(startPath).isFile() ? path.dirname(startPath) : startPath;
+
+  currentDir = path.resolve(currentDir);
+
+  const { root } = path.parse(currentDir);
+  let dirCount = 0;
+  let previousDir = '';
+
+  while (currentDir !== root && currentDir !== previousDir && dirCount < 10) {
+    dirCount += 1;
+    const packageJsonPath = path.join(currentDir, 'package.json');
+    const gitPath = path.join(currentDir, '.git');
+    const pnpmWorkspacePath = path.join(currentDir, 'pnpm-workspace.yaml');
+
+    if (existsSync(packageJsonPath) || existsSync(gitPath) || existsSync(pnpmWorkspacePath)) {
+      return currentDir;
+    }
+
+    previousDir = currentDir;
+    currentDir = path.dirname(currentDir);
+  }
+
+  return null;
+}

package/src/utils/index.ts

@@ -0,0 +1,4 @@
+export { default as getOptions } from './getOptions';
+export { default as handleError } from './handleError';
+export { default as loadTransformModules } from './loadTransformModules';
+export { default as reportManualReview } from './reportManualReview';

package/src/utils/loadTransformModules.ts

@@ -0,0 +1,28 @@
+import { promises as fs } from 'fs';
+import path from 'path';
+
+interface TransformModule {
+  default: {
+    default: unknown;
+  };
+}
+
+async function loadTransformModules(transformsDir: string) {
+  let transformModules: Record<string, unknown> = {};
+
+  const files = await fs.readdir(transformsDir);
+  const transformFiles = await Promise.all(
+    files
+      .filter((file) => file.endsWith('.js'))
+      .map(async (file) => {
+        const transformPath = path.join(transformsDir, file);
+        const transformModule = (await import(transformPath)) as TransformModule;
+        transformModules = { ...transformModules, [file]: transformModule.default.default };
+        return file.replace('.js', '');
+      }),
+  );
+
+  return { transformModules, transformFiles };
+}
+
+export default loadTransformModules;

package/src/utils/reportManualReview.ts

@@ -0,0 +1,17 @@
+import fs from 'node:fs/promises';
+
+import path from 'path';
+
+const REPORT_PATH = path.resolve(process.cwd(), 'codemod-report.txt');
+
+const reportManualReview = async (filePath: string, message: string): Promise<void> => {
+  const lineMatch = /at line (\d+)/u.exec(message);
+  const lineNumber = lineMatch?.[1];
+
+  const cleanMessage = message.replace(/ at line \d+/u, '');
+  const lineInfo = lineNumber ? `:${lineNumber}` : '';
+
+  await fs.appendFile(REPORT_PATH, `[${filePath}${lineInfo}] ${cleanMessage}\n`, 'utf8');
+};
+
+export default reportManualReview;