NX CLI to clear cache project

[Ashraf-Ali-aa]

It would be good to have in the nx cli to clear all caches like this js below, I am currently using zx to create a js cli to clear caches from different packages, the amount of time I have to debug issues due to a cache issue makes it painful when importing projects or due to transiant issues. I know nx has nx reset but not for diffrent projects like expo nextjs etc. Actually thinking about it, if each nx plugin supported clear-cache then nx can use that when user runs nx reset or a new command nx clear-cache

import { $ } from 'zx';
import { promises as fs } from 'fs';
import os from 'os';
import path from 'path';

const resolvePath = (p) => p.replace(/^~/, os.homedir());

async function getWorkspaceInfo() {
  try {
    const projects = (await $`nx show projects`.quiet()).stdout
      .trim()
      .split('\n');
    const workspaceRoot = process.cwd();
    const possiblePaths = ['', 'apps', 'libs', 'packages']
      .map((prefix) =>
        projects.map((project) => path.resolve(workspaceRoot, prefix, project)),
      )
      .flat();

    const projectPaths = [];
    for (const path of possiblePaths) {
      try {
        await fs.access(path);
        projectPaths.push(path);
      } catch {
        continue;
      }
    }

    return { workspaceRoot, projectPaths };
  } catch (error) {
    const rootPath = process.cwd();
    try {
      await fs.access(rootPath);
      return { workspaceRoot: rootPath, projectPaths: [rootPath] };
    } catch {
      return { workspaceRoot: rootPath, projectPaths: [] };
    }
  }
}

const taskFunctions = {
  async resetNXCache() {
    console.log('[Task] Resetting NX cache...');
    await $`npx nx reset`.quiet();
  },

  async wipeiOSBuildFolder(projectPath) {
    console.log(
      `[Task] Starting to wipe iOS build folder for ${projectPath}...`,
    );
    const iosPath = path.join(projectPath, 'ios');

    try {
      await fs.access(iosPath);
    } catch {
      console.log(`[Skip] iOS directory not found at ${iosPath}`);
      return;
    }

    await $`rm -rf ${iosPath}`.quiet();
    await $`killall Xcode || true`.quiet();
    await $`xcrun -k`.quiet();
    await $`cd ${iosPath} && xcodebuild -alltargets clean`.quiet();

    const darwinUserCacheDir = (
      await $`getconf DARWIN_USER_CACHE_DIR`.quiet()
    ).stdout.trim();
    const pathsToRemove = [
      path.join(darwinUserCacheDir, 'org.llvm.clang', 'ModuleCache'),
      path.join(
        darwinUserCacheDir,
        `org.llvm.clang.${os.userInfo().username}`,
        'ModuleCache',
      ),
      resolvePath('~/Library/Developer/Xcode/DerivedData/'),
      resolvePath('~/Library/Caches/com.apple.dt.Xcode/'),
    ];

    for (const dirPath of pathsToRemove) {
      console.log(`[Task] Attempting to remove: ${dirPath}`);
      await fs.rm(dirPath, { recursive: true, force: true });
    }
  },

  async wipeiOSPodsFolder(projectPath) {
    console.log(
      `[Task] Starting to wipe iOS Pods folder for ${projectPath}...`,
    );
    await fs.rm(path.join(projectPath, 'ios/Pods'), {
      recursive: true,
      force: true,
    });
  },

  async wipeSystemiOSPodsCache(projectPath) {
    console.log(
      `[Task] Starting to wipe system iOS Pods cache for ${projectPath}...`,
    );
    try {
      await fs.access(path.join(projectPath, 'ios'));
      await $`cd ${path.join(
        projectPath,
        'ios',
      )} && bundle exec pod cache clean --all`.quiet();
    } catch {}
  },

  async wipeUseriOSPodsCache() {
    console.log('[Task] Starting to wipe user iOS Pods cache...');
    await fs.rm(resolvePath('~/.cocoapods'), { recursive: true, force: true });
  },

  async wipeAndroidBuildFolder(projectPath) {
    console.log(
      `[Task] Starting to wipe Android build folder for ${projectPath}...`,
    );
    await fs.rm(path.join(projectPath, 'android/build'), {
      recursive: true,
      force: true,
    });
  },

  async cleanAndroidProject(projectPath) {
    console.log(`[Task] Cleaning Android project for ${projectPath}...`);
    try {
      await fs.access(path.join(projectPath, 'android'));
      await $`cd ${path.join(
        projectPath,
        'android',
      )} && ./gradlew clean`.quiet();
    } catch {}
  },

  async watchmanCacheClear() {
    console.log('[Task] Clearing Watchman watches...');
    await $`watchman watch-del-all || true`.quiet();
  },

  async wipeTempCaches() {
    console.log('[Task] Wiping temporary caches...');
    const tmpdir = os.tmpdir();
    await fs.rm(path.join(tmpdir, 'react-native-*'), {
      recursive: true,
      force: true,
    });
    await fs.rm(path.join(tmpdir, 'metro-*'), { recursive: true, force: true });
  },

  async wipeNodeModules(projectPath) {
    console.log(`[Task] Wiping node_modules directory for ${projectPath}...`);
    await fs.rm(path.join(projectPath, 'node_modules'), {
      recursive: true,
      force: true,
    });

    const tmpdir = os.tmpdir();
    console.log('[Task] Wiping npm related temp caches...');
    await fs.rm(path.join(tmpdir, 'react-*'), { recursive: true, force: true });
    await fs.rm(path.join(tmpdir, 'metro-*'), { recursive: true, force: true });
  },

  async npmClearCache() {
    console.log('[Task] Clearing npm cache...');
    await $`npm cache clean --force`.quiet();
  },

  async npmCacheVerify() {
    console.log('[Task] Verifying npm cache...');
    await $`npm cache verify`.quiet();
  },

  async npmInstall(projectPath) {
    try {
      await fs.access(path.join(projectPath, 'package-lock.json'));
      console.log(`[Task] Running npm install for ${projectPath}...\n`);
      await $`cd ${projectPath} && npm ci`;
    } catch {
      console.log(
        '[Warning] package-lock.json not found in project. npm install skipped.',
      );
    }
  },
};

export async function runTasks(tasks) {
  const { workspaceRoot, projectPaths } = await getWorkspaceInfo();

  console.log(`[Info] Workspace root: ${workspaceRoot}`);
  console.log(`[Info] Found projects:`);
  console.log('====================================');
  console.log(projectPaths);
  console.log('====================================');

  for (const task of tasks) {
    console.log(`[Info] Executing task: ${task}`);
    try {
      if (taskFunctions[task]) {
        if (
          task === 'resetNXCache' ||
          task === 'watchmanCacheClear' ||
          task === 'wipeTempCaches' ||
          task === 'npmCacheVerify' ||
          task === 'wipeUseriOSPodsCache'
        ) {
          await taskFunctions[task]();
        } else {
          for (const projectPath of projectPaths) {
            await taskFunctions[task](projectPath);
          }
        }
      } else {
        console.warn(`[Warning] No function defined for task "${task}"`);
      }
    } catch (error) {
      console.error(`[Error] An error occurred during "${task}": ${error}`);
    }
  }
  console.log('[Success] All tasks completed successfully.');
}