nx 19.6.4 → 19.6.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nx",
-  "version": "19.6.4",
+  "version": "19.6.6",
   "private": false,
   "description": "The core Nx plugin contains the core functionality of Nx like the project graph, nx commands and task orchestration.",
   "repository": {
@@ -71,7 +71,7 @@
     "yargs-parser": "21.1.1",
     "node-machine-id": "1.1.12",
     "ora": "5.3.0",
-    "@nrwl/tao": "19.6.4"
+    "@nrwl/tao": "19.6.6"
   },
   "peerDependencies": {
     "@swc-node/register": "^1.8.0",
@@ -86,16 +86,16 @@
     }
   },
   "optionalDependencies": {
-    "@nx/nx-darwin-x64": "19.6.4",
-    "@nx/nx-darwin-arm64": "19.6.4",
-    "@nx/nx-linux-x64-gnu": "19.6.4",
-    "@nx/nx-linux-x64-musl": "19.6.4",
-    "@nx/nx-win32-x64-msvc": "19.6.4",
-    "@nx/nx-linux-arm64-gnu": "19.6.4",
-    "@nx/nx-linux-arm64-musl": "19.6.4",
-    "@nx/nx-linux-arm-gnueabihf": "19.6.4",
-    "@nx/nx-win32-arm64-msvc": "19.6.4",
-    "@nx/nx-freebsd-x64": "19.6.4"
+    "@nx/nx-darwin-x64": "19.6.6",
+    "@nx/nx-darwin-arm64": "19.6.6",
+    "@nx/nx-linux-x64-gnu": "19.6.6",
+    "@nx/nx-linux-x64-musl": "19.6.6",
+    "@nx/nx-win32-x64-msvc": "19.6.6",
+    "@nx/nx-linux-arm64-gnu": "19.6.6",
+    "@nx/nx-linux-arm64-musl": "19.6.6",
+    "@nx/nx-linux-arm-gnueabihf": "19.6.6",
+    "@nx/nx-win32-arm64-msvc": "19.6.6",
+    "@nx/nx-freebsd-x64": "19.6.6"
   },
   "nx-migrations": {
     "migrations": "./migrations.json",

package/release/changelog-renderer/index.d.ts

@@ -41,7 +41,7 @@ export type ChangelogRenderer = (config: {
     changelogRenderOptions: DefaultChangelogRenderOptions;
     dependencyBumps?: DependencyBump[];
     repoSlug?: RepoSlug;
-    conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'];
+    conventionalCommitsConfig: NxReleaseConfig['conventionalCommits'] | null;
 }) => Promise<string> | string;
 /**
  * The specific options available to the default implementation of the ChangelogRenderer that nx exports

package/release/changelog-renderer/index.js

@@ -1,6 +1,7 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const semver_1 = require("semver");
+const conventional_commits_1 = require("../../src/command-line/release/config/conventional-commits");
 const github_1 = require("../../src/command-line/release/utils/github");
 // axios types and values don't seem to match
 const _axios = require("axios");
@@ -10,9 +11,7 @@ const axios = _axios;
  * from the given commits and other metadata.
  */
 const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion, project, entryWhenNoChanges, changelogRenderOptions, dependencyBumps, repoSlug, conventionalCommitsConfig, }) => {
-    const changeTypes = conventionalCommitsConfig.types;
     const markdownLines = [];
-    const breakingChanges = [];
     // If the current range of changes contains both a commit and its revert, we strip them both from the final list. Changes from version plans are unaffected, as they have no hashes.
     for (const change of changes) {
         if (change.type === 'revert' && change.revertedHashes) {
@@ -26,10 +25,38 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
         }
     }
     let relevantChanges = changes;
+    const breakingChanges = [];
+    // For now to keep the interface of the changelog renderer non-breaking for v19 releases we have a somewhat indirect check for whether or not we are generating a changelog for version plans
+    const isVersionPlans = !conventionalCommitsConfig;
+    // Only applicable for version plans
+    const additionalChangesForAuthorsSection = [];
+    // Provide a default configuration for version plans to allow most of the subsequent logic to work in the same way it would for conventional commits
+    // NOTE: The one exception is breaking/major changes, where we do not follow the same structure and instead only show the changes once
+    if (isVersionPlans) {
+        conventionalCommitsConfig = {
+            types: {
+                feat: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.feat,
+                fix: conventional_commits_1.DEFAULT_CONVENTIONAL_COMMITS_CONFIG.types.fix,
+            },
+        };
+        // Trim down "relevant changes" to only include non-breaking ones so that we can render them differently under version plans,
+        // but keep track of the changes for the purposes of the authors section
+        // TODO(v20): Clean this abstraction up as part of the larger overall refactor of changelog rendering
+        for (let i = 0; i < relevantChanges.length; i++) {
+            if (relevantChanges[i].isBreaking) {
+                const change = relevantChanges[i];
+                additionalChangesForAuthorsSection.push(change);
+                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoSlug);
+                breakingChanges.push(line);
+                relevantChanges.splice(i, 1);
+            }
+        }
+    }
+    const changeTypes = conventionalCommitsConfig.types;
     // workspace root level changelog
     if (project === null) {
         // No changes for the workspace
-        if (relevantChanges.length === 0) {
+        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
             if (dependencyBumps?.length) {
                 applyAdditionalDependencyBumps({
                     markdownLines,
@@ -62,7 +89,7 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
             for (const scope of scopesSortedAlphabetically) {
                 const changes = changesGroupedByScope[scope];
                 for (const change of changes) {
-                    const line = formatChange(change, changelogRenderOptions, repoSlug);
+                    const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoSlug);
                     markdownLines.push(line);
                     if (change.isBreaking) {
                         const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
@@ -79,7 +106,7 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
         relevantChanges = relevantChanges.filter((c) => c.affectedProjects &&
             (c.affectedProjects === '*' || c.affectedProjects.includes(project)));
         // Generating for a named project, but that project has no relevant changes in the current set of commits, exit early
-        if (relevantChanges.length === 0) {
+        if (relevantChanges.length === 0 && breakingChanges.length === 0) {
             if (dependencyBumps?.length) {
                 applyAdditionalDependencyBumps({
                     markdownLines,
@@ -105,7 +132,7 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
             markdownLines.push('', `### ${changeTypes[type].changelog.title}`, '');
             const changesInChronologicalOrder = group.reverse();
             for (const change of changesInChronologicalOrder) {
-                const line = formatChange(change, changelogRenderOptions, repoSlug);
+                const line = formatChange(change, changelogRenderOptions, isVersionPlans, repoSlug);
                 markdownLines.push(line + '\n');
                 if (change.isBreaking) {
                     const breakingChangeExplanation = extractBreakingChangeExplanation(change.body);
@@ -117,7 +144,7 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
         }
     }
     if (breakingChanges.length > 0) {
-        markdownLines.push('', '#### ⚠️  Breaking Changes', '', ...breakingChanges);
+        markdownLines.push('', '### ⚠️  Breaking Changes', '', ...breakingChanges);
     }
     if (dependencyBumps?.length) {
         applyAdditionalDependencyBumps({
@@ -129,7 +156,10 @@ const defaultChangelogRenderer = async ({ projectGraph, changes, releaseVersion,
     }
     if (changelogRenderOptions.authors) {
         const _authors = new Map();
-        for (const change of relevantChanges) {
+        for (const change of [
+            ...relevantChanges,
+            ...additionalChangesForAuthorsSection,
+        ]) {
             if (!change.author) {
                 continue;
             }
@@ -215,7 +245,7 @@ function groupBy(items, key) {
     }
     return groups;
 }
-function formatChange(change, changelogRenderOptions, repoSlug) {
+function formatChange(change, changelogRenderOptions, isVersionPlans, repoSlug) {
     let description = change.description;
     let extraLines = [];
     let extraLinesStr = '';
@@ -228,9 +258,14 @@ function formatChange(change, changelogRenderOptions, repoSlug) {
             .map((l) => `${indentation}${l}`)
             .join('\n');
     }
+    /**
+     * In version plans changelogs:
+     * - don't repeat the breaking change icon
+     * - don't render the scope
+     */
     let changeLine = '- ' +
-        (change.isBreaking ? '⚠️  ' : '') +
-        (change.scope ? `**${change.scope.trim()}:** ` : '') +
+        (!isVersionPlans && change.isBreaking ? '⚠️  ' : '') +
+        (!isVersionPlans && change.scope ? `**${change.scope.trim()}:** ` : '') +
         description;
     if (repoSlug && changelogRenderOptions.commitReferences) {
         changeLine += (0, github_1.formatReferences)(change.githubReferences, repoSlug);

package/schemas/nx-schema.json

@@ -499,6 +499,11 @@
             "type": "object"
           }
         },
+        "parallelism": {
+          "type": "boolean",
+          "default": true,
+          "description": "Whether this target can be run in parallel with other tasks"
+        },
         "inputs": {
           "$ref": "#/definitions/inputs"
         },

package/src/command-line/import/command-object.js

@@ -23,6 +23,10 @@ exports.yargsImportCommand = {
         .option('ref', {
         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',

package/src/command-line/import/import.d.ts

@@ -15,6 +15,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;
 }

package/src/command-line/import/import.js

@@ -2,6 +2,10 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.importHandler = importHandler;
 const path_1 = require("path");
+const minimatch_1 = require("minimatch");
+const node_fs_1 = require("node:fs");
+const chalk = require("chalk");
+const js_yaml_1 = require("@zkochan/js-yaml");
 const git_utils_1 = require("../../utils/git-utils");
 const promises_1 = require("node:fs/promises");
 const tmp_1 = require("tmp");
@@ -18,6 +22,7 @@ const command_line_utils_1 = require("../../utils/command-line-utils");
 const prepare_source_repo_1 = require("./utils/prepare-source-repo");
 const merge_remote_source_1 = require("./utils/merge-remote-source");
 const needs_install_1 = require("./utils/needs-install");
+const file_utils_1 = require("../../project-graph/file-utils");
 const importRemoteName = '__tmp_nx_import__';
 async function importHandler(options) {
     let { sourceRemoteUrl, ref, source, destination } = options;
@@ -54,7 +59,7 @@ async function importHandler(options) {
         // It's a remote url
     }
     const sourceRepoPath = (0, path_1.join)(tempImportDirectory, 'repo');
-    const spinner = createSpinner(`Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath}`).start();
+    const spinner = createSpinner(`Cloning ${sourceRemoteUrl} into a temporary directory: ${sourceRepoPath} (Use --depth to limit commit history and speed up clone times)`).start();
     try {
         await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
     }
@@ -64,6 +69,7 @@ async function importHandler(options) {
     try {
         sourceGitClient = await (0, git_utils_1.cloneFromUpstream)(sourceRemoteUrl, sourceRepoPath, {
             originName: importRemoteName,
+            depth: options.depth,
         });
     }
     catch (e) {
@@ -72,6 +78,8 @@ async function importHandler(options) {
         throw new Error(errorMessage);
     }
     spinner.succeed(`Cloned into ${sourceRepoPath}`);
+    // Detecting the package manager before preparing the source repo for import.
+    const sourcePackageManager = (0, package_manager_1.detectPackageManager)(sourceGitClient.root);
     if (!ref) {
         const branchChoices = await sourceGitClient.listBranches();
         ref = (await (0, enquirer_1.prompt)([
@@ -104,24 +112,34 @@ async function importHandler(options) {
                 name: 'destination',
                 message: 'Where in this workspace should the code be imported into?',
                 required: true,
+                initial: source ? source : undefined,
             },
         ])).destination;
     }
     const absSource = (0, path_1.join)(sourceRepoPath, source);
     const absDestination = (0, path_1.join)(process.cwd(), destination);
+    const destinationGitClient = new git_utils_1.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 (0, promises_1.stat)(absSource);
     }
     catch (e) {
         throw new Error(`The source directory ${source} does not exist in ${sourceRemoteUrl}. Please double check to make sure it exists.`);
     }
-    const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
-    await assertDestinationEmpty(destinationGitClient, absDestination);
-    const tempImportBranch = getTempImportBranch(ref);
     const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
     const originalPackageWorkspaces = await (0, needs_install_1.getPackagesInPackageManagerWorkspace)(packageManager);
     const relativeDestination = (0, path_1.relative)(destinationGitClient.root, absDestination);
-    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl, importRemoteName);
+    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl);
     await createTemporaryRemote(destinationGitClient, (0, path_1.join)(sourceRepoPath, '.git'), importRemoteName);
     await (0, merge_remote_source_1.mergeRemoteSource)(destinationGitClient, sourceRemoteUrl, tempImportBranch, destination, importRemoteName, ref);
     spinner.start('Cleaning up temporary files and remotes');
@@ -132,19 +150,69 @@ async function importHandler(options) {
     const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
     (0, workspace_context_1.resetWorkspaceContext)();
     const { plugins, updatePackageScripts } = await (0, init_v2_1.detectPlugins)(nxJson, options.interactive);
+    if (packageManager !== sourcePackageManager) {
+        output_1.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.`,
+            ],
+        });
+    }
+    // If install fails, we should continue since the errors could be resolved later.
+    let installFailed = false;
     if (plugins.length > 0) {
-        output_1.output.log({ title: 'Installing Plugins' });
-        (0, init_v2_1.installPlugins)(workspace_root_1.workspaceRoot, plugins, pmc, updatePackageScripts);
-        await destinationGitClient.amendCommit();
+        try {
+            output_1.output.log({ title: 'Installing Plugins' });
+            (0, init_v2_1.installPlugins)(workspace_root_1.workspaceRoot, plugins, pmc, updatePackageScripts);
+            await destinationGitClient.amendCommit();
+        }
+        catch (e) {
+            installFailed = true;
+            output_1.output.error({
+                title: `Install failed: ${e.message || 'Unknown error'}`,
+                bodyLines: [e.stack],
+            });
+        }
     }
     else if (await (0, needs_install_1.needsInstall)(packageManager, originalPackageWorkspaces)) {
+        try {
+            output_1.output.log({
+                title: 'Installing dependencies for imported code',
+            });
+            (0, utils_1.runInstall)(workspace_root_1.workspaceRoot, (0, package_manager_1.getPackageManagerCommand)(packageManager));
+            await destinationGitClient.amendCommit();
+        }
+        catch (e) {
+            installFailed = true;
+            output_1.output.error({
+                title: `Install failed: ${e.message || 'Unknown error'}`,
+                bodyLines: [e.stack],
+            });
+        }
+    }
+    console.log(await destinationGitClient.showStat());
+    if (installFailed) {
+        const pmc = (0, package_manager_1.getPackageManagerCommand)(packageManager);
+        output_1.output.warn({
+            title: `The import was successful, but the install failed`,
+            bodyLines: [
+                `You may need to run "${pmc.install}" manually to resolve the issue. The error is logged above.`,
+            ],
+        });
+    }
+    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_1.output.log({
-            title: 'Installing dependencies for imported code',
+            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.`,
+            ],
         });
-        (0, utils_1.runInstall)(workspace_root_1.workspaceRoot, (0, package_manager_1.getPackageManagerCommand)(packageManager));
-        await destinationGitClient.amendCommit();
     }
-    console.log(await destinationGitClient.showStat());
     output_1.output.log({
         title: `Merging these changes into ${(0, command_line_utils_1.getBaseRef)(nxJson)}`,
         bodyLines: [
@@ -171,3 +239,70 @@ async function createTemporaryRemote(destinationGitClient, sourceRemoteUrl, remo
     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, pmc, pkgPath) {
+    if (!(0, package_manager_1.isWorkspacesEnabled)(pm, workspace_root_1.workspaceRoot)) {
+        output_1.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`,
+                    ]
+                    : 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}":`,
+                            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 = null;
+        if (pm === 'npm' || pm === 'yarn' || pm === 'bun') {
+            const packageJson = (0, file_utils_1.readPackageJson)();
+            workspaces = packageJson.workspaces;
+        }
+        else if (pm === 'pnpm') {
+            const yamlPath = (0, path_1.join)(workspace_root_1.workspaceRoot, 'pnpm-workspace.yaml');
+            if ((0, node_fs_1.existsSync)(yamlPath)) {
+                const yamlContent = await node_fs_1.promises.readFile(yamlPath, 'utf-8');
+                const yaml = (0, js_yaml_1.load)(yamlContent);
+                workspaces = yaml.packages;
+            }
+        }
+        if (workspaces) {
+            const isPkgIncluded = workspaces.some((w) => (0, minimatch_1.minimatch)(pkgPath, w));
+            if (!isPkgIncluded) {
+                const pkgsDir = (0, path_1.dirname)(pkgPath);
+                output_1.output.warn({
+                    title: `Project missing in workspaces`,
+                    bodyLines: 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}".`,
+                        ]
+                        : [
+                            `The imported project (${pkgPath}) is missing the "packages" field in pnpm-workspaces.yaml.`,
+                            `Add "${pkgsDir}/*" to packages run "${pmc.install}".`,
+                        ],
+                });
+            }
+        }
+    }
+}

package/src/command-line/import/utils/prepare-source-repo.d.ts

@@ -1,2 +1,2 @@
 import { GitRepository } from '../../../utils/git-utils';
-export declare function prepareSourceRepo(gitClient: GitRepository, ref: string, source: string, relativeDestination: string, tempImportBranch: string, sourceRemoteUrl: string, originName: string): Promise<void>;
+export declare function prepareSourceRepo(gitClient: GitRepository, ref: string, source: string, relativeDestination: string, tempImportBranch: string, sourceRemoteUrl: string): Promise<void>;

package/src/command-line/import/utils/prepare-source-repo.js

@@ -4,99 +4,45 @@ exports.prepareSourceRepo = prepareSourceRepo;
 const createSpinner = require("ora");
 const path_1 = require("path");
 const promises_1 = require("node:fs/promises");
-async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl, originName) {
+async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl) {
     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 = (0, path_1.relative)(gitClient.root, (0, path_1.join)(gitClient.root, source));
-    const destinationInSource = (0, path_1.join)(gitClient.root, relativeDestination);
-    spinner.start(`Moving files and git history to ${destinationInSource}`);
-    if (relativeSourceDir === '') {
-        const files = await gitClient.getGitFiles('.');
-        try {
-            await (0, promises_1.rm)(destinationInSource, {
-                recursive: true,
-            });
-        }
-        catch { }
-        await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-        const gitignores = new Set();
-        for (const file of files) {
-            if ((0, path_1.basename)(file) === '.gitignore') {
-                gitignores.add(file);
-                continue;
-            }
-            spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
-            const newPath = (0, path_1.join)(destinationInSource, file);
-            await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
-            try {
-                await gitClient.move(file, newPath);
-            }
-            catch {
-                await wait(100);
-                await gitClient.move(file, newPath);
-            }
-        }
-        await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-        for (const gitignore of gitignores) {
-            await gitClient.move(gitignore, (0, path_1.join)(destinationInSource, gitignore));
+    if (relativeSourceDir !== '') {
+        if (await gitClient.hasFilterRepoInstalled()) {
+            spinner.start(`Filtering git history to only include files in ${relativeSourceDir}`);
+            await gitClient.filterRepo(relativeSourceDir);
         }
-        await gitClient.amendCommit();
-        for (const gitignore of gitignores) {
-            await (0, promises_1.copyFile)((0, path_1.join)(destinationInSource, gitignore), (0, path_1.join)(gitClient.root, gitignore));
+        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}`);
     }
-    else {
-        let needsSquash = false;
-        const needsMove = destinationInSource !== (0, path_1.join)(gitClient.root, source);
-        if (needsMove) {
-            try {
-                await (0, promises_1.rm)(destinationInSource, {
-                    recursive: true,
-                });
-                await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-                needsSquash = true;
-            }
-            catch { }
-            await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
-        }
-        const files = await gitClient.getGitFiles('.');
-        for (const file of files) {
-            if (file === '.gitignore') {
-                continue;
-            }
-            spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
-            if (!(0, path_1.relative)(source, file).startsWith('..')) {
-                if (needsMove) {
-                    const newPath = (0, path_1.join)(destinationInSource, file);
-                    await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
-                    try {
-                        await gitClient.move(file, newPath);
-                    }
-                    catch {
-                        await wait(100);
-                        await gitClient.move(file, newPath);
-                    }
-                }
-            }
-            else {
-                await (0, promises_1.rm)((0, path_1.join)(gitClient.root, file), {
-                    recursive: true,
-                });
-            }
+    const destinationInSource = (0, path_1.join)(gitClient.root, relativeDestination);
+    spinner.start(`Moving files and git history to ${destinationInSource}`);
+    // The result of filter-branch will contain only the files in the subdirectory at its root.
+    const files = await gitClient.getGitFiles('.');
+    try {
+        await (0, promises_1.rm)(destinationInSource, {
+            recursive: true,
+        });
+    }
+    catch { }
+    await (0, promises_1.mkdir)(destinationInSource, { recursive: true });
+    for (const file of files) {
+        spinner.start(`Moving files and git history to ${destinationInSource}: ${file}`);
+        const newPath = (0, path_1.join)(destinationInSource, file);
+        await (0, promises_1.mkdir)((0, path_1.dirname)(newPath), { recursive: true });
+        try {
+            await gitClient.move(file, newPath);
         }
-        await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
-        if (needsSquash) {
-            await gitClient.squashLastTwoCommits();
+        catch {
+            await wait(100);
+            await gitClient.move(file, newPath);
         }
     }
+    await gitClient.commit(`chore(repo): move ${source} to ${relativeDestination} to prepare to be imported`);
+    await gitClient.amendCommit();
     spinner.succeed(`${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`);
 }
 function wait(ms) {