From dbf0e64ca280a477b05ffc7e4f259fb94fd4fbd2 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Tue, 27 Aug 2024 11:04:03 -0400
Subject: [PATCH 01/12] fix(core): filter branch in preparation for nx import

---
 e2e/nx/src/import.test.ts                     |  52 ++++++-
 .../src/command-line/import/command-object.ts |   5 +
 packages/nx/src/command-line/import/import.ts |   6 +
 .../import/utils/prepare-source-repo.ts       | 130 +++++++-----------
 packages/nx/src/utils/git-utils.ts            |  60 ++++----
 packages/nx/src/utils/squash.ts               |  14 --
 6 files changed, 135 insertions(+), 132 deletions(-)
 delete mode 100644 packages/nx/src/utils/squash.ts

diff --git a/e2e/nx/src/import.test.ts b/e2e/nx/src/import.test.ts
index 2bb5196d589d1..54ad7ea3874e3 100644
--- a/e2e/nx/src/import.test.ts
+++ b/e2e/nx/src/import.test.ts
@@ -8,7 +8,7 @@ import {
   updateFile,
   e2eCwd,
 } from '@nx/e2e/utils';
-import { mkdirSync, rmdirSync } from 'fs';
+import { writeFileSync, mkdirSync, rmdirSync } from 'fs';
 import { execSync } from 'node:child_process';
 import { join } from 'path';
 
@@ -86,4 +86,54 @@ describe('Nx Import', () => {
     );
     runCLI(`vite:build created-vite-app`);
   });
+
+  it('should be able to import two directories from same repo', () => {
+    // Setup repo with two packages: a and b
+    const repoPath = join(tempImportE2ERoot, 'repo');
+    mkdirSync(repoPath, { recursive: true });
+    writeFileSync(join(repoPath, 'README.md'), `# Repo`);
+    execSync(`git init`, {
+      cwd: repoPath,
+    });
+    execSync(`git add .`, {
+      cwd: repoPath,
+    });
+    execSync(`git commit -am "initial commit"`, {
+      cwd: repoPath,
+    });
+    execSync(`git checkout -b main`, {
+      cwd: repoPath,
+    });
+    mkdirSync(join(repoPath, 'packages/a'), { recursive: true });
+    writeFileSync(join(repoPath, 'packages/a/README.md'), `# A`);
+    execSync(`git add packages/a`, {
+      cwd: repoPath,
+    });
+    execSync(`git commit -m "add package a"`, {
+      cwd: repoPath,
+    });
+    mkdirSync(join(repoPath, 'packages/b'), { recursive: true });
+    writeFileSync(join(repoPath, 'packages/b/README.md'), `# B`);
+    execSync(`git add packages/b`, {
+      cwd: repoPath,
+    });
+    execSync(`git commit -m "add package b"`, {
+      cwd: repoPath,
+    });
+
+    runCLI(
+      `import ${repoPath} packages/a --ref main --source packages/a --no-interactive`,
+      {
+        verbose: true,
+      }
+    );
+    runCLI(
+      `import ${repoPath} packages/b --ref main --source packages/b --no-interactive`,
+      {
+        verbose: true,
+      }
+    );
+
+    checkFilesExist('packages/a/README.md', 'packages/b/README.md');
+  });
 });
diff --git a/packages/nx/src/command-line/import/command-object.ts b/packages/nx/src/command-line/import/command-object.ts
index 0158249d09102..0914ecbdd1c1d 100644
--- a/packages/nx/src/command-line/import/command-object.ts
+++ b/packages/nx/src/command-line/import/command-object.ts
@@ -28,6 +28,11 @@ export const yargsImportCommand: CommandModule = {
             type: 'string',
             description: 'The branch from the source repository to import',
           })
+          .option('depth', {
+            type: 'number',
+            description:
+              'The depth to clone the source repository (limit this for faster git clone)',
+          })
           .option('interactive', {
             type: 'boolean',
             description: 'Interactive mode',
diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index ee120e2d88487..2bcc4cbd29841 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -41,6 +41,10 @@ export interface ImportOptions {
    * The directory in the destination repo to import into
    */
   destination: string;
+  /**
+   * The depth to clone the source repository (limit this for faster clone times)
+   */
+  depth: number;
 
   verbose: boolean;
   interactive: boolean;
@@ -101,6 +105,7 @@ export async function importHandler(options: ImportOptions) {
   try {
     sourceGitClient = await cloneFromUpstream(sourceRemoteUrl, sourceRepoPath, {
       originName: importRemoteName,
+      depth: options.depth,
     });
   } catch (e) {
     spinner.fail(`Failed to clone ${sourceRemoteUrl} into ${sourceRepoPath}`);
@@ -149,6 +154,7 @@ export async function importHandler(options: ImportOptions) {
           name: 'destination',
           message: 'Where in this workspace should the code be imported into?',
           required: true,
+          initial: source ? source : undefined,
         },
       ])
     ).destination;
diff --git a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
index 25cae28176531..f416b77abe13d 100644
--- a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
+++ b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
@@ -25,108 +25,72 @@ export async function prepareSourceRepo(
     new: true,
     base: `${originName}/${ref}`,
   });
+
   spinner.succeed(`Created a ${tempImportBranch} branch based on ${ref}`);
   const relativeSourceDir = relative(
     gitClient.root,
     join(gitClient.root, source)
   );
 
+  if (relativeSourceDir !== '') {
+    spinner.start(
+      `Filtering git history to only include files in ${relativeSourceDir}`
+    );
+    await gitClient.filterBranch(relativeSourceDir, tempImportBranch);
+    spinner.succeed(
+      `Filtered git history to only include files in ${relativeSourceDir}`
+    );
+  }
+
   const destinationInSource = join(gitClient.root, relativeDestination);
   spinner.start(`Moving files and git history to ${destinationInSource}`);
-  if (relativeSourceDir === '') {
-    const files = await gitClient.getGitFiles('.');
-    try {
-      await rm(destinationInSource, {
-        recursive: true,
-      });
-    } catch {}
-    await mkdir(destinationInSource, { recursive: true });
-    const gitignores = new Set<string>();
-    for (const file of files) {
-      if (basename(file) === '.gitignore') {
-        gitignores.add(file);
-        continue;
-      }
-      spinner.start(
-        `Moving files and git history to ${destinationInSource}: ${file}`
-      );
-
-      const newPath = join(destinationInSource, file);
 
-      await mkdir(dirname(newPath), { recursive: true });
-      try {
-        await gitClient.move(file, newPath);
-      } catch {
-        await wait(100);
-        await gitClient.move(file, newPath);
-      }
+  // The result of filter-branch will contain only the files in the subdirectory at its root.
+  const files = await gitClient.getGitFiles('.');
+  try {
+    await rm(destinationInSource, {
+      recursive: true,
+    });
+  } catch {}
+  await mkdir(destinationInSource, { recursive: true });
+  const gitignores = new Set<string>();
+  for (const file of files) {
+    if (basename(file) === '.gitignore') {
+      gitignores.add(file);
+      continue;
     }
-
-    await gitClient.commit(
-      `chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`
+    spinner.start(
+      `Moving files and git history to ${destinationInSource}: ${file}`
     );
 
-    for (const gitignore of gitignores) {
-      await gitClient.move(gitignore, join(destinationInSource, gitignore));
-    }
-    await gitClient.amendCommit();
-    for (const gitignore of gitignores) {
-      await copyFile(
-        join(destinationInSource, gitignore),
-        join(gitClient.root, gitignore)
-      );
-    }
-  } else {
-    let needsSquash = false;
-    const needsMove = destinationInSource !== join(gitClient.root, source);
-    if (needsMove) {
-      try {
-        await rm(destinationInSource, {
-          recursive: true,
-        });
-        await gitClient.commit(
-          `chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`
-        );
-        needsSquash = true;
-      } catch {}
+    const newPath = join(destinationInSource, file);
 
-      await mkdir(destinationInSource, { recursive: true });
+    await mkdir(dirname(newPath), { recursive: true });
+    try {
+      await gitClient.move(file, newPath);
+    } catch {
+      await wait(100);
+      await gitClient.move(file, newPath);
     }
+  }
 
-    const files = await gitClient.getGitFiles('.');
-    for (const file of files) {
-      if (file === '.gitignore') {
-        continue;
-      }
-      spinner.start(
-        `Moving files and git history to ${destinationInSource}: ${file}`
-      );
+  await gitClient.commit(
+    `chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`
+  );
 
-      if (!relative(source, file).startsWith('..')) {
-        if (needsMove) {
-          const newPath = join(destinationInSource, file);
+  for (const gitignore of gitignores) {
+    await gitClient.move(gitignore, join(destinationInSource, gitignore));
+  }
 
-          await mkdir(dirname(newPath), { recursive: true });
-          try {
-            await gitClient.move(file, newPath);
-          } catch {
-            await wait(100);
-            await gitClient.move(file, newPath);
-          }
-        }
-      } else {
-        await rm(join(gitClient.root, file), {
-          recursive: true,
-        });
-      }
-    }
-    await gitClient.commit(
-      `chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`
+  await gitClient.amendCommit();
+
+  for (const gitignore of gitignores) {
+    await copyFile(
+      join(destinationInSource, gitignore),
+      join(gitClient.root, gitignore)
     );
-    if (needsSquash) {
-      await gitClient.squashLastTwoCommits();
-    }
   }
+
   spinner.succeed(
     `${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`
   );
diff --git a/packages/nx/src/utils/git-utils.ts b/packages/nx/src/utils/git-utils.ts
index f4811781f4aee..1d58d3e90570d 100644
--- a/packages/nx/src/utils/git-utils.ts
+++ b/packages/nx/src/utils/git-utils.ts
@@ -2,8 +2,6 @@ import { exec, ExecOptions, execSync, ExecSyncOptions } from 'child_process';
 import { logger } from '../devkit-exports';
 import { dirname, join } from 'path';
 
-const SQUASH_EDITOR = join(__dirname, 'squash.js');
-
 function execAsync(command: string, execOptions: ExecOptions) {
   return new Promise<string>((res, rej) => {
     exec(command, execOptions, (err, stdout, stderr) => {
@@ -18,10 +16,14 @@ function execAsync(command: string, execOptions: ExecOptions) {
 export async function cloneFromUpstream(
   url: string,
   destination: string,
-  { originName } = { originName: 'origin' }
+  { originName, depth }: { originName: string; depth?: number } = {
+    originName: 'origin',
+  }
 ) {
   await execAsync(
-    `git clone ${url} ${destination} --depth 1 --origin ${originName}`,
+    `git clone ${url} ${destination} ${
+      depth ? `--depth ${depth}` : ''
+    } --origin ${originName}`,
     {
       cwd: dirname(destination),
     }
@@ -42,8 +44,8 @@ export class GitRepository {
       .trim();
   }
 
-  addFetchRemote(remoteName: string, branch: string) {
-    return this.execAsync(
+  async addFetchRemote(remoteName: string, branch: string) {
+    return await this.execAsync(
       `git config --add remote.${remoteName}.fetch "+refs/heads/${branch}:refs/remotes/${remoteName}/${branch}"`
     );
   }
@@ -79,22 +81,16 @@ export class GitRepository {
   }
 
   async reset(ref: string) {
-    return this.execAsync(`git reset ${ref} --hard`);
-  }
-
-  async squashLastTwoCommits() {
-    return this.execAsync(
-      `git -c core.editor="node ${SQUASH_EDITOR}" rebase --interactive --no-autosquash HEAD~2`
-    );
+    return await this.execAsync(`git reset ${ref} --hard`);
   }
 
   async mergeUnrelatedHistories(ref: string, message: string) {
-    return this.execAsync(
+    return await this.execAsync(
       `git merge ${ref} -X ours --allow-unrelated-histories -m "${message}"`
     );
   }
   async fetch(remote: string, ref?: string) {
-    return this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
+    return await this.execAsync(`git fetch ${remote}${ref ? ` ${ref}` : ''}`);
   }
 
   async checkout(
@@ -104,7 +100,7 @@ export class GitRepository {
       base: string;
     }
   ) {
-    return this.execAsync(
+    return await this.execAsync(
       `git checkout ${opts.new ? '-b ' : ' '}${branch}${
         opts.base ? ' ' + opts.base : ''
       }`
@@ -112,30 +108,34 @@ export class GitRepository {
   }
 
   async move(path: string, destination: string) {
-    return this.execAsync(`git mv "${path}" "${destination}"`);
+    return await this.execAsync(`git mv "${path}" "${destination}"`);
   }
 
   async push(ref: string, remoteName: string) {
-    return this.execAsync(`git push -u -f ${remoteName} ${ref}`);
+    return await this.execAsync(`git push -u -f ${remoteName} ${ref}`);
   }
 
   async commit(message: string) {
-    return this.execAsync(`git commit -am "${message}"`);
+    return await this.execAsync(`git commit -am "${message}"`);
   }
   async amendCommit() {
-    return this.execAsync(`git commit --amend -a --no-edit`);
+    return await this.execAsync(`git commit --amend -a --no-edit`);
   }
 
-  deleteGitRemote(name: string) {
-    return this.execAsync(`git remote rm ${name}`);
+  async deleteGitRemote(name: string) {
+    return await this.execAsync(`git remote rm ${name}`);
   }
 
-  deleteBranch(branch: string) {
-    return this.execAsync(`git branch -D ${branch}`);
+  async addGitRemote(name: string, url: string) {
+    return await this.execAsync(`git remote add ${name} ${url}`);
   }
 
-  addGitRemote(name: string, url: string) {
-    return this.execAsync(`git remote add ${name} ${url}`);
+  async filterBranch(subdirectory: string, branchName: string) {
+    // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
+    await this.execAsync(`git config core.quotepath false`);
+    return await this.execAsync(
+      `git filter-branch --subdirectory-filter ${subdirectory} -- ${branchName}`
+    );
   }
 }
 
@@ -150,14 +150,6 @@ export function updateRebaseFile(contents: string): string {
   return lines.join('\n');
 }
 
-export function fetchGitRemote(
-  name: string,
-  branch: string,
-  execOptions: ExecSyncOptions
-) {
-  return execSync(`git fetch ${name} ${branch} --depth 1`, execOptions);
-}
-
 /**
  * This is currently duplicated in Nx Console. Please let @MaxKless know if you make changes here.
  */
diff --git a/packages/nx/src/utils/squash.ts b/packages/nx/src/utils/squash.ts
deleted file mode 100644
index f565c068e0dc7..0000000000000
--- a/packages/nx/src/utils/squash.ts
+++ /dev/null
@@ -1,14 +0,0 @@
-import { readFileSync, writeFileSync } from 'fs';
-import { updateRebaseFile } from './git-utils';
-
-// This script is used as an editor for git rebase -i
-
-// This is the file which git creates. When this script exits, the updates should be written to this file.
-const filePath = process.argv[2];
-
-// Change the second commit from pick to fixup
-const contents = readFileSync(filePath).toString();
-const newContents = updateRebaseFile(contents);
-
-// Write the updated contents back to the file
-writeFileSync(filePath, newContents);

From bbed59599357843bd8795c4cb8034ada7b58be1f Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Tue, 27 Aug 2024 16:15:26 -0400
Subject: [PATCH 02/12] fix(core): use git-filter-repo if it is installed

---
 .../src/command-line/import/command-object.ts   |  2 +-
 packages/nx/src/command-line/import/import.ts   |  2 +-
 .../import/utils/prepare-source-repo.ts         | 15 +++++++++++----
 packages/nx/src/utils/git-utils.ts              | 17 +++++++++++++++++
 4 files changed, 30 insertions(+), 6 deletions(-)

diff --git a/packages/nx/src/command-line/import/command-object.ts b/packages/nx/src/command-line/import/command-object.ts
index 0914ecbdd1c1d..60b9290dd6985 100644
--- a/packages/nx/src/command-line/import/command-object.ts
+++ b/packages/nx/src/command-line/import/command-object.ts
@@ -5,7 +5,7 @@ import { handleErrors } from '../../utils/params';
 
 export const yargsImportCommand: CommandModule = {
   command: 'import [sourceRemoteUrl] [destination]',
-  describe: false,
+  describe: `Import a project into the current workspace. Install git-filter-repo for faster imports (https://github.com/newren/git-filter-repo).`,
   builder: (yargs) =>
     linkToNxDevAndExamples(
       withVerbose(
diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 2bcc4cbd29841..88a3acdf15353 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -94,7 +94,7 @@ export async function importHandler(options: ImportOptions) {
 
   const sourceRepoPath = join(tempImportDirectory, 'repo');
   const spinner = createSpinner(
-    `Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath}`
+    `Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath} (Hint: use --depth to limit the clone depth for faster clone times)`
   ).start();
   try {
     await rm(tempImportDirectory, { recursive: true });
diff --git a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
index f416b77abe13d..021f19527b197 100644
--- a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
+++ b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
@@ -33,10 +33,17 @@ export async function prepareSourceRepo(
   );
 
   if (relativeSourceDir !== '') {
-    spinner.start(
-      `Filtering git history to only include files in ${relativeSourceDir}`
-    );
-    await gitClient.filterBranch(relativeSourceDir, tempImportBranch);
+    if (await gitClient.hasFilterRepoInstalled()) {
+      spinner.start(
+        `Filtering git history to only include files in ${relativeSourceDir}`
+      );
+      await gitClient.filterRepo(relativeSourceDir);
+    } else {
+      spinner.start(
+        `Filtering git history to only include files in ${relativeSourceDir} (this might take a few minutes -- install git-filter-repo for faster performance)`
+      );
+      await gitClient.filterBranch(relativeSourceDir, tempImportBranch);
+    }
     spinner.succeed(
       `Filtered git history to only include files in ${relativeSourceDir}`
     );
diff --git a/packages/nx/src/utils/git-utils.ts b/packages/nx/src/utils/git-utils.ts
index 1d58d3e90570d..3aa90f0571e81 100644
--- a/packages/nx/src/utils/git-utils.ts
+++ b/packages/nx/src/utils/git-utils.ts
@@ -130,6 +130,23 @@ export class GitRepository {
     return await this.execAsync(`git remote add ${name} ${url}`);
   }
 
+  async hasFilterRepoInstalled() {
+    try {
+      await this.execAsync(`git filter-repo --help`);
+      return true;
+    } catch {
+      return false;
+    }
+  }
+
+  // git-filter-repo is much faster than filter-branch, but needs to be installed by user
+  // Use `hasFilterRepoInstalled` to check if it's installed
+  async filterRepo(subdirectory: string) {
+    return await this.execAsync(
+      `git filter-repo -f --subdirectory-filter ${subdirectory}`
+    );
+  }
+
   async filterBranch(subdirectory: string, branchName: string) {
     // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
     await this.execAsync(`git config core.quotepath false`);

From 0da6f6365347a46aaaaea99b2d634ec00b9c4c8f Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Tue, 27 Aug 2024 16:21:21 -0400
Subject: [PATCH 03/12] fix(core): nx import uses single-quotes (') in commands
 to avoid interpolation

---
 packages/nx/src/utils/git-utils.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/nx/src/utils/git-utils.ts b/packages/nx/src/utils/git-utils.ts
index 3aa90f0571e81..c1740f12664e3 100644
--- a/packages/nx/src/utils/git-utils.ts
+++ b/packages/nx/src/utils/git-utils.ts
@@ -108,7 +108,7 @@ export class GitRepository {
   }
 
   async move(path: string, destination: string) {
-    return await this.execAsync(`git mv "${path}" "${destination}"`);
+    return await this.execAsync(`git mv '${path}' '${destination}'`);
   }
 
   async push(ref: string, remoteName: string) {

From 18b65889857f88f1eed71bda108f2b7b9a2a3306 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Tue, 27 Aug 2024 16:39:17 -0400
Subject: [PATCH 04/12] fix(core): update docs

---
 packages/nx/src/command-line/import/command-object.ts | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/packages/nx/src/command-line/import/command-object.ts b/packages/nx/src/command-line/import/command-object.ts
index 60b9290dd6985..0914ecbdd1c1d 100644
--- a/packages/nx/src/command-line/import/command-object.ts
+++ b/packages/nx/src/command-line/import/command-object.ts
@@ -5,7 +5,7 @@ import { handleErrors } from '../../utils/params';
 
 export const yargsImportCommand: CommandModule = {
   command: 'import [sourceRemoteUrl] [destination]',
-  describe: `Import a project into the current workspace. Install git-filter-repo for faster imports (https://github.com/newren/git-filter-repo).`,
+  describe: false,
   builder: (yargs) =>
     linkToNxDevAndExamples(
       withVerbose(

From cc7682b5f1106ce2cfa8e4813eb1e8e8baace49f Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Wed, 28 Aug 2024 11:39:00 -0400
Subject: [PATCH 05/12] fix(core): handle special characters when listing and
 moving files

---
 .../import/utils/prepare-source-repo.ts       | 16 ------
 packages/nx/src/utils/git-utils.spec.ts       | 45 ---------------
 packages/nx/src/utils/git-utils.ts            | 57 ++++++++++++-------
 3 files changed, 35 insertions(+), 83 deletions(-)

diff --git a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
index 021f19527b197..b8858e9e98bc8 100644
--- a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
+++ b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
@@ -60,12 +60,7 @@ export async function prepareSourceRepo(
     });
   } catch {}
   await mkdir(destinationInSource, { recursive: true });
-  const gitignores = new Set<string>();
   for (const file of files) {
-    if (basename(file) === '.gitignore') {
-      gitignores.add(file);
-      continue;
-    }
     spinner.start(
       `Moving files and git history to ${destinationInSource}: ${file}`
     );
@@ -85,19 +80,8 @@ export async function prepareSourceRepo(
     `chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`
   );
 
-  for (const gitignore of gitignores) {
-    await gitClient.move(gitignore, join(destinationInSource, gitignore));
-  }
-
   await gitClient.amendCommit();
 
-  for (const gitignore of gitignores) {
-    await copyFile(
-      join(destinationInSource, gitignore),
-      join(gitClient.root, gitignore)
-    );
-  }
-
   spinner.succeed(
     `${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`
   );
diff --git a/packages/nx/src/utils/git-utils.spec.ts b/packages/nx/src/utils/git-utils.spec.ts
index e7de503b58d05..67bc43ad2b2fd 100644
--- a/packages/nx/src/utils/git-utils.spec.ts
+++ b/packages/nx/src/utils/git-utils.spec.ts
@@ -1,7 +1,6 @@
 import {
   extractUserAndRepoFromGitHubUrl,
   getGithubSlugOrNull,
-  updateRebaseFile,
 } from './git-utils';
 import { execSync } from 'child_process';
 
@@ -221,48 +220,4 @@ describe('git utils tests', () => {
       });
     });
   });
-
-  describe('updateRebaseFile', () => {
-    let rebaseFileContents;
-
-    beforeEach(() => {
-      rebaseFileContents = `pick 6a642190 chore(repo): hi
-pick 022528d9 chore(repo): prepare for import
-pick 84ef7741 feat(repo): complete import of git@github.com:FrozenPandaz/created-vite-app.git
-
-# Rebase 3441f39e..84ef7741 onto 3441f39e (3 commands)
-#
-# Commands:
-# p, pick <commit> = use commit
-# r, reword <commit> = use commit, but edit the commit message
-# e, edit <commit> = use commit, but stop for amending
-# s, squash <commit> = use commit, but meld into previous commit
-# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
-#                    commit's log message, unless -C is used, in which case
-#                    keep only this commit's message; -c is same as -C but
-#                    opens the editor
-# x, exec <command> = run command (the rest of the line) using shell
-# b, break = stop here (continue rebase later with 'git rebase --continue')
-# d, drop <commit> = remove commit
-# l, label <label> = label current HEAD with a name
-# t, reset <label> = reset HEAD to a label
-# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
-#         create a merge commit using the original merge commit's
-#         message (or the oneline, if no original merge commit was
-#         specified); use -c <commit> to reword the commit message
-# u, update-ref <ref> = track a placeholder for the <ref> to be updated
-#                       to this position in the new commits. The <ref> is
-#                       updated at the end of the rebase
-#
-# These lines can be re-ordered; they are executed from top to bottom.
-#
-# If you remove a line here THAT COMMIT WILL BE LOST.
-#
-# However, if you remove everything, the rebase will be aborted.`;
-    });
-
-    it('should squash the last 2 commits', () => {
-      expect(updateRebaseFile(rebaseFileContents)).toMatchSnapshot();
-    });
-  });
 });
diff --git a/packages/nx/src/utils/git-utils.ts b/packages/nx/src/utils/git-utils.ts
index c1740f12664e3..e9b741ce119c6 100644
--- a/packages/nx/src/utils/git-utils.ts
+++ b/packages/nx/src/utils/git-utils.ts
@@ -1,6 +1,6 @@
-import { exec, ExecOptions, execSync, ExecSyncOptions } from 'child_process';
+import { exec, ExecOptions, execSync } from 'child_process';
+import { dirname, posix, sep } from 'path';
 import { logger } from '../devkit-exports';
-import { dirname, join } from 'path';
 
 function execAsync(command: string, execOptions: ExecOptions) {
   return new Promise<string>((res, rej) => {
@@ -26,6 +26,7 @@ export async function cloneFromUpstream(
     } --origin ${originName}`,
     {
       cwd: dirname(destination),
+      maxBuffer: 10 * 1024 * 1024,
     }
   );
 
@@ -50,12 +51,6 @@ export class GitRepository {
     );
   }
 
-  private execAsync(command: string) {
-    return execAsync(command, {
-      cwd: this.root,
-    });
-  }
-
   async showStat() {
     return await this.execAsync(`git show --stat`);
   }
@@ -73,9 +68,11 @@ export class GitRepository {
   }
 
   async getGitFiles(path: string) {
-    return (await this.execAsync(`git ls-files ${path}`))
+    // Use -z to return file names exactly as they are stored in git, separated by NULL (\x00) character.
+    // This avoids problems with special characters in file names.
+    return (await this.execAsync(`git ls-files -z ${path}`))
       .trim()
-      .split('\n')
+      .split('\x00')
       .map((s) => s.trim())
       .filter(Boolean);
   }
@@ -108,7 +105,11 @@ export class GitRepository {
   }
 
   async move(path: string, destination: string) {
-    return await this.execAsync(`git mv '${path}' '${destination}'`);
+    // If source is not found, the -k prevents the command from failing.
+    // This could happen with special characters, although they should be mostly handled.
+    return await this.execAsync(
+      `git mv -k ${this.quotePath(path)} ${this.quotePath(destination)}`
+    );
   }
 
   async push(ref: string, remoteName: string) {
@@ -142,29 +143,41 @@ export class GitRepository {
   // git-filter-repo is much faster than filter-branch, but needs to be installed by user
   // Use `hasFilterRepoInstalled` to check if it's installed
   async filterRepo(subdirectory: string) {
+    // filter-repo requires POSIX path to work
+    const posixPath = subdirectory.split(sep).join(posix.sep);
     return await this.execAsync(
-      `git filter-repo -f --subdirectory-filter ${subdirectory}`
+      `git filter-repo -f --subdirectory-filter ${this.quotePath(posixPath)}`
     );
   }
 
   async filterBranch(subdirectory: string, branchName: string) {
+    // filter-repo requires POSIX path to work
+    const posixPath = subdirectory.split(sep).join(posix.sep);
     // We need non-ASCII file names to not be quoted, or else filter-branch will exclude them.
     await this.execAsync(`git config core.quotepath false`);
     return await this.execAsync(
-      `git filter-branch --subdirectory-filter ${subdirectory} -- ${branchName}`
+      `git filter-branch --subdirectory-filter ${this.quotePath(
+        posixPath
+      )} -- ${branchName}`
     );
   }
-}
 
-/**
- * This is used by the squash editor script to update the rebase file.
- */
-export function updateRebaseFile(contents: string): string {
-  const lines = contents.split('\n');
-  const lastCommitIndex = lines.findIndex((line) => line === '') - 1;
+  private execAsync(command: string) {
+    return execAsync(command, {
+      cwd: this.root,
+      maxBuffer: 10 * 1024 * 1024,
+    });
+  }
 
-  lines[lastCommitIndex] = lines[lastCommitIndex].replace('pick', 'fixup');
-  return lines.join('\n');
+  private quotePath(path: string) {
+    return process.platform === 'win32'
+      ? // Windows/CMD only understands double-quotes, single-quotes are treated as part of the file name
+        // Bash and other shells will substitute `$` in file names with a variable value.
+        `"${path}"`
+      : // e.g. `git mv "$$file.txt" "libs/a/$$file.txt"` will not work since `$$` is swapped with the PID of the last process.
+        // Using single-quotes prevents this substitution.
+        `'${path}'`;
+  }
 }
 
 /**

From 5e0d961cb0fcc9245584871551bc58c122fb9b33 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 09:59:32 -0400
Subject: [PATCH 06/12] fix(core): nx import checks the source package using
 the given branch

---
 packages/nx/src/command-line/import/import.ts | 25 +++++++++++++------
 .../import/utils/prepare-source-repo.ts       | 19 +++-----------
 2 files changed, 21 insertions(+), 23 deletions(-)

diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 88a3acdf15353..99e1f20aa0451 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -163,6 +163,23 @@ export async function importHandler(options: ImportOptions) {
   const absSource = join(sourceRepoPath, source);
   const absDestination = join(process.cwd(), destination);
 
+  const destinationGitClient = new GitRepository(process.cwd());
+  await assertDestinationEmpty(destinationGitClient, absDestination);
+
+  const tempImportBranch = getTempImportBranch(ref);
+  await sourceGitClient.addFetchRemote(importRemoteName, ref);
+  await sourceGitClient.fetch(importRemoteName, ref);
+  spinner.succeed(`Fetched ${ref} from ${sourceRemoteUrl}`);
+  spinner.start(
+    `Checking out a temporary branch, ${tempImportBranch} based on ${ref}`
+  );
+  await sourceGitClient.checkout(tempImportBranch, {
+    new: true,
+    base: `${importRemoteName}/${ref}`,
+  });
+
+  spinner.succeed(`Created a ${tempImportBranch} branch based on ${ref}`);
+
   try {
     await stat(absSource);
   } catch (e) {
@@ -171,11 +188,6 @@ export async function importHandler(options: ImportOptions) {
     );
   }
 
-  const destinationGitClient = new GitRepository(process.cwd());
-  await assertDestinationEmpty(destinationGitClient, absDestination);
-
-  const tempImportBranch = getTempImportBranch(ref);
-
   const packageManager = detectPackageManager(workspaceRoot);
 
   const originalPackageWorkspaces = await getPackagesInPackageManagerWorkspace(
@@ -192,8 +204,7 @@ export async function importHandler(options: ImportOptions) {
     source,
     relativeDestination,
     tempImportBranch,
-    sourceRemoteUrl,
-    importRemoteName
+    sourceRemoteUrl
   );
 
   await createTemporaryRemote(
diff --git a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
index b8858e9e98bc8..160e3e280dfb7 100644
--- a/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
+++ b/packages/nx/src/command-line/import/utils/prepare-source-repo.ts
@@ -1,6 +1,6 @@
 import * as createSpinner from 'ora';
-import { basename, dirname, join, relative } from 'path';
-import { copyFile, mkdir, rm } from 'node:fs/promises';
+import { dirname, join, relative } from 'path';
+import { mkdir, rm } from 'node:fs/promises';
 import { GitRepository } from '../../../utils/git-utils';
 
 export async function prepareSourceRepo(
@@ -9,24 +9,11 @@ export async function prepareSourceRepo(
   source: string,
   relativeDestination: string,
   tempImportBranch: string,
-  sourceRemoteUrl: string,
-  originName: string
+  sourceRemoteUrl: string
 ) {
   const spinner = createSpinner().start(
     `Fetching ${ref} from ${sourceRemoteUrl}`
   );
-  await gitClient.addFetchRemote(originName, ref);
-  await gitClient.fetch(originName, ref);
-  spinner.succeed(`Fetched ${ref} from ${sourceRemoteUrl}`);
-  spinner.start(
-    `Checking out a temporary branch, ${tempImportBranch} based on ${ref}`
-  );
-  await gitClient.checkout(tempImportBranch, {
-    new: true,
-    base: `${originName}/${ref}`,
-  });
-
-  spinner.succeed(`Created a ${tempImportBranch} branch based on ${ref}`);
   const relativeSourceDir = relative(
     gitClient.root,
     join(gitClient.root, source)

From 2bf754a3ccb31a09bfe9b0acc79e40634a547ae7 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 12:04:28 -0400
Subject: [PATCH 07/12] fix(core): import clean-up

---
 .../__snapshots__/git-utils.spec.ts.snap      | 37 -------------------
 packages/nx/src/utils/git-utils.ts            |  4 +-
 2 files changed, 1 insertion(+), 40 deletions(-)
 delete mode 100644 packages/nx/src/utils/__snapshots__/git-utils.spec.ts.snap

diff --git a/packages/nx/src/utils/__snapshots__/git-utils.spec.ts.snap b/packages/nx/src/utils/__snapshots__/git-utils.spec.ts.snap
deleted file mode 100644
index 5dc1f3c4715d9..0000000000000
--- a/packages/nx/src/utils/__snapshots__/git-utils.spec.ts.snap
+++ /dev/null
@@ -1,37 +0,0 @@
-// Jest Snapshot v1, https://goo.gl/fbAQLP
-
-exports[`git utils tests updateRebaseFile should squash the last 2 commits 1`] = `
-"pick 6a642190 chore(repo): hi
-pick 022528d9 chore(repo): prepare for import
-fixup 84ef7741 feat(repo): complete import of git@github.com:FrozenPandaz/created-vite-app.git
-
-# Rebase 3441f39e..84ef7741 onto 3441f39e (3 commands)
-#
-# Commands:
-# p, pick <commit> = use commit
-# r, reword <commit> = use commit, but edit the commit message
-# e, edit <commit> = use commit, but stop for amending
-# s, squash <commit> = use commit, but meld into previous commit
-# f, fixup [-C | -c] <commit> = like "squash" but keep only the previous
-#                    commit's log message, unless -C is used, in which case
-#                    keep only this commit's message; -c is same as -C but
-#                    opens the editor
-# x, exec <command> = run command (the rest of the line) using shell
-# b, break = stop here (continue rebase later with 'git rebase --continue')
-# d, drop <commit> = remove commit
-# l, label <label> = label current HEAD with a name
-# t, reset <label> = reset HEAD to a label
-# m, merge [-C <commit> | -c <commit>] <label> [# <oneline>]
-#         create a merge commit using the original merge commit's
-#         message (or the oneline, if no original merge commit was
-#         specified); use -c <commit> to reword the commit message
-# u, update-ref <ref> = track a placeholder for the <ref> to be updated
-#                       to this position in the new commits. The <ref> is
-#                       updated at the end of the rebase
-#
-# These lines can be re-ordered; they are executed from top to bottom.
-#
-# If you remove a line here THAT COMMIT WILL BE LOST.
-#
-# However, if you remove everything, the rebase will be aborted."
-`;
diff --git a/packages/nx/src/utils/git-utils.ts b/packages/nx/src/utils/git-utils.ts
index e9b741ce119c6..ff16767809bea 100644
--- a/packages/nx/src/utils/git-utils.ts
+++ b/packages/nx/src/utils/git-utils.ts
@@ -105,10 +105,8 @@ export class GitRepository {
   }
 
   async move(path: string, destination: string) {
-    // If source is not found, the -k prevents the command from failing.
-    // This could happen with special characters, although they should be mostly handled.
     return await this.execAsync(
-      `git mv -k ${this.quotePath(path)} ${this.quotePath(destination)}`
+      `git mv ${this.quotePath(path)} ${this.quotePath(destination)}`
     );
   }
 

From 167b18f0d65ba5c6554364461219056d5945404e Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 12:21:37 -0400
Subject: [PATCH 08/12] fix(core): import to warn on mismatched package
 managers

---
 packages/nx/src/command-line/import/import.ts | 59 +++++++++++++++----
 1 file changed, 49 insertions(+), 10 deletions(-)

diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 99e1f20aa0451..5638aaf9c0658 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -237,19 +237,58 @@ export async function importHandler(options: ImportOptions) {
     options.interactive
   );
 
-  if (plugins.length > 0) {
-    output.log({ title: 'Installing Plugins' });
-    installPlugins(workspaceRoot, plugins, pmc, updatePackageScripts);
-
-    await destinationGitClient.amendCommit();
-  } else if (await needsInstall(packageManager, originalPackageWorkspaces)) {
-    output.log({
-      title: 'Installing dependencies for imported code',
+  const sourcePackageManager = detectPackageManager(sourceGitClient.root);
+  if (packageManager !== sourcePackageManager) {
+    output.warn({
+      title: `Mismatched package managers`,
+      bodyLines: [
+        `The source repository is using a different package manager (${sourcePackageManager}) than this workspace (${packageManager}).`,
+        `This could lead to install issues due to discrepancies in "package.json" features.`,
+      ],
     });
+  }
 
-    runInstall(workspaceRoot, getPackageManagerCommand(packageManager));
+  // If install fails, we should continue since the errors could be resolved later.
+  let installFailed = false;
+  if (plugins.length > 0) {
+    try {
+      output.log({ title: 'Installing Plugins' });
+      installPlugins(workspaceRoot, plugins, pmc, updatePackageScripts);
+
+      await destinationGitClient.amendCommit();
+    } catch (e) {
+      installFailed = true;
+      output.error({
+        title: `Install failed: ${e.message || 'Unknown error'}`,
+        bodyLines: [e.stack],
+      });
+    }
+  } else if (await needsInstall(packageManager, originalPackageWorkspaces)) {
+    try {
+      output.log({
+        title: 'Installing dependencies for imported code',
+      });
+
+      runInstall(workspaceRoot, getPackageManagerCommand(packageManager));
+
+      await destinationGitClient.amendCommit();
+    } catch (e) {
+      installFailed = true;
+      output.error({
+        title: `Install failed: ${e.message || 'Unknown error'}`,
+        bodyLines: [e.stack],
+      });
+    }
+  }
 
-    await destinationGitClient.amendCommit();
+  if (installFailed) {
+    const pmc = getPackageManagerCommand(packageManager);
+    output.warn({
+      title: `The import was successful, but the install failed.`,
+      bodyLines: [
+        `You may need to run "${pmc.install} install" manually to resolve the issue.`,
+      ],
+    });
   }
 
   console.log(await destinationGitClient.showStat());

From 6c0bafeaba450720ee5467b1a80f76e24197cc28 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 12:35:01 -0400
Subject: [PATCH 09/12] fix(core): update --depth hint on import

---
 packages/nx/src/command-line/import/import.ts | 14 ++++++++------
 1 file changed, 8 insertions(+), 6 deletions(-)

diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 5638aaf9c0658..476f1513428f4 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -94,7 +94,7 @@ export async function importHandler(options: ImportOptions) {
 
   const sourceRepoPath = join(tempImportDirectory, 'repo');
   const spinner = createSpinner(
-    `Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath} (Hint: use --depth to limit the clone depth for faster clone times)`
+    `Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath} (Use --depth to limit commit history and speed up clone times)`
   ).start();
   try {
     await rm(tempImportDirectory, { recursive: true });
@@ -115,6 +115,9 @@ export async function importHandler(options: ImportOptions) {
   }
   spinner.succeed(`Cloned into ${sourceRepoPath}`);
 
+  // Detecting the package manager before preparing the source repo for import.
+  const sourcePackageManager = detectPackageManager(sourceGitClient.root);
+
   if (!ref) {
     const branchChoices = await sourceGitClient.listBranches();
     ref = (
@@ -237,7 +240,6 @@ export async function importHandler(options: ImportOptions) {
     options.interactive
   );
 
-  const sourcePackageManager = detectPackageManager(sourceGitClient.root);
   if (packageManager !== sourcePackageManager) {
     output.warn({
       title: `Mismatched package managers`,
@@ -281,18 +283,18 @@ export async function importHandler(options: ImportOptions) {
     }
   }
 
+  console.log(await destinationGitClient.showStat());
+
   if (installFailed) {
     const pmc = getPackageManagerCommand(packageManager);
     output.warn({
-      title: `The import was successful, but the install failed.`,
+      title: `The import was successful, but the install failed`,
       bodyLines: [
-        `You may need to run "${pmc.install} install" manually to resolve the issue.`,
+        `You may need to run "${pmc.install}" manually to resolve the issue. The error is logged above.`,
       ],
     });
   }
 
-  console.log(await destinationGitClient.showStat());
-
   output.log({
     title: `Merging these changes into ${getBaseRef(nxJson)}`,
     bodyLines: [

From ef19c0fcfd4f8db6c2005555aad0ea80680596c2 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 13:20:47 -0400
Subject: [PATCH 10/12] fix(core): add a check for if the imported project is
 in workspaces

---
 packages/nx/src/command-line/import/import.ts | 80 ++++++++++++++++++-
 1 file changed, 79 insertions(+), 1 deletion(-)

diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 476f1513428f4..17c491d537594 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -1,4 +1,8 @@
-import { join, relative, resolve } from 'path';
+import { dirname, join, relative, resolve } from 'path';
+import { minimatch } from 'minimatch';
+import { existsSync, promises as fsp } from 'node:fs';
+import * as chalk from 'chalk';
+import { load as yamlLoad } from '@zkochan/js-yaml';
 import { cloneFromUpstream, GitRepository } from '../../utils/git-utils';
 import { stat, mkdir, rm } from 'node:fs/promises';
 import { tmpdir } from 'tmp';
@@ -11,6 +15,9 @@ import { workspaceRoot } from '../../utils/workspace-root';
 import {
   detectPackageManager,
   getPackageManagerCommand,
+  isWorkspacesEnabled,
+  PackageManager,
+  PackageManagerCommands,
 } from '../../utils/package-manager';
 import { resetWorkspaceContext } from '../../utils/workspace-context';
 import { runInstall } from '../init/implementation/utils';
@@ -21,6 +28,7 @@ import {
   getPackagesInPackageManagerWorkspace,
   needsInstall,
 } from './utils/needs-install';
+import { readPackageJson } from '../../project-graph/file-utils';
 
 const importRemoteName = '__tmp_nx_import__';
 
@@ -295,6 +303,8 @@ export async function importHandler(options: ImportOptions) {
     });
   }
 
+  await warnOnMissingWorkspacesEntry(packageManager, pmc, relativeDestination);
+
   output.log({
     title: `Merging these changes into ${getBaseRef(nxJson)}`,
     bodyLines: [
@@ -332,3 +342,71 @@ async function createTemporaryRemote(
   await destinationGitClient.addGitRemote(remoteName, sourceRemoteUrl);
   await destinationGitClient.fetch(remoteName);
 }
+
+// If the user imports a project that isn't in NPM/Yarn/PNPM workspaces, then its dependencies
+// will not be installed. We should warn users and provide instructions on how to fix this.
+async function warnOnMissingWorkspacesEntry(
+  pm: PackageManager,
+  pmc: PackageManagerCommands,
+  pkgPath: string
+) {
+  if (!isWorkspacesEnabled(pm, workspaceRoot)) {
+    output.warn({
+      title: `Missing workspaces in package.json`,
+      bodyLines:
+        pm === 'npm'
+          ? [
+              `We recommend enabling NPM workspaces to install dependencies for the imported project.`,
+              `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
+              `See: https://docs.npmjs.com/cli/using-npm/workspaces`,
+            ]
+          : pm === 'yarn'
+          ? [
+              `We recommend enabling Yarn workspaces to install dependencies for the imported project.`,
+              `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
+              `See: https://yarnpkg.com/features/workspaces`,
+            ]
+          : [
+              `We recommend enabling PNPM workspaces to install dependencies for the imported project.`,
+              `Add the following entry to to pnpm-workspace.yaml and run "${pmc.install}":`,
+              chalk.bold(`packages:\n  - '${pkgPath}'`),
+              `See: https://pnpm.io/workspaces`,
+            ],
+    });
+  } else {
+    // Check if the new package is included in existing workspaces entries. If not, warn the user.
+    let workspaces: string[] | null = null;
+
+    if (pm === 'npm' || pm === 'yarn') {
+      const packageJson = readPackageJson();
+      workspaces = packageJson.workspaces;
+    } else if (pm === 'pnpm') {
+      const yamlPath = join(workspaceRoot, 'pnpm-workspace.yaml');
+      if (existsSync(yamlPath)) {
+        const yamlContent = await fsp.readFile('utf-8');
+        const yaml = yamlLoad(yamlContent);
+        workspaces = yaml.packages;
+      }
+    }
+
+    if (workspaces) {
+      const isPkgIncluded = workspaces.some((w) => minimatch(pkgPath, w));
+      if (!isPkgIncluded) {
+        const pkgsDir = dirname(pkgPath);
+        output.warn({
+          title: `Project missing in workspaces`,
+          bodyLines:
+            pm === 'npm' || pm === 'yarn'
+              ? [
+                  `The imported project (${pkgPath}) is missing the "workspaces" field in package.json.`,
+                  `Add "${pkgsDir}/*" to workspaces run "${pmc.install}".`,
+                ]
+              : [
+                  `The imported project (${pkgPath}) is missing the "packages" field in pnpm-workspaces.yaml.`,
+                  `Add "${pkgsDir}/*" to packages run "${pmc.install}".`,
+                ],
+        });
+      }
+    }
+  }
+}

From b3a6b9ba11a027560738bb37f068958b212d6f39 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 14:20:30 -0400
Subject: [PATCH 11/12] fix(core): import to let users know that root deps may
 need to be imported

---
 packages/nx/src/command-line/import/import.ts | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 17c491d537594..26c7514ad8e42 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -305,6 +305,18 @@ export async function importHandler(options: ImportOptions) {
 
   await warnOnMissingWorkspacesEntry(packageManager, pmc, relativeDestination);
 
+  // When only a subdirectory is imported, there might be devDependencies in the root package.json file
+  // that needs to be ported over as well.
+  if (ref) {
+    output.log({
+      title: `Check root dependencies`,
+      bodyLines: [
+        `"dependencies" and "devDependencies" are not imported from the source repository (${sourceRemoteUrl}).`,
+        `You may need to add some of those dependencies to this workspace in order to run tasks successfully.`,
+      ],
+    });
+  }
+
   output.log({
     title: `Merging these changes into ${getBaseRef(nxJson)}`,
     bodyLines: [

From 5d5aa161ab94405806a5a26ee534984dcdfd1499 Mon Sep 17 00:00:00 2001
From: Jack Hsu <jack.hsu@gmail.com>
Date: Thu, 29 Aug 2024 15:03:47 -0400
Subject: [PATCH 12/12] fix(core): nx import also checks bun workspaces

---
 packages/nx/src/command-line/import/import.ts | 12 +++++++++---
 1 file changed, 9 insertions(+), 3 deletions(-)

diff --git a/packages/nx/src/command-line/import/import.ts b/packages/nx/src/command-line/import/import.ts
index 26c7514ad8e42..3d425c1226424 100644
--- a/packages/nx/src/command-line/import/import.ts
+++ b/packages/nx/src/command-line/import/import.ts
@@ -378,6 +378,12 @@ async function warnOnMissingWorkspacesEntry(
               `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
               `See: https://yarnpkg.com/features/workspaces`,
             ]
+          : pm === 'bun'
+          ? [
+              `We recommend enabling Bun workspaces to install dependencies for the imported project.`,
+              `Add \`"workspaces": ["${pkgPath}"]\` to package.json and run "${pmc.install}".`,
+              `See: https://bun.sh/docs/install/workspaces`,
+            ]
           : [
               `We recommend enabling PNPM workspaces to install dependencies for the imported project.`,
               `Add the following entry to to pnpm-workspace.yaml and run "${pmc.install}":`,
@@ -389,13 +395,13 @@ async function warnOnMissingWorkspacesEntry(
     // Check if the new package is included in existing workspaces entries. If not, warn the user.
     let workspaces: string[] | null = null;
 
-    if (pm === 'npm' || pm === 'yarn') {
+    if (pm === 'npm' || pm === 'yarn' || pm === 'bun') {
       const packageJson = readPackageJson();
       workspaces = packageJson.workspaces;
     } else if (pm === 'pnpm') {
       const yamlPath = join(workspaceRoot, 'pnpm-workspace.yaml');
       if (existsSync(yamlPath)) {
-        const yamlContent = await fsp.readFile('utf-8');
+        const yamlContent = await fsp.readFile(yamlPath, 'utf-8');
         const yaml = yamlLoad(yamlContent);
         workspaces = yaml.packages;
       }
@@ -408,7 +414,7 @@ async function warnOnMissingWorkspacesEntry(
         output.warn({
           title: `Project missing in workspaces`,
           bodyLines:
-            pm === 'npm' || pm === 'yarn'
+            pm === 'npm' || pm === 'yarn' || pm === 'bun'
               ? [
                   `The imported project (${pkgPath}) is missing the "workspaces" field in package.json.`,
                   `Add "${pkgsDir}/*" to workspaces run "${pmc.install}".`,