nx 20.8.4 → 22.7.7

package/dist/src/tasks-runner/life-cycles/dynamic-run-one-terminal-output-life-cycle.js

@@ -0,0 +1,238 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createRunOneDynamicOutputRenderer = createRunOneDynamicOutputRenderer;
+const tslib_1 = require("tslib");
+const cliCursor = tslib_1.__importStar(require("cli-cursor"));
+const cli_spinners_1 = require("cli-spinners");
+const os_1 = require("os");
+const readline = tslib_1.__importStar(require("readline"));
+const output_1 = require("../../utils/output");
+const pretty_time_1 = require("./pretty-time");
+const formatting_utils_1 = require("./formatting-utils");
+const view_logs_utils_1 = require("./view-logs-utils");
+const handle_import_1 = require("../../utils/handle-import");
+const pc = tslib_1.__importStar(require("picocolors"));
+const LEFT_PAD = `   `;
+const SPACER = `  `;
+const EXTENDED_LEFT_PAD = `      `;
+/**
+ * The following function is responsible for creating a life cycle with dynamic
+ * outputs, meaning previous outputs can be rewritten or modified as new outputs
+ * are added. It is therefore intended for use on a user's local machines.
+ *
+ * In CI environments the static equivalent of this life cycle should be used.
+ *
+ * NOTE: output.dim() should be preferred over output.colors.gray() because it
+ * is much more consistently readable across different terminal color themes.
+ */
+async function createRunOneDynamicOutputRenderer({ initiatingProject, tasks, args, overrides, }) {
+    cliCursor.hide();
+    // Show the cursor again after the process exits
+    process.on('exit', () => {
+        cliCursor.show();
+    });
+    let resolveRenderIsDonePromise;
+    const renderIsDone = new Promise((resolve) => (resolveRenderIsDonePromise = resolve)).then(() => {
+        clearRenderInterval();
+        cliCursor.show();
+    });
+    function clearRenderInterval() {
+        if (renderDependentTargetsIntervalId) {
+            clearInterval(renderDependentTargetsIntervalId);
+        }
+    }
+    process.on('exit', () => clearRenderInterval());
+    process.on('SIGINT', () => clearRenderInterval());
+    process.on('SIGTERM', () => clearRenderInterval());
+    process.on('SIGHUP', () => clearRenderInterval());
+    const lifeCycle = {};
+    const start = process.hrtime();
+    const figures = await (0, handle_import_1.handleImport)('figures');
+    let state = 'EXECUTING_DEPENDENT_TARGETS';
+    const tasksToTerminalOutputs = {};
+    const totalTasks = tasks.length;
+    const totalDependentTasks = totalTasks - 1;
+    const totalTasksFromInitiatingProject = tasks.filter((t) => t.target.project === initiatingProject).length;
+    // Tasks from the initiating project are treated differently, they forward their output
+    const totalDependentTasksNotFromInitiatingProject = totalTasks - totalTasksFromInitiatingProject;
+    const targetName = tasks[0].target.target;
+    let dependentTargetsNumLines = 0;
+    let totalCompletedTasks = 0;
+    let totalSuccessfulTasks = 0;
+    let totalFailedTasks = 0;
+    let totalCachedTasks = 0;
+    // Used to control the rendering of the spinner
+    let dependentTargetsCurrentFrame = 0;
+    let renderDependentTargetsIntervalId;
+    const moveCursorToStartOfDependentTargetLines = () => {
+        readline.cursorTo(process.stdout, 0);
+        readline.moveCursor(process.stdout, 0, -dependentTargetsNumLines);
+    };
+    const renderLines = (lines, dividerColor = 'cyan', renderDivider = true) => {
+        let additionalLines = 0;
+        if (renderDivider) {
+            const dividerLines = output_1.output.getVerticalSeparatorLines(dividerColor);
+            for (const line of dividerLines) {
+                output_1.output.overwriteLine(line);
+            }
+            additionalLines += dividerLines.length;
+            lines.push('');
+        }
+        for (const line of lines) {
+            output_1.output.overwriteLine(line);
+        }
+        dependentTargetsNumLines = lines.length + additionalLines;
+        // clear any possible text below the cursor's position
+        readline.clearScreenDown(process.stdout);
+    };
+    const renderDependentTargets = (renderDivider = true) => {
+        if (totalDependentTasksNotFromInitiatingProject <= 0) {
+            return;
+        }
+        const max = cli_spinners_1.dots.frames.length - 1;
+        const curr = dependentTargetsCurrentFrame;
+        dependentTargetsCurrentFrame = curr >= max ? 0 : curr + 1;
+        const linesToRender = [''];
+        const remainingDependentTasksNotFromInitiatingProject = totalDependentTasksNotFromInitiatingProject - totalCompletedTasks;
+        switch (state) {
+            case 'EXECUTING_DEPENDENT_TARGETS':
+                if (totalFailedTasks === 0) {
+                    linesToRender.push(`${LEFT_PAD}${output_1.output.colors.cyan(cli_spinners_1.dots.frames[dependentTargetsCurrentFrame])}${SPACER}${output_1.output.dim(`Nx is waiting on ${remainingDependentTasksNotFromInitiatingProject} dependent project tasks before running tasks from`)} ${initiatingProject}${output_1.output.dim('...')}`);
+                    if (totalSuccessfulTasks > 0) {
+                        linesToRender.push('');
+                    }
+                }
+                break;
+        }
+        if (totalFailedTasks > 0) {
+            linesToRender.push(pc.dim(pc.red(`${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} dependent project tasks failed (see below)`)));
+        }
+        if (totalSuccessfulTasks > 0) {
+            linesToRender.push(output_1.output.dim(`${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} dependent project tasks succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`));
+        }
+        moveCursorToStartOfDependentTargetLines();
+        if (linesToRender.length > 1) {
+            renderLines(linesToRender, 'gray', renderDivider && state !== 'EXECUTING_DEPENDENT_TARGETS');
+        }
+        else {
+            renderLines([]);
+        }
+    };
+    lifeCycle.startCommand = () => {
+        renderDependentTargets();
+    };
+    lifeCycle.startTasks = (tasks) => {
+        for (const task of tasks) {
+            // Move from the dependent project tasks phase to the initiating project's targets
+            if (task.target.project === initiatingProject &&
+                state !== 'EXECUTING_INITIATING_PROJECT_TARGET') {
+                state = 'EXECUTING_INITIATING_PROJECT_TARGET';
+                clearRenderInterval();
+                renderDependentTargets(false);
+                if (totalDependentTasksNotFromInitiatingProject > 0) {
+                    output_1.output.addNewline();
+                    process.stdout.write(`${LEFT_PAD}${output_1.output.dim('Hint: you can run the command with')} --verbose ${output_1.output.dim('to see the full dependent project outputs')}` + os_1.EOL);
+                    output_1.output.addVerticalSeparator('gray');
+                }
+            }
+        }
+        if (!renderDependentTargetsIntervalId &&
+            state === 'EXECUTING_DEPENDENT_TARGETS') {
+            renderDependentTargetsIntervalId = setInterval(renderDependentTargets, 100);
+        }
+    };
+    lifeCycle.printTaskTerminalOutput = (task, cacheStatus, terminalOutput) => {
+        if (task.target.project === initiatingProject) {
+            output_1.output.logCommandOutput(task.id, cacheStatus, terminalOutput);
+        }
+        else {
+            tasksToTerminalOutputs[task.id] = terminalOutput;
+        }
+    };
+    lifeCycle.endTasks = (taskResults) => {
+        for (let t of taskResults) {
+            totalCompletedTasks++;
+            switch (t.status) {
+                case 'remote-cache':
+                case 'local-cache':
+                case 'local-cache-kept-existing':
+                    totalCachedTasks++;
+                    totalSuccessfulTasks++;
+                    break;
+                case 'success':
+                    totalSuccessfulTasks++;
+                    break;
+                case 'failure':
+                    totalFailedTasks++;
+                    /**
+                     * A dependent project has failed so we stop executing and update the relevant
+                     * dependent project task messaging
+                     */
+                    if (t.task.target.project !== initiatingProject) {
+                        clearRenderInterval();
+                        renderDependentTargets(false);
+                        output_1.output.addVerticalSeparator('red');
+                        output_1.output.logCommandOutput(t.task.id, t.status, tasksToTerminalOutputs[t.task.id]);
+                    }
+                    break;
+            }
+            delete tasksToTerminalOutputs[t.task.id];
+        }
+    };
+    lifeCycle.endCommand = () => {
+        clearRenderInterval();
+        const timeTakenText = (0, pretty_time_1.prettyTime)(process.hrtime(start));
+        if (totalSuccessfulTasks === totalTasks) {
+            state = 'COMPLETED_SUCCESSFULLY';
+            const text = `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)([initiatingProject], [targetName], tasks)}`;
+            const taskOverridesLines = [];
+            const filteredOverrides = Object.entries(overrides).filter(
+            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+            ([flag]) => flag !== 'nxReleaseVersionData');
+            if (filteredOverrides.length > 0) {
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.green('With additional flags:'))}`);
+                filteredOverrides
+                    .map(([flag, value]) => pc.dim(pc.green((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            const pinnedFooterLines = [
+                output_1.output.applyNxPrefix('green', output_1.output.colors.green(text) + output_1.output.dim(` (${timeTakenText})`)),
+                ...taskOverridesLines,
+            ];
+            if (totalCachedTasks > 0) {
+                pinnedFooterLines.push(output_1.output.dim(`${os_1.EOL}Nx read the output from the cache instead of running the command for ${totalCachedTasks} out of ${totalTasks} tasks.`));
+            }
+            renderLines(pinnedFooterLines, 'green');
+        }
+        else {
+            state = 'COMPLETED_WITH_ERRORS';
+            let text = `Ran target ${output_1.output.bold(targetName)} for project ${output_1.output.bold(initiatingProject)}`;
+            if (totalDependentTasks > 0) {
+                text += ` and ${output_1.output.bold(totalDependentTasks)} task(s) they depend on`;
+            }
+            const taskOverridesLines = [];
+            const filteredOverrides = Object.entries(overrides).filter(
+            // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+            ([flag]) => flag !== 'nxReleaseVersionData');
+            if (filteredOverrides.length > 0) {
+                taskOverridesLines.push('');
+                taskOverridesLines.push(`${EXTENDED_LEFT_PAD}${pc.dim(pc.red('With additional flags:'))}`);
+                filteredOverrides
+                    .map(([flag, value]) => pc.dim(pc.red((0, formatting_utils_1.formatFlags)(EXTENDED_LEFT_PAD, flag, value))))
+                    .forEach((arg) => taskOverridesLines.push(arg));
+            }
+            const viewLogs = (0, view_logs_utils_1.viewLogsFooterRows)(totalFailedTasks);
+            renderLines([
+                output_1.output.applyNxPrefix('red', output_1.output.colors.red(text) + output_1.output.dim(` (${timeTakenText})`)),
+                ...taskOverridesLines,
+                '',
+                `${LEFT_PAD}${output_1.output.colors.red(figures.cross)}${SPACER}${totalFailedTasks}${`/${totalCompletedTasks}`} failed`,
+                `${LEFT_PAD}${output_1.output.dim(figures.tick)}${SPACER}${totalSuccessfulTasks}${`/${totalCompletedTasks}`} succeeded ${output_1.output.dim(`[${totalCachedTasks} read from cache]`)}`,
+                ...viewLogs,
+            ], 'red');
+        }
+        resolveRenderIsDonePromise();
+    };
+    return { lifeCycle, renderIsDone };
+}

package/dist/src/tasks-runner/life-cycles/static-run-many-terminal-output-life-cycle.js

@@ -0,0 +1,109 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.StaticRunManyTerminalOutputLifeCycle = void 0;
+const output_1 = require("../../utils/output");
+const utils_1 = require("../utils");
+const formatting_utils_1 = require("./formatting-utils");
+/**
+ * The following life cycle's outputs are static, meaning no previous content
+ * is rewritten or modified as new outputs are added. It is therefore intended
+ * for use in CI environments.
+ *
+ * For the common case of a user executing a command on their local machine,
+ * the dynamic equivalent of this life cycle is usually preferable.
+ */
+class StaticRunManyTerminalOutputLifeCycle {
+    constructor(projectNames, tasks, args, taskOverrides) {
+        this.projectNames = projectNames;
+        this.tasks = tasks;
+        this.args = args;
+        this.taskOverrides = taskOverrides;
+        this.failedTasks = [];
+        this.cachedTasks = [];
+        this.allCompletedTasks = new Map();
+    }
+    startCommand() {
+        if (this.tasks.length === 0) {
+            return;
+        }
+        if (this.projectNames.length <= 0) {
+            output_1.output.logSingleLine(`No projects with ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} were run`);
+            return;
+        }
+        const bodyLines = this.projectNames.map((affectedProject) => `${output_1.output.dim('-')} ${affectedProject}`);
+        const filteredOverrides = Object.entries(this.taskOverrides).filter(
+        // Don't print the data passed through from the version subcommand to the publish executor options, it could be quite large and it's an implementation detail.
+        ([flag]) => flag !== 'nxReleaseVersionData');
+        if (filteredOverrides.length > 0) {
+            bodyLines.push('');
+            bodyLines.push(`${output_1.output.dim('With additional flags:')}`);
+            filteredOverrides
+                .map(([flag, value]) => (0, formatting_utils_1.formatFlags)('', flag, value))
+                .forEach((arg) => bodyLines.push(arg));
+        }
+        const title = `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}:`;
+        output_1.output.log({
+            color: 'cyan',
+            title,
+            bodyLines,
+        });
+        output_1.output.addVerticalSeparatorWithoutNewLines('cyan');
+    }
+    endCommand() {
+        output_1.output.addNewline();
+        if (this.tasks.length === 0) {
+            output_1.output.logSingleLine(`No tasks were run`);
+            return;
+        }
+        if (this.failedTasks.length === 0) {
+            output_1.output.addVerticalSeparatorWithoutNewLines('green');
+            const bodyLines = this.cachedTasks.length > 0
+                ? [
+                    output_1.output.dim(`Nx read the output from the cache instead of running the command for ${this.cachedTasks.length} out of ${this.tasks.length} tasks.`),
+                ]
+                : [];
+            output_1.output.success({
+                title: `Successfully ran ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)}`,
+                bodyLines,
+            });
+        }
+        else {
+            output_1.output.addVerticalSeparatorWithoutNewLines('red');
+            const bodyLines = [];
+            const skippedTasks = this.skippedTasks();
+            if (skippedTasks.length > 0) {
+                bodyLines.push(output_1.output.dim('Tasks not run because their dependencies failed or --nx-bail=true:'), '', ...skippedTasks.map((task) => `${output_1.output.dim('-')} ${task.id}`), '');
+            }
+            bodyLines.push(output_1.output.dim('Failed tasks:'), '', ...[...this.failedTasks.values()].map((task) => `${output_1.output.dim('-')} ${task.id}`));
+            output_1.output.error({
+                title: `Running ${(0, formatting_utils_1.formatTargetsAndProjects)(this.projectNames, this.args.targets, this.tasks)} failed`,
+                bodyLines,
+            });
+        }
+    }
+    skippedTasks() {
+        return this.tasks.filter((t) => !this.allCompletedTasks.has(t.id));
+    }
+    endTasks(taskResults) {
+        for (let t of taskResults) {
+            this.allCompletedTasks.set(t.task.id, t.task);
+            if (t.status === 'failure') {
+                this.failedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'local-cache-kept-existing') {
+                this.cachedTasks.push(t.task);
+            }
+            else if (t.status === 'remote-cache') {
+                this.cachedTasks.push(t.task);
+            }
+        }
+    }
+    printTaskTerminalOutput(task, cacheStatus, terminalOutput) {
+        const args = (0, utils_1.getPrintableCommandArgsForTask)(task);
+        output_1.output.logCommandOutput(args.join(' '), cacheStatus, terminalOutput);
+    }
+}
+exports.StaticRunManyTerminalOutputLifeCycle = StaticRunManyTerminalOutputLifeCycle;

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle-old.d.ts

@@ -0,0 +1,11 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+export declare class LegacyTaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private pendingResults;
+    private flakyTasks;
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
+}

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle-old.js

@@ -0,0 +1,91 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.LegacyTaskHistoryLifeCycle = void 0;
+const nx_json_1 = require("../../config/nx-json");
+const legacy_task_history_1 = require("../../utils/legacy-task-history");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const serialize_target_1 = require("../../utils/serialize-target");
+const is_tui_enabled_1 = require("../is-tui-enabled");
+class LegacyTaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.pendingResults = [];
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        for (const taskResult of taskResults) {
+            this.pendingResults.push(taskResult);
+        }
+    }
+    async endCommand() {
+        // Build TaskRun objects now — task.hash is guaranteed to be set by this point
+        const taskRuns = [];
+        const cacheableHashes = new Set();
+        for (const taskResult of this.pendingResults) {
+            if (taskResult.task.cache === true) {
+                cacheableHashes.add(taskResult.task.hash);
+            }
+            taskRuns.push({
+                project: taskResult.task.target.project,
+                target: taskResult.task.target.target,
+                configuration: taskResult.task.target.configuration,
+                hash: taskResult.task.hash,
+                code: taskResult.code.toString(),
+                status: taskResult.status,
+                start: (taskResult.task.startTime ?? this.startTimings[taskResult.task.id]).toString(),
+                end: (taskResult.task.endTime ?? new Date().getTime()).toString(),
+            });
+        }
+        await (0, legacy_task_history_1.writeTaskRunsToHistory)(taskRuns);
+        // Only check for flaky tasks among cacheable tasks
+        const cacheableTaskRuns = taskRuns.filter((t) => cacheableHashes.has(t.hash));
+        const history = await (0, legacy_task_history_1.getHistoryForHashes)(cacheableTaskRuns.map((t) => t.hash));
+        this.flakyTasks = [];
+        // check if any hash has different exit codes => flaky
+        for (let hash in history) {
+            if (history[hash].length > 1 &&
+                history[hash].some((run) => run.code !== history[hash][0].code)) {
+                this.flakyTasks.push((0, serialize_target_1.serializeTarget)(history[hash][0].project, history[hash][0].target, history[hash][0].configuration));
+            }
+        }
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((t) => `  ${t}`);
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
+            output_1.output.warn({
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
+                bodyLines: [
+                    ,
+                    ...flakyRows,
+                    ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
+                        ? []
+                        : [
+                            '',
+                            `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                        ]),
+                ],
+            });
+        }
+    }
+}
+exports.LegacyTaskHistoryLifeCycle = LegacyTaskHistoryLifeCycle;

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle.d.ts

@@ -0,0 +1,16 @@
+import { Task } from '../../config/task-graph';
+import { LifeCycle, TaskResult } from '../life-cycle';
+import { LegacyTaskHistoryLifeCycle } from './task-history-life-cycle-old';
+export declare function getTasksHistoryLifeCycle(): TaskHistoryLifeCycle | LegacyTaskHistoryLifeCycle;
+export declare class TaskHistoryLifeCycle implements LifeCycle {
+    private startTimings;
+    private pendingResults;
+    private taskRuns;
+    private taskHistory;
+    private flakyTasks;
+    constructor();
+    startTasks(tasks: Task[]): void;
+    endTasks(taskResults: TaskResult[]): Promise<void>;
+    endCommand(): Promise<void>;
+    printFlakyTasksMessage(): void;
+}

package/dist/src/tasks-runner/life-cycles/task-history-life-cycle.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskHistoryLifeCycle = void 0;
+exports.getTasksHistoryLifeCycle = getTasksHistoryLifeCycle;
+const nx_json_1 = require("../../config/nx-json");
+const native_1 = require("../../native");
+const nx_cloud_utils_1 = require("../../utils/nx-cloud-utils");
+const output_1 = require("../../utils/output");
+const serialize_target_1 = require("../../utils/serialize-target");
+const task_history_1 = require("../../utils/task-history");
+const is_tui_enabled_1 = require("../is-tui-enabled");
+const task_history_life_cycle_old_1 = require("./task-history-life-cycle-old");
+let tasksHistoryLifeCycle;
+function getTasksHistoryLifeCycle() {
+    if (!tasksHistoryLifeCycle) {
+        tasksHistoryLifeCycle = !native_1.IS_WASM
+            ? new TaskHistoryLifeCycle()
+            : new task_history_life_cycle_old_1.LegacyTaskHistoryLifeCycle();
+    }
+    return tasksHistoryLifeCycle;
+}
+class TaskHistoryLifeCycle {
+    constructor() {
+        this.startTimings = {};
+        this.pendingResults = new Map();
+        this.taskRuns = new Map();
+        this.taskHistory = (0, task_history_1.getTaskHistory)();
+        if (tasksHistoryLifeCycle) {
+            throw new Error('TaskHistoryLifeCycle is a singleton and should not be instantiated multiple times');
+        }
+        tasksHistoryLifeCycle = this;
+    }
+    startTasks(tasks) {
+        for (let task of tasks) {
+            this.startTimings[task.id] = new Date().getTime();
+        }
+    }
+    async endTasks(taskResults) {
+        for (const taskResult of taskResults) {
+            this.pendingResults.set(taskResult.task.id, taskResult);
+        }
+    }
+    async endCommand() {
+        if (!this.taskHistory) {
+            return;
+        }
+        // Build TaskRun objects now — task.hash is guaranteed to be set by this point
+        for (const [, taskResult] of this.pendingResults) {
+            this.taskRuns.set(taskResult.task.hash, {
+                hash: taskResult.task.hash,
+                target: taskResult.task.target,
+                code: taskResult.code,
+                status: taskResult.status,
+                start: taskResult.task.startTime ?? this.startTimings[taskResult.task.id],
+                end: taskResult.task.endTime ?? Date.now(),
+                cacheable: taskResult.task.cache === true,
+            });
+        }
+        const runs = [];
+        // Only check for flaky tasks among cacheable tasks
+        const cacheableHashes = [];
+        const iterator = this.taskRuns.entries();
+        for (const [hash, run] of iterator) {
+            runs.push(run);
+            if (run.cacheable) {
+                cacheableHashes.push(hash);
+            }
+        }
+        await this.taskHistory.recordTaskRuns(runs);
+        this.flakyTasks =
+            cacheableHashes.length > 0
+                ? await this.taskHistory.getFlakyTasks(cacheableHashes)
+                : [];
+        // Do not directly print output when using the TUI
+        if ((0, is_tui_enabled_1.isTuiEnabled)()) {
+            return;
+        }
+        this.printFlakyTasksMessage();
+    }
+    printFlakyTasksMessage() {
+        if (this.flakyTasks?.length > 0) {
+            const MAX_VISIBLE_FLAKY = 5;
+            const visibleFlaky = this.flakyTasks.length > MAX_VISIBLE_FLAKY + 1
+                ? this.flakyTasks.slice(0, MAX_VISIBLE_FLAKY)
+                : this.flakyTasks;
+            const hiddenCount = this.flakyTasks.length - visibleFlaky.length;
+            const flakyRows = visibleFlaky.map((hash) => {
+                const taskRun = this.taskRuns.get(hash);
+                return `  ${(0, serialize_target_1.serializeTarget)(taskRun.target.project, taskRun.target.target, taskRun.target.configuration)}`;
+            });
+            if (hiddenCount > 0) {
+                flakyRows.push(`  ${hiddenCount} more...`);
+            }
+            output_1.output.warn({
+                title: `Nx detected ${this.flakyTasks.length === 1
+                    ? 'a flaky task'
+                    : `${this.flakyTasks.length} flaky tasks`}`,
+                bodyLines: [
+                    ,
+                    ...flakyRows,
+                    ...((0, nx_cloud_utils_1.isNxCloudUsed)((0, nx_json_1.readNxJson)())
+                        ? []
+                        : [
+                            '',
+                            `Flaky tasks can disrupt your CI pipeline. Automatically retry them with Nx Cloud. Learn more at https://nx.dev/ci/features/flaky-tasks`,
+                        ]),
+                ],
+            });
+        }
+    }
+}
+exports.TaskHistoryLifeCycle = TaskHistoryLifeCycle;

package/dist/src/tasks-runner/life-cycles/task-telemetry-life-cycle.d.ts

@@ -0,0 +1,9 @@
+import type { LifeCycle, TaskResult, TaskMetadata } from '../life-cycle';
+export declare class TaskTelemetryLifeCycle implements LifeCycle {
+    private taskCount;
+    private cachedTaskCount;
+    private projects;
+    startCommand(): void;
+    endTasks(taskResults: TaskResult[], metadata: TaskMetadata): void;
+    endCommand(): void;
+}

package/dist/src/tasks-runner/life-cycles/task-telemetry-life-cycle.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskTelemetryLifeCycle = void 0;
+const perf_hooks_1 = require("perf_hooks");
+const analytics_1 = require("../../analytics");
+class TaskTelemetryLifeCycle {
+    constructor() {
+        this.taskCount = 0;
+        this.cachedTaskCount = 0;
+        this.projects = new Set();
+    }
+    startCommand() {
+        perf_hooks_1.performance.mark('task-execution-lifecycle:start');
+    }
+    endTasks(taskResults, metadata) {
+        for (const r of taskResults) {
+            this.taskCount++;
+            this.projects.add(r.task.target.project);
+            if (r.status === 'local-cache' ||
+                r.status === 'local-cache-kept-existing' ||
+                r.status === 'remote-cache') {
+                this.cachedTaskCount++;
+            }
+        }
+    }
+    endCommand() {
+        perf_hooks_1.performance.mark('task-execution-lifecycle:end');
+        perf_hooks_1.performance.measure('task-execution', {
+            start: 'task-execution-lifecycle:start',
+            end: 'task-execution-lifecycle:end',
+            detail: {
+                track: true,
+                ...(analytics_1.customDimensions && {
+                    [analytics_1.customDimensions.taskCount]: this.taskCount,
+                    [analytics_1.customDimensions.cachedTaskCount]: this.cachedTaskCount,
+                    [analytics_1.customDimensions.projectCount]: this.projects.size,
+                }),
+            },
+        });
+    }
+}
+exports.TaskTelemetryLifeCycle = TaskTelemetryLifeCycle;

package/dist/src/tasks-runner/life-cycles/tui-summary-life-cycle.d.ts

@@ -0,0 +1,19 @@
+import { Task, TaskGraph } from '../../config/task-graph';
+import type { LifeCycle } from '../life-cycle';
+export declare function getTuiTerminalSummaryLifeCycle({ projectNames, tasks, taskGraph, args, overrides, initiatingProject, initiatingTasks, resolveRenderIsDonePromise, }: {
+    projectNames: string[];
+    tasks: Task[];
+    taskGraph: TaskGraph;
+    args: {
+        targets?: string[];
+        configuration?: string;
+        parallel?: number;
+    };
+    overrides: Record<string, unknown>;
+    initiatingProject: string;
+    initiatingTasks: Task[];
+    resolveRenderIsDonePromise: (value: void) => void;
+}): {
+    lifeCycle: LifeCycle;
+    printSummary: () => void;
+};