@ohos-ports/nx 19.8.4-beta.0

package/src/command-line/show/project.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProjectHandler = showProjectHandler;
+const output_1 = require("../../utils/output");
+const project_graph_1 = require("../../project-graph/project-graph");
+const graph_1 = require("../graph/graph");
+async function showProjectHandler(args) {
+    const graph = await (0, project_graph_1.createProjectGraphAsync)();
+    const node = graph.nodes[args.projectName];
+    if (!node) {
+        console.log(`Could not find project ${args.projectName}`);
+        process.exit(1);
+    }
+    if (args.json) {
+        console.log(JSON.stringify(node.data));
+    }
+    else if (args.web) {
+        await (0, graph_1.generateGraph)({
+            view: 'project-details',
+            focus: node.name,
+            watch: true,
+            open: args.open ?? true,
+        }, []);
+    }
+    else {
+        const chalk = require('chalk');
+        const logIfExists = (label, key) => {
+            if (node.data[key]) {
+                console.log(`${chalk.bold(label)}: ${node.data[key]}`);
+            }
+        };
+        logIfExists('Name', 'name');
+        logIfExists('Root', 'root');
+        logIfExists('Source Root', 'sourceRoot');
+        logIfExists('Tags', 'tags');
+        logIfExists('Implicit Dependencies', 'implicitDependencies');
+        const targets = Object.entries(node.data.targets ?? {});
+        const maxTargetNameLength = Math.max(...targets.map(([t]) => t.length));
+        const maxExecutorNameLength = Math.max(...targets.map(([, t]) => t?.executor?.length ?? 0));
+        if (targets.length > 0) {
+            console.log(`${chalk.bold('Targets')}: `);
+            for (const [target, targetConfig] of targets) {
+                const executorCommandText = targetConfig.metadata?.scriptContent ??
+                    targetConfig?.options?.command ??
+                    (targetConfig?.options?.commands?.length === 1
+                        ? targetConfig.options.commands[0]
+                        : targetConfig?.executor) ??
+                    '';
+                console.log(`- ${chalk.bold((target + ':').padEnd(maxTargetNameLength + 2))} ${executorCommandText.padEnd(maxExecutorNameLength + 2)} ${(() => {
+                    const configurations = Object.keys(targetConfig.configurations ?? {});
+                    if (configurations.length) {
+                        return chalk.dim(configurations.join(', '));
+                    }
+                    return '';
+                })()}`);
+            }
+        }
+    }
+    await output_1.output.drain();
+}

package/src/command-line/show/projects.d.ts

@@ -0,0 +1,2 @@
+import { ShowProjectsOptions } from './command-object';
+export declare function showProjectsHandler(args: ShowProjectsOptions): Promise<void>;

package/src/command-line/show/projects.js

@@ -0,0 +1,77 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProjectsHandler = showProjectsHandler;
+const output_1 = require("../../utils/output");
+const nx_json_1 = require("../../config/nx-json");
+const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const file_utils_1 = require("../../project-graph/file-utils");
+const operators_1 = require("../../project-graph/operators");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+async function showProjectsHandler(args) {
+    let graph = await (0, project_graph_1.createProjectGraphAsync)();
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+        printWarnings: false,
+    }, nxJson);
+    // Affected touches dependencies so it needs to be processed first.
+    if (args.affected) {
+        const touchedFiles = await getTouchedFiles(nxArgs);
+        graph = await getAffectedGraph(touchedFiles, nxJson, graph);
+    }
+    const filter = (0, operators_1.filterNodes)((node) => {
+        if (args.type && node.type !== args.type) {
+            return false;
+        }
+        return true;
+    });
+    graph = filter(graph);
+    // Apply projects filter and get resultant graph
+    if (args.projects) {
+        graph.nodes = getGraphNodesMatchingPatterns(graph, args.projects);
+    }
+    // Grab only the nodes with the specified target
+    if (args.withTarget) {
+        graph.nodes = Object.entries(graph.nodes).reduce((acc, [name, node]) => {
+            if (args.withTarget.some((target) => node.data.targets?.[target])) {
+                acc[name] = node;
+            }
+            return acc;
+        }, {});
+    }
+    const selectedProjects = new Set(Object.keys(graph.nodes));
+    if (args.exclude) {
+        const excludedProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, graph.nodes);
+        for (const excludedProject of excludedProjects) {
+            selectedProjects.delete(excludedProject);
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify(Array.from(selectedProjects)));
+    }
+    else if (args.sep) {
+        console.log(Array.from(selectedProjects.values()).join(args.sep));
+    }
+    else {
+        for (const project of selectedProjects) {
+            console.log(project);
+        }
+    }
+    await output_1.output.drain();
+}
+function getGraphNodesMatchingPatterns(graph, patterns) {
+    const nodes = {};
+    const matches = (0, find_matching_projects_1.findMatchingProjects)(patterns, graph.nodes);
+    for (const match of matches) {
+        nodes[match] = graph.nodes[match];
+    }
+    return nodes;
+}
+function getAffectedGraph(touchedFiles, nxJson, graph) {
+    return (0, affected_project_graph_1.filterAffected)(graph, touchedFiles, nxJson);
+}
+async function getTouchedFiles(nxArgs) {
+    return (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, await (0, all_file_data_1.allFileData)(), nxArgs);
+}

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

@@ -0,0 +1,6 @@
+import type { CommandModule } from 'yargs';
+export interface SyncArgs {
+    verbose?: boolean;
+}
+export declare const yargsSyncCommand: CommandModule<Record<string, unknown>, SyncArgs>;
+export declare const yargsSyncCheckCommand: CommandModule<Record<string, unknown>, SyncArgs>;

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

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsSyncCheckCommand = exports.yargsSyncCommand = void 0;
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsSyncCommand = {
+    command: 'sync',
+    describe: 'Sync the workspace files by running all the sync generators.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
+    handler: async (args) => {
+        process.exit(await Promise.resolve().then(() => require('./sync')).then((m) => m.syncHandler(args)));
+    },
+};
+exports.yargsSyncCheckCommand = {
+    command: 'sync:check',
+    describe: 'Check that no changes are required after running all sync generators.',
+    builder: (yargs) => (0, shared_options_1.withVerbose)(yargs),
+    handler: async (args) => {
+        process.exit(await Promise.resolve().then(() => require('./sync')).then((m) => m.syncHandler({ ...args, check: true })));
+    },
+};

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

@@ -0,0 +1,6 @@
+import type { SyncArgs } from './command-object';
+interface SyncOptions extends SyncArgs {
+    check?: boolean;
+}
+export declare function syncHandler(options: SyncOptions): Promise<number>;
+export {};

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

@@ -0,0 +1,114 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncHandler = syncHandler;
+const ora = require("ora");
+const nx_json_1 = require("../../config/nx-json");
+const project_graph_1 = require("../../project-graph/project-graph");
+const output_1 = require("../../utils/output");
+const handle_errors_1 = require("../../utils/handle-errors");
+const sync_generators_1 = require("../../utils/sync-generators");
+const chalk = require("chalk");
+function syncHandler(options) {
+    return (0, handle_errors_1.handleErrors)(options.verbose, async () => {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const { globalGenerators, taskGenerators } = await (0, sync_generators_1.collectAllRegisteredSyncGenerators)(projectGraph, nxJson);
+        if (!globalGenerators.length && !taskGenerators.length) {
+            output_1.output.success({
+                title: options.check
+                    ? 'The workspace is up to date'
+                    : 'The workspace is already up to date',
+                bodyLines: ['There are no sync generators to run.'],
+            });
+            return 0;
+        }
+        const syncGenerators = Array.from(new Set([...globalGenerators, ...taskGenerators]));
+        const results = await (0, sync_generators_1.getSyncGeneratorChanges)(syncGenerators);
+        if (!results.length) {
+            output_1.output.success({
+                title: options.check
+                    ? 'The workspace is up to date'
+                    : 'The workspace is already up to date',
+                bodyLines: syncGenerators.map((generator) => `The ${chalk.bold(generator)} sync generator didn't identify any files in the workspace that are out of sync.`),
+            });
+            return 0;
+        }
+        const { failedGeneratorsCount, areAllResultsFailures, anySyncGeneratorsFailed, } = (0, sync_generators_1.processSyncGeneratorResultErrors)(results);
+        const failedSyncGeneratorsFixMessageLines = (0, sync_generators_1.getFailedSyncGeneratorsFixMessageLines)(results, options.verbose, new Set(globalGenerators));
+        if (areAllResultsFailures) {
+            output_1.output.error({
+                title: `The workspace is probably out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            return 1;
+        }
+        const resultBodyLines = (0, sync_generators_1.getSyncGeneratorSuccessResultsMessageLines)(results);
+        if (options.check) {
+            output_1.output.error({
+                title: 'The workspace is out of sync',
+                bodyLines: resultBodyLines,
+            });
+            if (anySyncGeneratorsFailed) {
+                output_1.output.error({
+                    title: failedGeneratorsCount === 1
+                        ? 'A sync generator failed to run'
+                        : 'Some sync generators failed to run',
+                    bodyLines: failedSyncGeneratorsFixMessageLines,
+                });
+            }
+            return 1;
+        }
+        output_1.output.warn({
+            title: 'The workspace is out of sync',
+            bodyLines: resultBodyLines,
+        });
+        const spinner = ora('Syncing the workspace...');
+        spinner.start();
+        try {
+            const flushResult = await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+            if ('generatorFailures' in flushResult) {
+                spinner.fail();
+                output_1.output.error({
+                    title: 'Failed to sync the workspace',
+                    bodyLines: (0, sync_generators_1.getFlushFailureMessageLines)(flushResult, options.verbose, new Set(globalGenerators)),
+                });
+                return 1;
+            }
+        }
+        catch (e) {
+            spinner.fail();
+            output_1.output.error({
+                title: 'Failed to sync the workspace',
+                bodyLines: [
+                    'Syncing the workspace failed with the following error:',
+                    '',
+                    e.message,
+                    ...(options.verbose && !!e.stack ? [`\n${e.stack}`] : []),
+                    '',
+                    'Please rerun with `--verbose` and report the error at: https://github.com/nrwl/nx/issues/new/choose',
+                ],
+            });
+            return 1;
+        }
+        const successTitle = anySyncGeneratorsFailed
+            ? // the identified changes were synced successfully, but the workspace
+                // is still not up to date, which we'll mention next
+                'The identified changes were synced successfully!'
+            : // the workspace is fully up to date
+                'The workspace was synced successfully!';
+        const successSubtitle = 'Please make sure to commit the changes to your repository.';
+        spinner.succeed(`${successTitle}\n\n${successSubtitle}`);
+        if (anySyncGeneratorsFailed) {
+            output_1.output.error({
+                title: `The workspace is probably still out of sync because ${failedGeneratorsCount === 1
+                    ? 'a sync generator'
+                    : 'some sync generators'} failed to run`,
+                bodyLines: failedSyncGeneratorsFixMessageLines,
+            });
+            return 1;
+        }
+        return 0;
+    });
+}

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

@@ -0,0 +1,2 @@
+import { CommandModule } from 'yargs';
+export declare const yargsWatchCommand: CommandModule;

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

@@ -0,0 +1,64 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsWatchCommand = void 0;
+const documentation_1 = require("../yargs-utils/documentation");
+const shared_options_1 = require("../yargs-utils/shared-options");
+exports.yargsWatchCommand = {
+    command: 'watch',
+    describe: 'Watch for changes within projects, and execute commands.',
+    builder: (yargs) => (0, documentation_1.linkToNxDevAndExamples)(withWatchOptions(yargs), 'watch'),
+    handler: async (args) => {
+        await Promise.resolve().then(() => require('./watch')).then((m) => m.watch(args));
+    },
+};
+function withWatchOptions(yargs) {
+    return (0, shared_options_1.withVerbose)(yargs)
+        .parserConfiguration({
+        'strip-dashed': true,
+        'populate--': true,
+    })
+        .option('projects', {
+        type: 'string',
+        alias: 'p',
+        coerce: shared_options_1.parseCSV,
+        description: 'Projects to watch (comma/space delimited).',
+    })
+        .option('all', {
+        type: 'boolean',
+        description: 'Watch all projects.',
+    })
+        .option('includeDependentProjects', {
+        type: 'boolean',
+        description: 'When watching selected projects, include dependent projects as well.',
+        alias: 'd',
+    })
+        .option('includeGlobalWorkspaceFiles', {
+        type: 'boolean',
+        description: 'Include global workspace files that are not part of a project. For example, the root eslint, or tsconfig file.',
+        alias: 'g',
+        hidden: true,
+    })
+        .option('command', { type: 'string', hidden: true })
+        .option('verbose', {
+        type: 'boolean',
+        description: 'Run watch mode in verbose mode, where commands are logged before execution.',
+    })
+        .conflicts({
+        all: 'projects',
+    })
+        .check((args) => {
+        if (!args.all && !args.projects) {
+            throw Error('Please specify either --all or --projects');
+        }
+        return true;
+    })
+        .middleware((args) => {
+        const { '--': doubledash } = args;
+        if (doubledash && Array.isArray(doubledash)) {
+            args.command = doubledash.join(' ');
+        }
+        else {
+            throw Error('No command specified for watch mode.');
+        }
+    }, true);
+}

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

@@ -0,0 +1,23 @@
+import { ChangedFile } from '../../daemon/client/client';
+export interface WatchArguments {
+    projects?: string[];
+    all?: boolean;
+    includeDependentProjects?: boolean;
+    includeGlobalWorkspaceFiles?: boolean;
+    verbose?: boolean;
+    command?: string;
+    projectNameEnvName?: string;
+    fileChangesEnvName?: string;
+}
+export declare class BatchFunctionRunner {
+    private callback;
+    private running;
+    private pendingProjects;
+    private pendingFiles;
+    protected get _verbose(): boolean;
+    private get hasPending();
+    constructor(callback: (projects: Set<string>, files: Set<string>) => Promise<unknown>);
+    enqueue(projectNames: string[], fileChanges: ChangedFile[]): Promise<void>;
+    private process;
+}
+export declare function watch(args: WatchArguments): Promise<void>;

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

@@ -0,0 +1,173 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BatchFunctionRunner = void 0;
+exports.watch = watch;
+const child_process_1 = require("child_process");
+const client_1 = require("../../daemon/client/client");
+const output_1 = require("../../utils/output");
+const DEFAULT_PROJECT_NAME_ENV = 'NX_PROJECT_NAME';
+const DEFAULT_FILE_CHANGES_ENV = 'NX_FILE_CHANGES';
+class BatchFunctionRunner {
+    get _verbose() {
+        return process.env.NX_VERBOSE_LOGGING === 'true';
+    }
+    get hasPending() {
+        return this.pendingProjects.size > 0 || this.pendingFiles.size > 0;
+    }
+    constructor(callback) {
+        this.callback = callback;
+        this.running = false;
+        this.pendingProjects = new Set();
+        this.pendingFiles = new Set();
+    }
+    enqueue(projectNames, fileChanges) {
+        projectNames.forEach((projectName) => {
+            this.pendingProjects.add(projectName);
+        });
+        fileChanges.forEach((fileChange) => {
+            this.pendingFiles.add(fileChange.path);
+        });
+        return this.process();
+    }
+    async process() {
+        if (!this.running && this.hasPending) {
+            this.running = true;
+            // Clone the pending projects and files before clearing
+            const projects = new Set(this.pendingProjects);
+            const files = new Set(this.pendingFiles);
+            // Clear the pending projects and files
+            this.pendingProjects.clear();
+            this.pendingFiles.clear();
+            return this.callback(projects, files).then(() => {
+                this.running = false;
+                this.process();
+            });
+        }
+        else {
+            this._verbose &&
+                this.running &&
+                output_1.output.logSingleLine('waiting for function to finish executing');
+            this._verbose &&
+                !this.hasPending &&
+                output_1.output.logSingleLine('no more function to process');
+        }
+    }
+}
+exports.BatchFunctionRunner = BatchFunctionRunner;
+class BatchCommandRunner extends BatchFunctionRunner {
+    constructor(command, projectNameEnv = DEFAULT_PROJECT_NAME_ENV, fileChangesEnv = DEFAULT_FILE_CHANGES_ENV) {
+        super((projects, files) => {
+            // process all pending commands together
+            const envs = this.createCommandEnvironments(projects, files);
+            return this.run(envs);
+        });
+        this.command = command;
+        this.projectNameEnv = projectNameEnv;
+        this.fileChangesEnv = fileChangesEnv;
+    }
+    createCommandEnvironments(projects, files) {
+        const commandsToRun = [];
+        if (projects.size > 0) {
+            projects.forEach((projectName) => {
+                commandsToRun.push({
+                    [this.projectNameEnv]: projectName,
+                    [this.fileChangesEnv]: Array.from(files).join(' '),
+                });
+            });
+        }
+        else {
+            commandsToRun.push({
+                [this.projectNameEnv]: '',
+                [this.fileChangesEnv]: Array.from(files).join(' '),
+            });
+        }
+        return commandsToRun;
+    }
+    async run(envs) {
+        this._verbose &&
+            output_1.output.logSingleLine('about to run commands with these environments: ' + JSON.stringify(envs));
+        return Promise.all(envs.map((env) => {
+            return new Promise((resolve, reject) => {
+                const commandExec = (0, child_process_1.spawn)(this.command, {
+                    stdio: 'inherit',
+                    shell: true,
+                    cwd: process.cwd(),
+                    env: {
+                        ...process.env,
+                        [this.projectNameEnv]: env[this.projectNameEnv],
+                        [this.fileChangesEnv]: env[this.fileChangesEnv],
+                    },
+                    windowsHide: true,
+                });
+                commandExec.on('close', () => {
+                    resolve();
+                });
+                commandExec.on('exit', () => {
+                    resolve();
+                });
+            });
+        })).then((r) => {
+            this._verbose &&
+                output_1.output.logSingleLine('running complete, processing the next batch');
+            return r;
+        });
+    }
+}
+async function watch(args) {
+    const projectReplacementRegex = new RegExp(args.projectNameEnvName ?? DEFAULT_PROJECT_NAME_ENV, 'g');
+    if (!client_1.daemonClient.enabled()) {
+        output_1.output.error({
+            title: 'Daemon is not running. The watch command is not supported without the Nx Daemon.',
+        });
+        process.exit(1);
+    }
+    if (args.includeGlobalWorkspaceFiles &&
+        args.command.match(projectReplacementRegex)) {
+        output_1.output.error({
+            title: 'Invalid command',
+            bodyLines: [
+                'The command you provided has a replacement for projects ($NX_PROJECT_NAME), but you are also including global workspace files.',
+                'You cannot use a replacement for projects when including global workspace files because there will be scenarios where there are file changes not associated with a project.',
+            ],
+        });
+        process.exit(1);
+    }
+    args.verbose &&
+        output_1.output.logSingleLine('running with args: ' + JSON.stringify(args));
+    args.verbose && output_1.output.logSingleLine('starting watch process');
+    const whatToWatch = args.all ? 'all' : args.projects;
+    const batchQueue = new BatchCommandRunner(args.command ?? '', args.projectNameEnvName, args.fileChangesEnvName);
+    await client_1.daemonClient.registerFileWatcher({
+        watchProjects: whatToWatch,
+        includeDependentProjects: args.includeDependentProjects,
+        includeGlobalWorkspaceFiles: args.includeGlobalWorkspaceFiles,
+    }, async (err, data) => {
+        if (err === 'closed') {
+            output_1.output.error({
+                title: 'Watch connection closed',
+                bodyLines: [
+                    'The daemon has closed the connection to this watch process.',
+                    'Please restart your watch command.',
+                ],
+            });
+            process.exit(1);
+        }
+        else if (err !== null) {
+            output_1.output.error({
+                title: 'Watch error',
+                bodyLines: [
+                    'An error occurred during the watch process:',
+                    err.message,
+                ],
+            });
+        }
+        // Only pass the projects to the queue if the command has a replacement for projects
+        if (args.command.match(projectReplacementRegex)) {
+            batchQueue.enqueue(data.changedProjects, data.changedFiles);
+        }
+        else {
+            batchQueue.enqueue([], data.changedFiles);
+        }
+    });
+    args.verbose && output_1.output.logSingleLine('watch process waiting...');
+}

package/src/command-line/yargs-utils/documentation.d.ts

@@ -0,0 +1,2 @@
+import yargs = require('yargs');
+export declare function linkToNxDevAndExamples<T>(yargs: yargs.Argv<T>, command: string): yargs.Argv<T>;

package/src/command-line/yargs-utils/documentation.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkToNxDevAndExamples = linkToNxDevAndExamples;
+const chalk = require("chalk");
+const examples_1 = require("../examples");
+function linkToNxDevAndExamples(yargs, command) {
+    (examples_1.examples[command] || []).forEach((t) => {
+        yargs = yargs.example(t.command, t.description);
+    });
+    return yargs.epilog(chalk.bold(`Find more information and examples at https://nx.dev/nx/${command.replace(':', '-')}`));
+}

package/src/command-line/yargs-utils/shared-options.d.ts

@@ -0,0 +1,75 @@
+import { Argv, ParserConfigurationOptions } from 'yargs';
+interface ExcludeOptions {
+    exclude: string[];
+}
+export declare const defaultYargsParserConfiguration: Partial<ParserConfigurationOptions>;
+export declare function withExcludeOption<T>(yargs: Argv<T>): Argv<T & ExcludeOptions>;
+export interface RunOptions {
+    exclude: string;
+    parallel: string;
+    maxParallel: number;
+    runner: string;
+    prod: boolean;
+    graph: string;
+    verbose: boolean;
+    nxBail: boolean;
+    nxIgnoreCycles: boolean;
+    skipNxCache: boolean;
+    cloud: boolean;
+    dte: boolean;
+    batch: boolean;
+    useAgents: boolean;
+    excludeTaskDependencies: boolean;
+    skipSync: boolean;
+}
+export declare function withRunOptions<T>(yargs: Argv<T>): Argv<T & RunOptions>;
+export declare function withTargetAndConfigurationOption(yargs: Argv, demandOption?: boolean): Argv<{
+    configuration: string;
+} & {
+    targets: string;
+}>;
+export declare function withConfiguration(yargs: Argv): Argv<{
+    configuration: string;
+}>;
+export declare function withVerbose<T>(yargs: Argv<T>): Argv<T & {
+    verbose: boolean;
+}>;
+export declare function withBatch(yargs: Argv): any;
+export declare function withAffectedOptions(yargs: Argv): Argv<ExcludeOptions & {
+    files: string;
+} & {
+    uncommitted: boolean;
+} & {
+    untracked: boolean;
+} & {
+    base: string;
+} & {
+    head: string;
+}>;
+export interface RunManyOptions extends RunOptions {
+    projects: string[];
+    /**
+     * @deprecated This is deprecated
+     */
+    all: boolean;
+}
+export declare function withRunManyOptions<T>(yargs: Argv<T>): Argv<T & RunManyOptions>;
+export declare function withOverrides<T extends {
+    _: Array<string | number>;
+}>(args: T, commandLevel?: number): T & {
+    __overrides_unparsed__: string[];
+};
+declare const allOutputStyles: readonly ["dynamic", "static", "stream", "stream-without-prefixes", "compact"];
+export type OutputStyle = (typeof allOutputStyles)[number];
+export declare function withOutputStyleOption(yargs: Argv, choices?: ReadonlyArray<OutputStyle>): Argv<{
+    "output-style": string;
+}>;
+export declare function withRunOneOptions(yargs: Argv): Argv<{
+    "output-style": string;
+} & RunOptions & {
+    project: string;
+} & {
+    help: boolean;
+}>;
+export declare function parseCSV(args: string[] | string): string[];
+export {};