@depup/nx 22.5.4-depup.0

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

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+export declare const yargsImportCommand: CommandModule;
+//# sourceMappingURL=command-object.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"command-object.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/import/command-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,OAAO,CAAC;AAKtC,eAAO,MAAM,kBAAkB,EAAE,aAgDhC,CAAC"}

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

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsImportCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+const handle_errors_1 = require("../../utils/handle-errors");
+exports.yargsImportCommand = {
+    command: 'import [sourceRepository] [destinationDirectory]',
+    describe: 'Import code and git history from another repository into this repository.',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)((0, shared_options_1.withVerbose)(yargs
+        .positional('sourceRepository', {
+        type: 'string',
+        description: 'The remote URL or local path of the source repository to import.',
+    })
+        .positional('destinationDirectory', {
+        type: 'string',
+        alias: 'destination',
+        description: 'The directory in the current workspace to import into.',
+    })
+        .option('sourceDirectory', {
+        type: 'string',
+        alias: 'source',
+        description: 'The directory in the source repository to import from.',
+    })
+        .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',
+        description: 'Interactive mode.',
+        default: true,
+    })), 'import'),
+    handler: async (args) => {
+        const exitCode = await (0, handle_errors_1.handleErrors)(args.verbose, async () => {
+            return (await Promise.resolve().then(() => require('./import'))).importHandler(args);
+        });
+        process.exit(exitCode);
+    },
+};

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

@@ -0,0 +1,26 @@
+export interface ImportOptions {
+    /**
+     * The remote URL of the repository to import
+     */
+    sourceRepository: string;
+    /**
+     * The branch or reference to import
+     */
+    ref: string;
+    /**
+     * The directory in the source repo to import
+     */
+    source: string;
+    /**
+     * 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;
+}
+export declare function importHandler(options: ImportOptions): Promise<void>;
+//# sourceMappingURL=import.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"import.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/import/import.ts"],"names":[],"mappings":"AAwCA,MAAM,WAAW,aAAa;IAC5B;;OAEG;IACH,gBAAgB,EAAE,MAAM,CAAC;IACzB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAC;IACZ;;OAEG;IACH,MAAM,EAAE,MAAM,CAAC;IACf;;OAEG;IACH,WAAW,EAAE,MAAM,CAAC;IACpB;;OAEG;IACH,KAAK,EAAE,MAAM,CAAC;IAEd,OAAO,EAAE,OAAO,CAAC;IACjB,WAAW,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,aAAa,CAAC,OAAO,EAAE,aAAa,iBAmUzD"}

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

@@ -0,0 +1,375 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.importHandler = importHandler;
+const path_1 = require("path");
+const node_fs_1 = require("node:fs");
+const pc = require("picocolors");
+const git_utils_1 = require("../../utils/git-utils");
+const promises_1 = require("node:fs/promises");
+const tmp_1 = require("tmp");
+const enquirer_1 = require("enquirer");
+const output_1 = require("../../utils/output");
+const createSpinner = require('ora');
+const init_v2_1 = require("../init/init-v2");
+const nx_json_1 = require("../../config/nx-json");
+const fileutils_1 = require("../../utils/fileutils");
+const workspace_root_1 = require("../../utils/workspace-root");
+const package_manager_1 = require("../../utils/package-manager");
+const workspace_context_1 = require("../../utils/workspace-context");
+const utils_1 = require("../init/implementation/utils");
+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 minimatch_1 = require("minimatch");
+const configure_plugins_1 = require("../init/configure-plugins");
+const check_compatible_with_plugins_1 = require("../init/implementation/check-compatible-with-plugins");
+const importRemoteName = '__tmp_nx_import__';
+async function importHandler(options) {
+    process.env.NX_RUNNING_NX_IMPORT = 'true';
+    let { sourceRepository, ref, source, destination, verbose } = options;
+    const destinationGitClient = new git_utils_1.GitRepository(process.cwd());
+    if (await destinationGitClient.hasUncommittedChanges()) {
+        throw new Error(`You have uncommitted changes in the destination repository. Commit or revert the changes and try again.`);
+    }
+    output_1.output.log({
+        title: 'Nx will walk you through the process of importing code from the source repository into this repository:',
+        bodyLines: [
+            `1. Nx will clone the source repository into a temporary directory`,
+            `2. The project code from the sourceDirectory will be moved to the destinationDirectory on a temporary branch in this repository`,
+            `3. The temporary branch will be merged into the current branch in this repository`,
+            `4. Nx will recommend plugins to integrate any new tools used in the imported code`,
+            '',
+            `Git history will be preserved during this process as long as you MERGE these changes. Do NOT squash and do NOT rebase the changes when merging branches.  If you would like to UNDO these changes, run "git reset HEAD~1 --hard"`,
+        ],
+    });
+    const tempImportDirectory = (0, path_1.join)(tmp_1.tmpdir, 'nx-import');
+    if (!sourceRepository) {
+        sourceRepository = (await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                name: 'sourceRepository',
+                message: 'What is the URL of the repository you want to import? (This can be a local git repository or a git remote URL)',
+                required: true,
+            },
+        ])).sourceRepository;
+    }
+    try {
+        const maybeLocalDirectory = await (0, promises_1.stat)(sourceRepository);
+        if (maybeLocalDirectory.isDirectory()) {
+            sourceRepository = (0, path_1.resolve)(sourceRepository);
+        }
+    }
+    catch (e) {
+        // It's a remote url
+    }
+    const sourceTempRepoPath = (0, path_1.join)(tempImportDirectory, 'repo');
+    const spinner = createSpinner(`Cloning ${sourceRepository} into a temporary directory: ${sourceTempRepoPath} (Use --depth to limit commit history and speed up clone times)`).start();
+    try {
+        await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
+    }
+    catch { }
+    await (0, promises_1.mkdir)(tempImportDirectory, { recursive: true });
+    let sourceGitClient;
+    try {
+        sourceGitClient = await (0, git_utils_1.cloneFromUpstream)(sourceRepository, sourceTempRepoPath, {
+            originName: importRemoteName,
+            depth: options.depth,
+        });
+    }
+    catch (e) {
+        spinner.fail(`Failed to clone ${sourceRepository} into ${sourceTempRepoPath}`);
+        let errorMessage = `Failed to clone ${sourceRepository} into ${sourceTempRepoPath}. Please double check the remote and try again.\n${e.message}`;
+        throw new Error(errorMessage);
+    }
+    spinner.succeed(`Cloned into ${sourceTempRepoPath}`);
+    // 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)([
+            {
+                type: 'autocomplete',
+                name: 'ref',
+                message: `Which branch do you want to import?`,
+                choices: branchChoices,
+                /**
+                 * Limit the number of choices so that it fits on screen
+                 */
+                limit: process.stdout.rows - 3,
+                required: true,
+            },
+        ])).ref;
+    }
+    if (!source) {
+        source = (await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                name: 'source',
+                message: `Which directory do you want to import into this workspace? (leave blank to import the entire repository)`,
+            },
+        ])).source;
+    }
+    if (!destination) {
+        destination = (await (0, enquirer_1.prompt)([
+            {
+                type: 'input',
+                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)(sourceTempRepoPath, source);
+    if ((0, path_1.isAbsolute)(destination)) {
+        throw new Error(`The destination directory must be a relative path in this repository.`);
+    }
+    const absDestination = (0, path_1.join)(process.cwd(), destination);
+    await assertDestinationEmpty(destinationGitClient, absDestination);
+    const tempImportBranch = getTempImportBranch(ref);
+    await sourceGitClient.addFetchRemote(importRemoteName, ref);
+    await sourceGitClient.fetch(importRemoteName, ref);
+    spinner.succeed(`Fetched ${ref} from ${sourceRepository}`);
+    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 ${sourceRepository}. Please double check to make sure it exists.`);
+    }
+    const packageManager = (0, package_manager_1.detectPackageManager)(workspace_root_1.workspaceRoot);
+    const sourceIsNxWorkspace = (0, node_fs_1.existsSync)((0, path_1.join)(sourceGitClient.root, 'nx.json'));
+    const relativeDestination = (0, path_1.relative)(destinationGitClient.root, absDestination);
+    await (0, prepare_source_repo_1.prepareSourceRepo)(sourceGitClient, ref, source, relativeDestination, tempImportBranch, sourceRepository);
+    await createTemporaryRemote(destinationGitClient, (0, path_1.join)(sourceTempRepoPath, '.git'), importRemoteName);
+    await (0, merge_remote_source_1.mergeRemoteSource)(destinationGitClient, sourceRepository, tempImportBranch, destination, importRemoteName, ref);
+    spinner.start('Cleaning up temporary files and remotes');
+    await (0, promises_1.rm)(tempImportDirectory, { recursive: true });
+    await destinationGitClient.deleteGitRemote(importRemoteName);
+    spinner.succeed('Cleaned up temporary files and remotes');
+    const pmc = (0, package_manager_1.getPackageManagerCommand)();
+    const nxJson = (0, nx_json_1.readNxJson)(workspace_root_1.workspaceRoot);
+    (0, workspace_context_1.resetWorkspaceContext)();
+    let packageJson;
+    try {
+        packageJson = (0, fileutils_1.readJsonFile)('package.json');
+    }
+    catch {
+        packageJson = null;
+    }
+    const { plugins, updatePackageScripts } = await (0, init_v2_1.detectPlugins)(nxJson, packageJson, options.interactive, true);
+    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.`,
+            ],
+        });
+    }
+    await handleMissingWorkspacesEntry(packageManager, pmc, relativeDestination, destinationGitClient);
+    let installed = await runInstallDestinationRepo(packageManager, destinationGitClient);
+    if (installed) {
+        // Check compatibility with existing plugins for the workspace included new imported projects
+        if (nxJson.plugins?.length > 0) {
+            const incompatiblePlugins = await (0, check_compatible_with_plugins_1.checkCompatibleWithPlugins)();
+            if (Object.keys(incompatiblePlugins).length > 0) {
+                (0, check_compatible_with_plugins_1.updatePluginsInNxJson)(workspace_root_1.workspaceRoot, incompatiblePlugins);
+                await destinationGitClient.amendCommit();
+            }
+        }
+        if (plugins.length > 0) {
+            installed = await runPluginsInstall(plugins, pmc, destinationGitClient);
+            if (installed) {
+                const { succeededPlugins } = await (0, configure_plugins_1.configurePlugins)(plugins, updatePackageScripts, pmc, workspace_root_1.workspaceRoot, verbose);
+                if (succeededPlugins.length > 0) {
+                    await destinationGitClient.amendCommit();
+                }
+            }
+        }
+    }
+    console.log(await destinationGitClient.showStat());
+    if (installed === false) {
+        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.`,
+            ],
+        });
+        if (plugins.length > 0) {
+            output_1.output.error({
+                title: `Failed to install plugins`,
+                bodyLines: [
+                    'The following plugins were not installed:',
+                    ...plugins.map((p) => `- ${pc.bold(p)}`),
+                ],
+            });
+            output_1.output.error({
+                title: `To install the plugins manually`,
+                bodyLines: [
+                    'You may need to run commands to install the plugins:',
+                    ...plugins.map((p) => `- ${pc.bold(pmc.exec + ' nx add ' + p)}`),
+                ],
+            });
+        }
+    }
+    if (source != destination) {
+        output_1.output.warn({
+            title: `Check configuration files`,
+            bodyLines: [
+                `The source directory (${source}) and destination directory (${destination}) are different.`,
+                `You may need to update configuration files to match the directory in this repository.`,
+                sourceIsNxWorkspace
+                    ? `For example, path options in project.json such as "main", "tsConfig", and "outputPath" need to be updated.`
+                    : `For example, relative paths in tsconfig.json and other tooling configuration files may need to be updated.`,
+            ],
+        });
+    }
+    // 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: `Check root dependencies`,
+            bodyLines: [
+                `"dependencies" and "devDependencies" are not imported from the source repository (${sourceRepository}).`,
+                `You may need to add some of those dependencies to this workspace in order to run tasks successfully.`,
+            ],
+        });
+    }
+    output_1.output.log({
+        title: `Merging these changes into ${(0, command_line_utils_1.getBaseRef)(nxJson)}`,
+        bodyLines: [
+            `MERGE these changes when merging these changes.`,
+            `Do NOT squash these commits when merging these changes.`,
+            `If you rebase, make sure to use "--rebase-merges" to preserve merge commits.`,
+            `To UNDO these changes, run "git reset HEAD~1 --hard"`,
+        ],
+    });
+}
+async function assertDestinationEmpty(gitClient, absDestination) {
+    const files = await gitClient.getGitFiles(absDestination);
+    if (files.length > 0) {
+        throw new Error(`Destination directory ${absDestination} is not empty. Please make sure it is empty before importing into it.`);
+    }
+}
+function getTempImportBranch(sourceBranch) {
+    return `__nx_tmp_import__/${sourceBranch}`;
+}
+async function createTemporaryRemote(destinationGitClient, sourceRemoteUrl, remoteName) {
+    try {
+        await destinationGitClient.deleteGitRemote(remoteName);
+    }
+    catch { }
+    await destinationGitClient.addGitRemote(remoteName, sourceRemoteUrl);
+    await destinationGitClient.fetch(remoteName);
+}
+/**
+ * Run install for the imported code and plugins
+ * @returns true if the install failed
+ */
+async function runInstallDestinationRepo(packageManager, destinationGitClient) {
+    let installed = true;
+    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) {
+        installed = false;
+        output_1.output.error({
+            title: `Install failed: ${e.message || 'Unknown error'}`,
+            bodyLines: [e.stack],
+        });
+    }
+    return installed;
+}
+async function runPluginsInstall(plugins, pmc, destinationGitClient) {
+    let installed = true;
+    output_1.output.log({ title: 'Installing Plugins' });
+    try {
+        (0, configure_plugins_1.installPluginPackages)(workspace_root_1.workspaceRoot, pmc, plugins);
+        await destinationGitClient.amendCommit();
+    }
+    catch (e) {
+        installed = false;
+        output_1.output.error({
+            title: `Install failed: ${e.message || 'Unknown error'}`,
+            bodyLines: [
+                'The following plugins were not installed:',
+                ...plugins.map((p) => `- ${pc.bold(p)}`),
+                e.stack,
+            ],
+        });
+        output_1.output.error({
+            title: `To install the plugins manually`,
+            bodyLines: [
+                'You may need to run commands to install the plugins:',
+                ...plugins.map((p) => `- ${pc.bold(pmc.exec + ' nx add ' + p)}`),
+            ],
+        });
+    }
+    return installed;
+}
+/*
+ * If the user imports a project that isn't in the workspaces entry, we should add that path to the workspaces entry.
+ */
+async function handleMissingWorkspacesEntry(pm, pmc, pkgPath, destinationGitClient) {
+    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}":`,
+                            pc.bold(`packages:\n  - '${pkgPath}'`),
+                            `See: https://pnpm.io/workspaces`,
+                        ],
+        });
+    }
+    else {
+        let workspaces = (0, package_manager_1.getPackageWorkspaces)(pm, workspace_root_1.workspaceRoot);
+        const isPkgIncluded = workspaces.some((w) => (0, minimatch_1.minimatch)(pkgPath, w));
+        if (isPkgIncluded) {
+            return;
+        }
+        (0, package_manager_1.addPackagePathToWorkspaces)(pkgPath, pm, workspaces, workspace_root_1.workspaceRoot);
+        await destinationGitClient.amendCommit();
+        output_1.output.success({
+            title: `Project added in workspaces`,
+            bodyLines: pm === 'npm' || pm === 'yarn' || pm === 'bun'
+                ? [
+                    `The imported project (${pc.bold(pkgPath)}) is missing the "workspaces" field in package.json.`,
+                    `Added "${pc.bold(pkgPath)}" to workspaces.`,
+                ]
+                : [
+                    `The imported project (${pc.bold(pkgPath)}) is missing the "packages" field in pnpm-workspaces.yaml.`,
+                    `Added "${pc.bold(pkgPath)}" to packages.`,
+                ],
+        });
+    }
+}

package/src/command-line/import/utils/merge-remote-source.d.ts

@@ -0,0 +1,3 @@
+import { GitRepository } from '../../../utils/git-utils';
+export declare function mergeRemoteSource(destinationGitClient: GitRepository, sourceRemoteUrl: string, tempBranch: string, destination: string, remoteName: string, branchName: string): Promise<void>;
+//# sourceMappingURL=merge-remote-source.d.ts.map

package/src/command-line/import/utils/merge-remote-source.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-remote-source.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/import/utils/merge-remote-source.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAGzD,wBAAsB,iBAAiB,CACrC,oBAAoB,EAAE,aAAa,EACnC,eAAe,EAAE,MAAM,EACvB,UAAU,EAAE,MAAM,EAClB,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,EAClB,UAAU,EAAE,MAAM,iBAsBnB"}

package/src/command-line/import/utils/merge-remote-source.js

@@ -0,0 +1,14 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeRemoteSource = mergeRemoteSource;
+const createSpinner = require('ora');
+async function mergeRemoteSource(destinationGitClient, sourceRemoteUrl, tempBranch, destination, remoteName, branchName) {
+    const spinner = createSpinner();
+    spinner.start(`Merging ${branchName} from ${sourceRemoteUrl} into ${destination}`);
+    spinner.start(`Fetching ${tempBranch} from ${remoteName}`);
+    await destinationGitClient.fetch(remoteName, tempBranch);
+    spinner.succeed(`Fetched ${tempBranch} from ${remoteName}`);
+    spinner.start(`Merging files and git history from ${branchName} from ${sourceRemoteUrl} into ${destination}`);
+    await destinationGitClient.mergeUnrelatedHistories(`${remoteName}/${tempBranch}`, `feat(repo): merge ${branchName} from ${sourceRemoteUrl}`);
+    spinner.succeed(`Merged files and git history from ${branchName} from ${sourceRemoteUrl} into ${destination}`);
+}

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

@@ -0,0 +1,3 @@
+import { GitRepository } from '../../../utils/git-utils';
+export declare function prepareSourceRepo(gitClient: GitRepository, ref: string, source: string, relativeDestination: string, tempImportBranch: string, sourceRemoteUrl: string): Promise<void>;
+//# sourceMappingURL=prepare-source-repo.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"prepare-source-repo.d.ts","sourceRoot":"","sources":["../../../../../../../packages/nx/src/command-line/import/utils/prepare-source-repo.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,aAAa,EAAE,MAAM,0BAA0B,CAAC;AAEzD,wBAAsB,iBAAiB,CACrC,SAAS,EAAE,aAAa,EACxB,GAAG,EAAE,MAAM,EACX,MAAM,EAAE,MAAM,EACd,mBAAmB,EAAE,MAAM,EAC3B,gBAAgB,EAAE,MAAM,EACxB,eAAe,EAAE,MAAM,iBAoCxB"}

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

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.prepareSourceRepo = prepareSourceRepo;
+const createSpinner = require('ora');
+const path_1 = require("path");
+async function prepareSourceRepo(gitClient, ref, source, relativeDestination, tempImportBranch, sourceRemoteUrl) {
+    const spinner = createSpinner().start(`Fetching ${ref} from ${sourceRemoteUrl}`);
+    const relativeSourceDir = (0, path_1.relative)(gitClient.root, (0, path_1.join)(gitClient.root, source));
+    const message = relativeSourceDir.trim()
+        ? `Filtering git history to only include files in ${relativeSourceDir}`
+        : `Filtering git history`;
+    if (await gitClient.hasFilterRepoInstalled()) {
+        spinner.start(message);
+        await gitClient.filterRepo(relativeSourceDir, relativeDestination);
+    }
+    else {
+        spinner.start(`${message} (this might take a few minutes -- install git-filter-repo for faster performance)`);
+        await gitClient.filterBranch(relativeSourceDir, relativeDestination, tempImportBranch);
+    }
+    spinner.succeed(relativeSourceDir.trim()
+        ? `Filtered git history to only include files in ${relativeSourceDir}`
+        : `Filtered git history`);
+    spinner.succeed(`${sourceRemoteUrl} has been prepared to be imported into this workspace on a temporary branch: ${tempImportBranch} in ${gitClient.root}`);
+}
+function wait(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}

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

@@ -0,0 +1,23 @@
+export * from './add/command-object';
+export * from './affected/command-object';
+export * from './daemon/command-object';
+export * from './exec/command-object';
+export * from './format/command-object';
+export * from './generate/command-object';
+export * from './graph/command-object';
+export * from './import/command-object';
+export * from './init/command-object';
+export * from './list/command-object';
+export * from './migrate/command-object';
+export * from './new/command-object';
+export * from './register/command-object';
+export * from './release/command-object';
+export * from './repair/command-object';
+export * from './report/command-object';
+export * from './reset/command-object';
+export * from './run-many/command-object';
+export * from './run/command-object';
+export * from './show/command-object';
+export * from './sync/command-object';
+export * from './watch/command-object';
+//# sourceMappingURL=index.d.ts.map

package/src/command-line/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../packages/nx/src/command-line/index.ts"],"names":[],"mappings":"AACA,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,yBAAyB,CAAC;AACxC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,wBAAwB,CAAC;AACvC,cAAc,yBAAyB,CAAC;AACxC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,0BAA0B,CAAC;AACzC,cAAc,sBAAsB,CAAC;AACrC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,0BAA0B,CAAC;AACzC,cAAc,yBAAyB,CAAC;AACxC,cAAc,yBAAyB,CAAC;AACxC,cAAc,wBAAwB,CAAC;AACvC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,uBAAuB,CAAC;AACtC,cAAc,wBAAwB,CAAC"}

package/src/command-line/index.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+// CLI Commands Export File for Documentation
+tslib_1.__exportStar(require("./add/command-object"), exports);
+tslib_1.__exportStar(require("./affected/command-object"), exports);
+tslib_1.__exportStar(require("./daemon/command-object"), exports);
+tslib_1.__exportStar(require("./exec/command-object"), exports);
+tslib_1.__exportStar(require("./format/command-object"), exports);
+tslib_1.__exportStar(require("./generate/command-object"), exports);
+tslib_1.__exportStar(require("./graph/command-object"), exports);
+tslib_1.__exportStar(require("./import/command-object"), exports);
+tslib_1.__exportStar(require("./init/command-object"), exports);
+tslib_1.__exportStar(require("./list/command-object"), exports);
+tslib_1.__exportStar(require("./migrate/command-object"), exports);
+tslib_1.__exportStar(require("./new/command-object"), exports);
+tslib_1.__exportStar(require("./register/command-object"), exports);
+tslib_1.__exportStar(require("./release/command-object"), exports);
+tslib_1.__exportStar(require("./repair/command-object"), exports);
+tslib_1.__exportStar(require("./report/command-object"), exports);
+tslib_1.__exportStar(require("./reset/command-object"), exports);
+tslib_1.__exportStar(require("./run-many/command-object"), exports);
+tslib_1.__exportStar(require("./run/command-object"), exports);
+tslib_1.__exportStar(require("./show/command-object"), exports);
+tslib_1.__exportStar(require("./sync/command-object"), exports);
+tslib_1.__exportStar(require("./watch/command-object"), exports);

package/src/command-line/init/ai-agent-prompts.d.ts

@@ -0,0 +1,3 @@
+import { Agent } from '../../ai/utils';
+export declare function determineAiAgents(aiAgents?: Agent[], interactive?: boolean): Promise<Agent[]>;
+//# sourceMappingURL=ai-agent-prompts.d.ts.map

package/src/command-line/init/ai-agent-prompts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ai-agent-prompts.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/init/ai-agent-prompts.ts"],"names":[],"mappings":"AAEA,OAAO,EAAE,KAAK,EAAoC,MAAM,gBAAgB,CAAC;AAGzE,wBAAsB,iBAAiB,CACrC,QAAQ,CAAC,EAAE,KAAK,EAAE,EAClB,WAAW,CAAC,EAAE,OAAO,GACpB,OAAO,CAAC,KAAK,EAAE,CAAC,CASlB"}

package/src/command-line/init/ai-agent-prompts.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.determineAiAgents = determineAiAgents;
+const enquirer_1 = require("enquirer");
+const is_ci_1 = require("../../utils/is-ci");
+const utils_1 = require("../../ai/utils");
+const pc = require("picocolors");
+async function determineAiAgents(aiAgents, interactive) {
+    if (interactive === false || (0, is_ci_1.isCI)()) {
+        return aiAgents ?? [];
+    }
+    if (aiAgents) {
+        return aiAgents;
+    }
+    return await aiAgentsPrompt();
+}
+async function aiAgentsPrompt() {
+    const promptConfig = {
+        name: 'agents',
+        message: 'Which AI agents, if any, would you like to set up?',
+        type: 'multiselect',
+        choices: utils_1.supportedAgents.map((a) => ({
+            name: a,
+            message: utils_1.agentDisplayMap[a],
+        })),
+        footer: () => pc.dim('Multiple selections possible. <Space> to select. <Enter> to confirm.'),
+    };
+    return (await (0, enquirer_1.prompt)([promptConfig])).agents;
+}

package/src/command-line/init/command-object.d.ts

@@ -0,0 +1,3 @@
+import { CommandModule } from 'yargs';
+export declare const yargsInitCommand: CommandModule;
+//# sourceMappingURL=command-object.d.ts.map

package/src/command-line/init/command-object.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"command-object.d.ts","sourceRoot":"","sources":["../../../../../../packages/nx/src/command-line/init/command-object.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,aAAa,EAAE,MAAM,OAAO,CAAC;AAG5C,eAAO,MAAM,gBAAgB,EAAE,aAiC9B,CAAC"}