@ohos-ports/nx 17.3.2-beta.0

package/src/utils/nx-cloud-utils.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getNxCloudToken = exports.getNxCloudUrl = exports.isNxCloudUsed = void 0;
+function isNxCloudUsed(nxJson) {
+    return (process.env.NX_CLOUD_ACCESS_TOKEN ||
+        !!nxJson.nxCloudAccessToken ||
+        !!Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud'));
+}
+exports.isNxCloudUsed = isNxCloudUsed;
+function getNxCloudUrl(nxJson) {
+    const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
+    if (!cloudRunner &&
+        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
+        throw new Error('nx-cloud runner not found in nx.json');
+    return cloudRunner?.options?.url ?? nxJson.nxCloudUrl ?? 'https://nx.app';
+}
+exports.getNxCloudUrl = getNxCloudUrl;
+function getNxCloudToken(nxJson) {
+    const cloudRunner = Object.values(nxJson.tasksRunnerOptions ?? {}).find((r) => r.runner == '@nrwl/nx-cloud' || r.runner == 'nx-cloud');
+    if (!cloudRunner &&
+        !(nxJson.nxCloudAccessToken || process.env.NX_CLOUD_ACCESS_TOKEN))
+        throw new Error('nx-cloud runner not found in nx.json');
+    return (process.env.NX_CLOUD_ACCESS_TOKEN ??
+        cloudRunner?.options.accessToken ??
+        nxJson.nxCloudAccessToken);
+}
+exports.getNxCloudToken = getNxCloudToken;

package/src/utils/nx-plugin.d.ts

@@ -0,0 +1,119 @@
+import { FileMap, ProjectGraph, ProjectGraphExternalNode } from '../config/project-graph';
+import { PackageJson } from './package-json';
+import { ProjectConfiguration } from '../config/workspace-json-project-json';
+import { NxJsonConfiguration, PluginConfiguration } from '../config/nx-json';
+import { NxPluginV1 } from './nx-plugin.deprecated';
+import { RawProjectGraphDependency } from '../project-graph/project-graph-builder';
+/**
+ * Context for {@link CreateNodesFunction}
+ */
+export interface CreateNodesContext {
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    readonly workspaceRoot: string;
+}
+/**
+ * A function which parses a configuration file into a set of nodes.
+ * Used for creating nodes for the {@link ProjectGraph}
+ */
+export type CreateNodesFunction<T = unknown> = (projectConfigurationFile: string, options: T | undefined, context: CreateNodesContext) => CreateNodesResult | Promise<CreateNodesResult>;
+export interface CreateNodesResult {
+    /**
+     * A map of project root -> project configuration
+     */
+    projects?: Record<string, Optional<ProjectConfiguration, 'root'>>;
+    /**
+     * A map of external node name -> external node. External nodes do not have a root, so the key is their name.
+     */
+    externalNodes?: Record<string, ProjectGraphExternalNode>;
+}
+/**
+ * A pair of file patterns and {@link CreateNodesFunction}
+ */
+export type CreateNodes<T = unknown> = readonly [
+    projectFilePattern: string,
+    createNodesFunction: CreateNodesFunction<T>
+];
+/**
+ * Context for {@link CreateDependencies}
+ */
+export interface CreateDependenciesContext {
+    /**
+     * The external nodes that have been added to the graph.
+     */
+    readonly externalNodes: ProjectGraph['externalNodes'];
+    /**
+     * The configuration of each project in the workspace.
+     */
+    readonly projects: Record<string, ProjectConfiguration>;
+    /**
+     * The `nx.json` configuration from the workspace
+     */
+    readonly nxJsonConfiguration: NxJsonConfiguration;
+    /**
+     * All files in the workspace
+     */
+    readonly fileMap: FileMap;
+    /**
+     * Files changes since last invocation
+     */
+    readonly filesToProcess: FileMap;
+    readonly workspaceRoot: string;
+}
+/**
+ * A function which parses files in the workspace to create dependencies in the {@link ProjectGraph}
+ * Use {@link validateDependency} to validate dependencies
+ */
+export type CreateDependencies<T = unknown> = (options: T | undefined, context: CreateDependenciesContext) => RawProjectGraphDependency[] | Promise<RawProjectGraphDependency[]>;
+/**
+ * A plugin for Nx which creates nodes and dependencies for the {@link ProjectGraph}
+ */
+export type NxPluginV2<TOptions = unknown> = {
+    name: string;
+    /**
+     * Provides a file pattern and function that retrieves configuration info from
+     * those files. e.g. { '**\/*.csproj': buildProjectsFromCsProjFile }
+     */
+    createNodes?: CreateNodes;
+    /**
+     * Provides a function to analyze files to create dependencies for the {@link ProjectGraph}
+     */
+    createDependencies?: CreateDependencies<TOptions>;
+};
+export * from './nx-plugin.deprecated';
+/**
+ * A plugin for Nx
+ */
+export type NxPlugin = NxPluginV1 | NxPluginV2;
+export type LoadedNxPlugin = {
+    plugin: NxPluginV2 & Pick<NxPluginV1, 'processProjectGraph'>;
+    options?: unknown;
+};
+export declare const nxPluginCache: Map<string, LoadedNxPlugin['plugin']>;
+export declare function getPluginPathAndName(moduleName: string, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): {
+    pluginPath: string;
+    name: any;
+};
+export declare function loadNxPluginAsync(pluginConfiguration: PluginConfiguration, paths: string[], projects: Record<string, ProjectConfiguration>, root: string): Promise<LoadedNxPlugin>;
+export declare function loadNxPlugins(plugins: PluginConfiguration[], paths?: string[], root?: string, projects?: Record<string, ProjectConfiguration>): Promise<LoadedNxPlugin[]>;
+export declare function ensurePluginIsV2(plugin: NxPlugin): NxPluginV2;
+export declare function isNxPluginV2(plugin: NxPlugin): plugin is NxPluginV2;
+export declare function isNxPluginV1(plugin: NxPlugin): plugin is NxPluginV1;
+export declare function readPluginPackageJson(pluginName: string, projects: Record<string, ProjectConfiguration>, paths?: string[]): {
+    path: string;
+    json: PackageJson;
+};
+export declare function resolveLocalNxPlugin(importPath: string, nxJsonConfiguration: NxJsonConfiguration, projects: Record<string, ProjectConfiguration>, root?: string): {
+    path: string;
+    projectConfig: ProjectConfiguration;
+} | null;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+export declare function registerPluginTSTranspiler(): void;
+/**
+ * Unregister the ts-node transpiler if it is registered
+ */
+export declare function unregisterPluginTSTranspiler(): void;
+export declare function getDefaultPlugins(root: string): Promise<LoadedNxPlugin[]>;
+type Optional<T, K extends keyof T> = Omit<T, K> & Partial<Pick<T, K>>;

package/src/utils/nx-plugin.deprecated.d.ts

@@ -0,0 +1,31 @@
+import { ProjectGraphProcessor } from '../config/project-graph';
+import { TargetConfiguration } from '../config/workspace-json-project-json';
+import { LoadedNxPlugin } from './nx-plugin';
+/**
+ * @deprecated Add targets to the projects in a {@link CreateNodes} function instead. This will be removed in Nx 19
+ */
+export type ProjectTargetConfigurator = (file: string) => Record<string, TargetConfiguration>;
+/**
+ * @deprecated Use {@link NxPluginV2} instead. This will be removed in Nx 19
+ */
+export type NxPluginV1 = {
+    name: string;
+    /**
+     * @deprecated Use {@link CreateNodes} and {@link CreateDependencies} instead. This will be removed in Nx 19
+     */
+    processProjectGraph?: ProjectGraphProcessor;
+    /**
+     * @deprecated Add targets to the projects inside of {@link CreateNodes} instead. This will be removed in Nx 19
+     */
+    registerProjectTargets?: ProjectTargetConfigurator;
+    /**
+     * A glob pattern to search for non-standard project files.
+     * @example: ["*.csproj", "pom.xml"]
+     * @deprecated Use {@link CreateNodes} instead. This will be removed in Nx 19
+     */
+    projectFilePatterns?: string[];
+};
+/**
+ * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
+ */
+export declare function getDefaultPluginsSync(root: string): LoadedNxPlugin[];

package/src/utils/nx-plugin.deprecated.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultPluginsSync = void 0;
+const angular_json_1 = require("../adapter/angular-json");
+const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
+const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
+const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
+/**
+ * @todo(@agentender) v19: Remove this fn when we remove readWorkspaceConfig
+ */
+function getDefaultPluginsSync(root) {
+    const plugins = [
+        require('../plugins/js'),
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [require('../adapter/angular-json').NxAngularJsonPlugin]
+            : []),
+        target_defaults_plugin_1.TargetDefaultsPlugin,
+        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
+        project_json_1.ProjectJsonProjectsPlugin,
+    ];
+    return plugins.map((p) => ({
+        plugin: p,
+    }));
+}
+exports.getDefaultPluginsSync = getDefaultPluginsSync;

package/src/utils/nx-plugin.js

@@ -0,0 +1,293 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDefaultPlugins = exports.unregisterPluginTSTranspiler = exports.registerPluginTSTranspiler = exports.resolveLocalNxPlugin = exports.readPluginPackageJson = exports.isNxPluginV1 = exports.isNxPluginV2 = exports.ensurePluginIsV2 = exports.loadNxPlugins = exports.loadNxPluginAsync = exports.getPluginPathAndName = exports.nxPluginCache = void 0;
+const tslib_1 = require("tslib");
+const fs_1 = require("fs");
+const path = require("path");
+const workspaces_1 = require("../config/workspaces");
+const workspace_root_1 = require("./workspace-root");
+const fileutils_1 = require("../utils/fileutils");
+const package_json_1 = require("./package-json");
+const register_1 = require("../plugins/js/utils/register");
+const logger_1 = require("./logger");
+const find_project_for_path_1 = require("../project-graph/utils/find-project-for-path");
+const path_1 = require("./path");
+const path_2 = require("path");
+const installation_directory_1 = require("./installation-directory");
+const typescript_1 = require("../plugins/js/utils/typescript");
+const nx_json_1 = require("../config/nx-json");
+const globs_1 = require("./globs");
+const angular_json_1 = require("../adapter/angular-json");
+const package_json_workspaces_1 = require("../plugins/package-json-workspaces");
+const project_json_1 = require("../plugins/project-json/build-nodes/project-json");
+const package_json_next_to_project_json_1 = require("../plugins/project-json/build-nodes/package-json-next-to-project-json");
+const retrieve_workspace_files_1 = require("../project-graph/utils/retrieve-workspace-files");
+const target_defaults_plugin_1 = require("../plugins/target-defaults/target-defaults-plugin");
+tslib_1.__exportStar(require("./nx-plugin.deprecated"), exports);
+// Short lived cache (cleared between cmd runs)
+// holding resolved nx plugin objects.
+// Allows loadNxPlugins to be called multiple times w/o
+// executing resolution mulitple times.
+exports.nxPluginCache = new Map();
+function getPluginPathAndName(moduleName, paths, projects, root) {
+    let pluginPath;
+    try {
+        pluginPath = require.resolve(moduleName, {
+            paths,
+        });
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const plugin = resolveLocalNxPlugin(moduleName, (0, nx_json_1.readNxJson)(root), projects, root);
+            if (plugin) {
+                const main = readPluginMainFromProjectConfiguration(plugin.projectConfig);
+                pluginPath = main ? path.join(root, main) : plugin.path;
+            }
+            else {
+                logger_1.logger.error(`Plugin listed in \`nx.json\` not found: ${moduleName}`);
+                throw e;
+            }
+        }
+        else {
+            throw e;
+        }
+    }
+    const packageJsonPath = path.join(pluginPath, 'package.json');
+    const extension = path.extname(pluginPath);
+    // Register the ts-transpiler if we are pointing to a
+    // plain ts file that's not part of a plugin project
+    if (extension === '.ts' && !tsNodeAndPathsUnregisterCallback) {
+        registerPluginTSTranspiler();
+    }
+    const { name } = !['.ts', '.js'].some((x) => x === extension) && // Not trying to point to a ts or js file
+        (0, fs_1.existsSync)(packageJsonPath) // plugin has a package.json
+        ? (0, fileutils_1.readJsonFile)(packageJsonPath) // read name from package.json
+        : { name: moduleName };
+    return { pluginPath, name };
+}
+exports.getPluginPathAndName = getPluginPathAndName;
+async function loadNxPluginAsync(pluginConfiguration, paths, projects, root) {
+    const { plugin: moduleName, options } = typeof pluginConfiguration === 'object'
+        ? pluginConfiguration
+        : { plugin: pluginConfiguration, options: undefined };
+    let pluginModule = exports.nxPluginCache.get(moduleName);
+    if (pluginModule) {
+        return { plugin: pluginModule, options };
+    }
+    performance.mark(`Load Nx Plugin: ${moduleName} - start`);
+    let { pluginPath, name } = await getPluginPathAndName(moduleName, paths, projects, root);
+    const plugin = ensurePluginIsV2((await Promise.resolve(`${pluginPath}`).then(s => require(s))));
+    plugin.name ??= name;
+    exports.nxPluginCache.set(moduleName, plugin);
+    performance.mark(`Load Nx Plugin: ${moduleName} - end`);
+    performance.measure(`Load Nx Plugin: ${moduleName}`, `Load Nx Plugin: ${moduleName} - start`, `Load Nx Plugin: ${moduleName} - end`);
+    return { plugin, options };
+}
+exports.loadNxPluginAsync = loadNxPluginAsync;
+async function loadNxPlugins(plugins, paths = (0, installation_directory_1.getNxRequirePaths)(), root = workspace_root_1.workspaceRoot, projects) {
+    const result = [
+        { plugin: package_json_next_to_project_json_1.PackageJsonProjectsNextToProjectJsonPlugin },
+    ];
+    plugins ??= [];
+    // When loading plugins for `createNodes`, we don't know what projects exist yet.
+    // Try resolving plugins
+    for (const plugin of plugins) {
+        try {
+            require.resolve(typeof plugin === 'string' ? plugin : plugin.plugin);
+        }
+        catch {
+            // If a plugin cannot be resolved, we will need projects to resolve it
+            projects ??= await (0, retrieve_workspace_files_1.retrieveProjectConfigurationsWithoutPluginInference)(root);
+            break;
+        }
+    }
+    for (const plugin of plugins) {
+        result.push(await loadNxPluginAsync(plugin, paths, projects, root));
+    }
+    // We push the nx core node plugins onto the end, s.t. it overwrites any other plugins
+    result.push(...(await getDefaultPlugins(root)));
+    return result;
+}
+exports.loadNxPlugins = loadNxPlugins;
+function ensurePluginIsV2(plugin) {
+    if (isNxPluginV2(plugin)) {
+        return plugin;
+    }
+    if (isNxPluginV1(plugin) && plugin.projectFilePatterns) {
+        return {
+            ...plugin,
+            createNodes: [
+                `*/**/${(0, globs_1.combineGlobPatterns)(plugin.projectFilePatterns)}`,
+                (configFilePath) => {
+                    const root = (0, path_2.dirname)(configFilePath);
+                    return {
+                        projects: {
+                            [root]: {
+                                name: (0, workspaces_1.toProjectName)(configFilePath),
+                                root,
+                                targets: plugin.registerProjectTargets?.(configFilePath),
+                            },
+                        },
+                    };
+                },
+            ],
+        };
+    }
+    return plugin;
+}
+exports.ensurePluginIsV2 = ensurePluginIsV2;
+function isNxPluginV2(plugin) {
+    return 'createNodes' in plugin || 'createDependencies' in plugin;
+}
+exports.isNxPluginV2 = isNxPluginV2;
+function isNxPluginV1(plugin) {
+    return 'processProjectGraph' in plugin || 'projectFilePatterns' in plugin;
+}
+exports.isNxPluginV1 = isNxPluginV1;
+function readPluginPackageJson(pluginName, projects, paths = (0, installation_directory_1.getNxRequirePaths)()) {
+    try {
+        const result = (0, package_json_1.readModulePackageJsonWithoutFallbacks)(pluginName, paths);
+        return {
+            json: result.packageJson,
+            path: result.path,
+        };
+    }
+    catch (e) {
+        if (e.code === 'MODULE_NOT_FOUND') {
+            const nxJson = (0, nx_json_1.readNxJson)();
+            const localPluginPath = resolveLocalNxPlugin(pluginName, nxJson, projects);
+            if (localPluginPath) {
+                const localPluginPackageJson = path.join(localPluginPath.path, 'package.json');
+                return {
+                    path: localPluginPackageJson,
+                    json: (0, fileutils_1.readJsonFile)(localPluginPackageJson),
+                };
+            }
+        }
+        throw e;
+    }
+}
+exports.readPluginPackageJson = readPluginPackageJson;
+/**
+ * Builds a plugin package and returns the path to output
+ * @param importPath What is the import path that refers to a potential plugin?
+ * @returns The path to the built plugin, or null if it doesn't exist
+ */
+const localPluginCache = {};
+function resolveLocalNxPlugin(importPath, nxJsonConfiguration, projects, root = workspace_root_1.workspaceRoot) {
+    localPluginCache[importPath] ??= lookupLocalPlugin(importPath, nxJsonConfiguration, projects, root);
+    return localPluginCache[importPath];
+}
+exports.resolveLocalNxPlugin = resolveLocalNxPlugin;
+let tsNodeAndPathsUnregisterCallback = undefined;
+/**
+ * Register swc-node or ts-node if they are not currently registered
+ * with some default settings which work well for Nx plugins.
+ */
+function registerPluginTSTranspiler() {
+    if (!tsNodeAndPathsUnregisterCallback) {
+        // nx-ignore-next-line
+        const ts = require('typescript');
+        // Get the first tsconfig that matches the allowed set
+        const tsConfigName = [
+            (0, path_2.join)(workspace_root_1.workspaceRoot, 'tsconfig.base.json'),
+            (0, path_2.join)(workspace_root_1.workspaceRoot, 'tsconfig.json'),
+        ].find((x) => (0, fs_1.existsSync)(x));
+        const tsConfig = tsConfigName
+            ? (0, typescript_1.readTsConfig)(tsConfigName)
+            : {};
+        const unregisterTsConfigPaths = (0, register_1.registerTsConfigPaths)(tsConfigName);
+        const unregisterTranspiler = (0, register_1.registerTranspiler)({
+            experimentalDecorators: true,
+            emitDecoratorMetadata: true,
+            ...tsConfig.options,
+        });
+        tsNodeAndPathsUnregisterCallback = () => {
+            unregisterTsConfigPaths();
+            unregisterTranspiler();
+        };
+    }
+}
+exports.registerPluginTSTranspiler = registerPluginTSTranspiler;
+/**
+ * Unregister the ts-node transpiler if it is registered
+ */
+function unregisterPluginTSTranspiler() {
+    if (tsNodeAndPathsUnregisterCallback) {
+        tsNodeAndPathsUnregisterCallback();
+        tsNodeAndPathsUnregisterCallback = undefined;
+    }
+}
+exports.unregisterPluginTSTranspiler = unregisterPluginTSTranspiler;
+function lookupLocalPlugin(importPath, nxJsonConfiguration, projects, root = workspace_root_1.workspaceRoot) {
+    const plugin = findNxProjectForImportPath(importPath, projects, root);
+    if (!plugin) {
+        return null;
+    }
+    if (!tsNodeAndPathsUnregisterCallback) {
+        registerPluginTSTranspiler();
+    }
+    const projectConfig = projects[plugin];
+    return { path: path.join(root, projectConfig.root), projectConfig };
+}
+function findNxProjectForImportPath(importPath, projects, root = workspace_root_1.workspaceRoot) {
+    const tsConfigPaths = readTsConfigPaths(root);
+    const possiblePaths = tsConfigPaths[importPath]?.map((p) => (0, path_1.normalizePath)(path.relative(root, path.join(root, p))));
+    if (possiblePaths?.length) {
+        const projectRootMappings = (0, find_project_for_path_1.createProjectRootMappingsFromProjectConfigurations)(projects);
+        for (const tsConfigPath of possiblePaths) {
+            const nxProject = (0, find_project_for_path_1.findProjectForPath)(tsConfigPath, projectRootMappings);
+            if (nxProject) {
+                return nxProject;
+            }
+        }
+        if (process.env.NX_VERBOSE_LOGGING) {
+            console.log('Unable to find local plugin', possiblePaths, projectRootMappings);
+        }
+        throw new Error('Unable to resolve local plugin with import path ' + importPath);
+    }
+}
+let tsconfigPaths;
+function readTsConfigPaths(root = workspace_root_1.workspaceRoot) {
+    if (!tsconfigPaths) {
+        const tsconfigPath = ['tsconfig.base.json', 'tsconfig.json']
+            .map((x) => path.join(root, x))
+            .filter((x) => (0, fs_1.existsSync)(x))[0];
+        if (!tsconfigPath) {
+            throw new Error('unable to find tsconfig.base.json or tsconfig.json');
+        }
+        const { compilerOptions } = (0, fileutils_1.readJsonFile)(tsconfigPath);
+        tsconfigPaths = compilerOptions?.paths;
+    }
+    return tsconfigPaths ?? {};
+}
+function readPluginMainFromProjectConfiguration(plugin) {
+    const { main } = Object.values(plugin.targets).find((x) => [
+        '@nx/js:tsc',
+        '@nrwl/js:tsc',
+        '@nx/js:swc',
+        '@nrwl/js:swc',
+        '@nx/node:package',
+        '@nrwl/node:package',
+    ].includes(x.executor))?.options ||
+        plugin.targets?.build?.options ||
+        {};
+    return main;
+}
+async function getDefaultPlugins(root) {
+    const plugins = [
+        await Promise.resolve().then(() => require('../plugins/js')),
+        target_defaults_plugin_1.TargetDefaultsPlugin,
+        ...((0, angular_json_1.shouldMergeAngularProjects)(root, false)
+            ? [
+                await Promise.resolve().then(() => require('../adapter/angular-json')).then((m) => m.NxAngularJsonPlugin),
+            ]
+            : []),
+        (0, package_json_workspaces_1.getNxPackageJsonWorkspacesPlugin)(root),
+        project_json_1.ProjectJsonProjectsPlugin,
+    ];
+    return plugins.map((p) => ({
+        plugin: p,
+    }));
+}
+exports.getDefaultPlugins = getDefaultPlugins;

package/src/utils/object-sort.d.ts

@@ -0,0 +1 @@
+export declare function sortObjectByKeys(originalObject: object): {};

package/src/utils/object-sort.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortObjectByKeys = void 0;
+function sortObjectByKeys(originalObject) {
+    const keys = Object.keys(originalObject).sort();
+    const sortedObject = {};
+    keys.forEach((key) => (sortedObject[key] = originalObject[key]));
+    return sortedObject;
+}
+exports.sortObjectByKeys = sortObjectByKeys;

package/src/utils/output.d.ts

@@ -0,0 +1,72 @@
+import * as chalk from 'chalk';
+import { TaskStatus } from '../tasks-runner/tasks-runner';
+export interface CLIErrorMessageConfig {
+    title: string;
+    bodyLines?: string[];
+    slug?: string;
+}
+export interface CLIWarnMessageConfig {
+    title: string;
+    bodyLines?: string[];
+    slug?: string;
+}
+export interface CLINoteMessageConfig {
+    title: string;
+    bodyLines?: string[];
+}
+export interface CLISuccessMessageConfig {
+    title: string;
+    bodyLines?: string[];
+}
+declare class CLIOutput {
+    readonly X_PADDING = " ";
+    cliName: string;
+    formatCommand: (taskId: string) => string;
+    /**
+     * Longer dash character which forms more of a continuous line when place side to side
+     * with itself, unlike the standard dash character
+     */
+    private get VERTICAL_SEPARATOR();
+    /**
+     * Expose some color and other utility functions so that other parts of the codebase that need
+     * more fine-grained control of message bodies are still using a centralized
+     * implementation.
+     */
+    colors: {
+        gray: chalk.Chalk;
+        green: chalk.Chalk;
+        red: chalk.Chalk;
+        cyan: chalk.Chalk;
+        white: chalk.Chalk;
+    };
+    bold: chalk.Chalk;
+    underline: chalk.Chalk;
+    dim: chalk.Chalk;
+    private writeToStdOut;
+    overwriteLine(lineText?: string): void;
+    private writeOutputTitle;
+    private writeOptionalOutputBody;
+    applyNxPrefix(color: string, text: string): string;
+    addNewline(): void;
+    addVerticalSeparator(color?: string): void;
+    addVerticalSeparatorWithoutNewLines(color?: string): void;
+    getVerticalSeparatorLines(color?: string): string[];
+    private getVerticalSeparator;
+    error({ title, slug, bodyLines }: CLIErrorMessageConfig): void;
+    warn({ title, slug, bodyLines }: CLIWarnMessageConfig): void;
+    note({ title, bodyLines }: CLINoteMessageConfig): void;
+    success({ title, bodyLines }: CLISuccessMessageConfig): void;
+    logSingleLine(message: string): void;
+    logCommand(message: string, taskStatus?: TaskStatus): void;
+    logCommandOutput(message: string, taskStatus: TaskStatus, output: string): void;
+    private getCommandWithStatus;
+    private getStatusIcon;
+    private normalizeMessage;
+    private addTaskStatus;
+    log({ title, bodyLines, color }: CLIWarnMessageConfig & {
+        color?: string;
+    }): void;
+    drain(): Promise<void>;
+}
+export declare const output: CLIOutput;
+export {};