@nx/gradle 22.7.1 → 22.7.2

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nx/gradle",
-  "version": "22.7.1",
+  "version": "22.7.2",
   "private": false,
   "description": "The Nx Plugin for Gradle allows Gradle tasks to be run through Nx",
   "repository": {
@@ -40,13 +40,13 @@
     "migrations": "./migrations.json"
   },
   "dependencies": {
-    "@nx/devkit": "22.7.1",
+    "@nx/devkit": "22.7.2",
     "toml-eslint-parser": "^0.10.0",
     "tree-kill": "^1.2.2",
     "tslib": "^2.3.0"
   },
   "devDependencies": {
-    "nx": "22.7.1"
+    "nx": "22.7.2"
   },
   "publishConfig": {
     "access": "public"

package/src/executors/gradle/get-exclude-task.d.ts

@@ -1,18 +1,4 @@
-import { ProjectGraphProjectNode, Target } from '@nx/devkit';
-/**
- * Returns Gradle CLI arguments to exclude dependent tasks
- * that are not part of the current execution set.
- *
- * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
- * and only `test` is running, this will return: ['lint']
- *
- * @param tasks - Set of Target to process
- * @param nodes - Project graph nodes
- * @param runningTasks - Set of Target that are currently running (won't be excluded)
- * @param includeDependsOnTasks - Set of Gradle task names that should be included (not excluded)
- *   (typically provider-based dependencies that Gradle must resolve)
- */
-export declare function getExcludeTasks(tasks: Set<Target>, nodes: Record<string, ProjectGraphProjectNode>, runningTasks?: Set<Target>, includeDependsOnTasks?: Set<string>): Set<string>;
-export declare function getGradleTaskName(pt: Target, nodes: Record<string, ProjectGraphProjectNode>): string | null;
-export declare function getAllDependsOn(nodes: Record<string, ProjectGraphProjectNode>, projectName: string, targetName: string): Set<Target>;
+import { ProjectGraphProjectNode, TaskGraph } from '@nx/devkit';
+export declare function getExcludeTasksFromTaskGraph(taskIdsToExcludeDepsOf: Iterable<string>, runningTaskIds: Set<string>, taskGraph: TaskGraph, nodes: Record<string, ProjectGraphProjectNode>, includeDependsOnTasks?: Set<string>): Set<string>;
+export declare function getAllDependsOnFromTaskGraph(startTaskIds: Iterable<string>, taskGraph: TaskGraph): Set<string>;
 //# sourceMappingURL=get-exclude-task.d.ts.map

package/src/executors/gradle/get-exclude-task.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"get-exclude-task.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/get-exclude-task.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,uBAAuB,EACvB,MAAM,EAEP,MAAM,YAAY,CAAC;AA+BpB;;;;;;;;;;;;GAYG;AACH,wBAAgB,eAAe,CAC7B,KAAK,EAAE,GAAG,CAAC,MAAM,CAAC,EAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,YAAY,GAAE,GAAG,CAAC,MAAM,CAAa,EACrC,qBAAqB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC7C,GAAG,CAAC,MAAM,CAAC,CAsBb;AAED,wBAAgB,iBAAiB,CAC/B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,GAC7C,MAAM,GAAG,IAAI,CAEf;AAED,wBAAgB,eAAe,CAC7B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,WAAW,EAAE,MAAM,EACnB,UAAU,EAAE,MAAM,GACjB,GAAG,CAAC,MAAM,CAAC,CAgCb"}
+{"version":3,"file":"get-exclude-task.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/get-exclude-task.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAU,SAAS,EAAE,MAAM,YAAY,CAAC;AAUxE,wBAAgB,4BAA4B,CAC1C,sBAAsB,EAAE,QAAQ,CAAC,MAAM,CAAC,EACxC,cAAc,EAAE,GAAG,CAAC,MAAM,CAAC,EAC3B,SAAS,EAAE,SAAS,EACpB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,qBAAqB,GAAE,GAAG,CAAC,MAAM,CAAa,GAC7C,GAAG,CAAC,MAAM,CAAC,CAsBb;AAED,wBAAgB,4BAA4B,CAC1C,YAAY,EAAE,QAAQ,CAAC,MAAM,CAAC,EAC9B,SAAS,EAAE,SAAS,GACnB,GAAG,CAAC,MAAM,CAAC,CAiCb"}

package/src/executors/gradle/get-exclude-task.js

@@ -1,90 +1,53 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getExcludeTasks = getExcludeTasks;
-exports.getGradleTaskName = getGradleTaskName;
-exports.getAllDependsOn = getAllDependsOn;
-const devkit_1 = require("@nx/devkit");
-/**
- * Resolves a dependsOn entry to a Target.
- * Handles both string format ("target") and object format
- * ({ target: "name", projects?: ["proj1"] }).
- * For same-project object deps (no projects field), uses the owning project name.
- */
-function resolveDepToTarget(dep, owningProject) {
-    if (typeof dep === 'string') {
-        return { project: owningProject, target: dep };
-    }
-    const target = dep?.target;
-    if (!target) {
-        return null;
-    }
-    if (dep.projects) {
-        const projectList = Array.isArray(dep.projects)
-            ? dep.projects
-            : [dep.projects];
-        return {
-            project: projectList[0] !== 'self' ? projectList[0] : owningProject,
-            target,
-        };
-    }
-    return { project: owningProject, target };
+exports.getExcludeTasksFromTaskGraph = getExcludeTasksFromTaskGraph;
+exports.getAllDependsOnFromTaskGraph = getAllDependsOnFromTaskGraph;
+function getGradleTaskName(target, nodes) {
+    return nodes[target.project]?.data?.targets?.[target.target]?.options
+        ?.taskName;
 }
-/**
- * Returns Gradle CLI arguments to exclude dependent tasks
- * that are not part of the current execution set.
- *
- * For example, if a project defines `dependsOn: ['lint']` for the `test` target,
- * and only `test` is running, this will return: ['lint']
- *
- * @param tasks - Set of Target to process
- * @param nodes - Project graph nodes
- * @param runningTasks - Set of Target that are currently running (won't be excluded)
- * @param includeDependsOnTasks - Set of Gradle task names that should be included (not excluded)
- *   (typically provider-based dependencies that Gradle must resolve)
- */
-function getExcludeTasks(tasks, nodes, runningTasks = new Set(), includeDependsOnTasks = new Set()) {
+function getExcludeTasksFromTaskGraph(taskIdsToExcludeDepsOf, runningTaskIds, taskGraph, nodes, includeDependsOnTasks = new Set()) {
     const excludes = new Set();
-    const runningKeys = new Set(Array.from(runningTasks).map(devkit_1.targetToTargetString));
-    for (const task of tasks) {
-        const taskDeps = nodes[task.project]?.data?.targets?.[task.target]?.dependsOn ?? [];
-        for (const dep of taskDeps) {
-            const depPt = resolveDepToTarget(dep, task.project);
-            if (depPt && !runningKeys.has((0, devkit_1.targetToTargetString)(depPt))) {
-                const gradleTaskName = getGradleTaskName(depPt, nodes);
-                if (gradleTaskName && !includeDependsOnTasks.has(gradleTaskName)) {
-                    excludes.add(gradleTaskName);
-                }
-            }
+    const transitiveDepIds = getAllDependsOnFromTaskGraph(taskIdsToExcludeDepsOf, taskGraph);
+    for (const depTaskId of transitiveDepIds) {
+        if (runningTaskIds.has(depTaskId)) {
+            continue;
+        }
+        const task = taskGraph.tasks[depTaskId];
+        if (!task) {
+            continue;
+        }
+        const gradleTaskName = getGradleTaskName(task.target, nodes);
+        if (gradleTaskName && !includeDependsOnTasks.has(gradleTaskName)) {
+            excludes.add(gradleTaskName);
         }
     }
     return excludes;
 }
-function getGradleTaskName(pt, nodes) {
-    return nodes[pt.project]?.data?.targets?.[pt.target]?.options?.taskName;
-}
-function getAllDependsOn(nodes, projectName, targetName) {
-    const allDependsOn = new Set();
+function getAllDependsOnFromTaskGraph(startTaskIds, taskGraph) {
     const result = new Set();
-    const startKey = (0, devkit_1.targetToTargetString)({
-        project: projectName,
-        target: targetName,
-    });
-    const stack = [{ project: projectName, target: targetName }];
+    const seen = new Set();
+    const stack = [];
+    const edges = (id) => [
+        ...(taskGraph.dependencies[id] ?? []),
+        ...(taskGraph.continuousDependencies?.[id] ?? []),
+    ];
+    for (const id of startTaskIds) {
+        seen.add(id);
+        for (const dep of edges(id)) {
+            stack.push(dep);
+        }
+    }
     while (stack.length > 0) {
         const current = stack.pop();
-        const key = (0, devkit_1.targetToTargetString)(current);
-        if (!allDependsOn.has(key)) {
-            allDependsOn.add(key);
-            if (key !== startKey) {
-                result.add(current);
-            }
-            const directDependencies = nodes[current.project]?.data?.targets?.[current.target]?.dependsOn ??
-                [];
-            for (const dep of directDependencies) {
-                const depPt = resolveDepToTarget(dep, current.project);
-                if (depPt && !allDependsOn.has((0, devkit_1.targetToTargetString)(depPt))) {
-                    stack.push(depPt);
-                }
+        if (seen.has(current)) {
+            continue;
+        }
+        seen.add(current);
+        result.add(current);
+        for (const dep of edges(current)) {
+            if (!seen.has(dep)) {
+                stack.push(dep);
             }
         }
     }

package/src/executors/gradle/gradle-batch.impl.d.ts

@@ -1,13 +1,13 @@
 import { ExecutorContext, ProjectGraphProjectNode, TaskGraph } from '@nx/devkit';
 import { RunCommandsOptions } from 'nx/src/executors/run-commands/run-commands.impl';
-import { BatchResults } from 'nx/src/tasks-runner/batch/batch-messages';
+import { TaskResult } from 'nx/src/config/misc-interfaces';
 import { GradleExecutorSchema } from './schema';
 export declare const batchRunnerPath: string;
-export default function gradleBatch(taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): Promise<BatchResults>;
-/**
- * Get the gradlew task ids to run
- */
-export declare function getGradlewTasksToRun(taskIds: string[], taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, nodes: Record<string, ProjectGraphProjectNode>): {
+export default function gradleBatch(taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): AsyncGenerator<{
+    task: string;
+    result: TaskResult;
+}>;
+export declare function getGradlewTasksToRun(taskIds: string[], taskGraph: TaskGraph, inputs: Record<string, GradleExecutorSchema>, nodes: Record<string, ProjectGraphProjectNode>, fullTaskGraph?: TaskGraph): {
     gradlewTasksToRun: Record<string, GradleExecutorSchema>;
     excludeTasks: Set<string>;
     excludeTestTasks: Set<string>;

package/src/executors/gradle/gradle-batch.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gradle-batch.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/gradle-batch.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,uBAAuB,EAEvB,SAAS,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,EAEL,kBAAkB,EACnB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAchD,eAAO,MAAM,eAAe,QAG3B,CAAC;AAEF,wBAA8B,WAAW,CACvC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAkEvB;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC;;;;EAuE/C"}
+{"version":3,"file":"gradle-batch.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/gradle-batch.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,eAAe,EAEf,uBAAuB,EACvB,SAAS,EAEV,MAAM,YAAY,CAAC;AACpB,OAAO,EAAE,kBAAkB,EAAE,MAAM,iDAAiD,CAAC;AACrF,OAAO,EAAE,UAAU,EAAE,MAAM,+BAA+B,CAAC;AAC3D,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAahD,eAAO,MAAM,eAAe,QAG3B,CAAC;AAEF,wBAA+B,WAAW,CACxC,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,eAAe,GACvB,cAAc,CAAC;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,UAAU,CAAA;CAAE,CAAC,CAkEtD;AAED,wBAAgB,oBAAoB,CAClC,OAAO,EAAE,MAAM,EAAE,EACjB,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,oBAAoB,CAAC,EAC5C,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,uBAAuB,CAAC,EAC9C,aAAa,GAAE,SAAqB;;;;EA0DrC"}

package/src/executors/gradle/gradle-batch.impl.js

@@ -7,66 +7,59 @@ const devkit_1 = require("@nx/devkit");
 const exec_gradle_1 = require("../../utils/exec-gradle");
 const path_1 = require("path");
 const child_process_1 = require("child_process");
+const readline_1 = require("readline");
 const get_exclude_task_1 = require("./get-exclude-task");
 exports.batchRunnerPath = (0, path_1.join)(__dirname, '../../../batch-runner/build/libs/gradle-batch-runner-all.jar');
-async function gradleBatch(taskGraph, inputs, overrides, context) {
+async function* gradleBatch(taskGraph, inputs, overrides, context) {
+    const projectName = taskGraph.tasks[taskGraph.roots[0]]?.target?.project;
+    const projectRoot = context.projectGraph.nodes[projectName]?.data?.root ?? '';
+    const customGradleExecutableDirectory = (0, exec_gradle_1.getCustomGradleExecutableDirectoryFromPlugin)(context.nxJsonConfiguration);
+    let gradlewPath = (0, exec_gradle_1.findGradlewFile)((0, path_1.join)(projectRoot, 'project.json'), devkit_1.workspaceRoot, customGradleExecutableDirectory);
+    gradlewPath = (0, path_1.join)(context.root, gradlewPath);
+    const root = (0, path_1.dirname)(gradlewPath);
+    // set args with passed in args and overrides in command line
+    const input = inputs[taskGraph.roots[0]];
+    const args = typeof input.args === 'string'
+        ? input.args.trim().split(' ')
+        : Array.isArray(input.args)
+            ? input.args
+            : [];
+    if (overrides.__overrides_unparsed__.length) {
+        args.push(...overrides.__overrides_unparsed__);
+    }
+    const taskIds = Object.keys(taskGraph.tasks);
+    const { gradlewTasksToRun, excludeTasks, excludeTestTasks } = getGradlewTasksToRun(taskIds, taskGraph, inputs, context.projectGraph.nodes, context.taskGraph ?? taskGraph);
+    const yielded = new Set();
     try {
-        const projectName = taskGraph.tasks[taskGraph.roots[0]]?.target?.project;
-        let projectRoot = context.projectGraph.nodes[projectName]?.data?.root ?? '';
-        const customGradleExecutableDirectory = (0, exec_gradle_1.getCustomGradleExecutableDirectoryFromPlugin)(context.nxJsonConfiguration);
-        let gradlewPath = (0, exec_gradle_1.findGradlewFile)((0, path_1.join)(projectRoot, 'project.json'), devkit_1.workspaceRoot, customGradleExecutableDirectory); // find gradlew near project root
-        gradlewPath = (0, path_1.join)(context.root, gradlewPath);
-        const root = (0, path_1.dirname)(gradlewPath);
-        // set args with passed in args and overrides in command line
-        const input = inputs[taskGraph.roots[0]];
-        let args = typeof input.args === 'string'
-            ? input.args.trim().split(' ')
-            : Array.isArray(input.args)
-                ? input.args
-                : [];
-        if (overrides.__overrides_unparsed__.length) {
-            args.push(...overrides.__overrides_unparsed__);
+        for await (const event of streamTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root)) {
+            yielded.add(event.task);
+            yield event;
         }
-        const taskIds = Object.keys(taskGraph.tasks);
-        const { gradlewTasksToRun, excludeTasks, excludeTestTasks } = getGradlewTasksToRun(taskIds, taskGraph, inputs, context.projectGraph.nodes);
-        const batchResults = await runTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root);
-        taskIds.forEach((taskId) => {
-            if (!batchResults[taskId]) {
-                batchResults[taskId] = {
-                    success: false,
-                    terminalOutput: `Gradlew batch failed`,
-                };
-            }
-        });
-        return batchResults;
     }
     catch (e) {
         devkit_1.output.error({
             title: `Gradlew batch failed`,
             bodyLines: [e.toString()],
         });
-        return taskGraph.roots.reduce((acc, key) => {
-            acc[key] = { success: false, terminalOutput: e.toString() };
-            return acc;
-        }, {});
+        for (const taskId of taskIds) {
+            if (!yielded.has(taskId)) {
+                yielded.add(taskId);
+                yield {
+                    task: taskId,
+                    result: { success: false, terminalOutput: e.toString() },
+                };
+            }
+        }
     }
 }
-/**
- * Get the gradlew task ids to run
- */
-function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes) {
-    const tasksWithExclude = new Set();
-    const testTasksWithExclude = new Set();
-    const tasksWithoutExclude = new Set();
+function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes, fullTaskGraph = taskGraph) {
+    const tasksWithExcludeIds = new Set();
+    const testTasksWithExcludeIds = new Set();
+    const tasksWithoutExcludeIds = new Set();
     const gradlewTasksToRun = {};
     const includeDependsOnTasks = new Set();
     for (const taskId of taskIds) {
-        const task = taskGraph.tasks[taskId];
-        const input = inputs[task.id];
-        const taskTarget = {
-            project: task.target.project,
-            target: task.target.target,
-        };
+        const input = inputs[taskId];
         gradlewTasksToRun[taskId] = input;
         if (input.includeDependsOnTasks) {
             for (const t of input.includeDependsOnTasks) {
@@ -75,44 +68,29 @@ function getGradlewTasksToRun(taskIds, taskGraph, inputs, nodes) {
         }
         if (input.excludeDependsOn) {
             if (input.testClassName) {
-                testTasksWithExclude.add(taskTarget);
+                testTasksWithExcludeIds.add(taskId);
             }
             else {
-                tasksWithExclude.add(taskTarget);
+                tasksWithExcludeIds.add(taskId);
             }
         }
         else {
-            tasksWithoutExclude.add(taskTarget);
+            tasksWithoutExcludeIds.add(taskId);
         }
     }
-    const allRunning = new Set(taskIds.map((id) => ({
-        project: taskGraph.tasks[id].target.project,
-        target: taskGraph.tasks[id].target.target,
-    })));
-    for (const task of tasksWithoutExclude) {
-        const dependencies = (0, get_exclude_task_1.getAllDependsOn)(nodes, task.project, task.target);
-        dependencies.forEach((dep) => allRunning.add(dep));
-    }
-    const excludeTasks = (0, get_exclude_task_1.getExcludeTasks)(tasksWithExclude, nodes, allRunning, includeDependsOnTasks);
-    const allTestsDependsOn = new Set();
-    for (const task of testTasksWithExclude) {
-        const taskDependsOn = (0, get_exclude_task_1.getAllDependsOn)(nodes, task.project, task.target);
-        taskDependsOn.forEach((dep) => allTestsDependsOn.add(dep));
-    }
-    const excludeTestTasks = new Set();
-    for (const task of allTestsDependsOn) {
-        const gradleTaskName = (0, get_exclude_task_1.getGradleTaskName)(task, nodes);
-        if (gradleTaskName) {
-            excludeTestTasks.add(gradleTaskName);
-        }
+    const runningTaskIds = new Set(taskIds);
+    for (const depId of (0, get_exclude_task_1.getAllDependsOnFromTaskGraph)(tasksWithoutExcludeIds, fullTaskGraph)) {
+        runningTaskIds.add(depId);
     }
+    const excludeTasks = (0, get_exclude_task_1.getExcludeTasksFromTaskGraph)(tasksWithExcludeIds, runningTaskIds, fullTaskGraph, nodes, includeDependsOnTasks);
+    const excludeTestTasks = (0, get_exclude_task_1.getExcludeTasksFromTaskGraph)(testTasksWithExcludeIds, new Set(), fullTaskGraph, nodes);
     return {
         gradlewTasksToRun,
         excludeTasks,
         excludeTestTasks,
     };
 }
-async function runTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root) {
+async function* streamTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks, args, root) {
     const gradlewBatchStart = performance.mark(`gradlew-batch:start`);
     const debugOptions = (process.env.NX_GRADLE_BATCH_DEBUG ?? '').trim();
     const spawnArgs = [
@@ -126,30 +104,74 @@ async function runTasksInBatch(gradlewTasksToRun, excludeTasks, excludeTestTasks
         `--excludeTestTasks=${Array.from(excludeTestTasks).join(',')}`,
         ...(process.env.NX_VERBOSE_LOGGING === 'true' ? [] : ['--quiet']),
     ];
-    // Use 'inherit' for stderr so Gradle output (tee'd to System.err
-    // by TeeOutputStream) flows to the terminal in real-time.
-    // stdout is piped to capture the JSON batch results.
-    const batchResults = await new Promise((resolve, reject) => {
-        const cp = (0, child_process_1.spawn)('java', spawnArgs, {
-            cwd: devkit_1.workspaceRoot,
-            windowsHide: true,
-            env: process.env,
-            stdio: ['pipe', 'pipe', 'inherit'],
-        });
-        const chunks = [];
-        cp.stdout.on('data', (chunk) => chunks.push(chunk));
+    // stderr is inherited so Gradle output (tee'd to System.err by TeeOutputStream)
+    // and logger output flow to the terminal in real-time.
+    // stdout is piped so we can read NX_RESULT lines emitted per task.
+    const cp = (0, child_process_1.spawn)('java', spawnArgs, {
+        cwd: devkit_1.workspaceRoot,
+        windowsHide: true,
+        env: process.env,
+        stdio: ['pipe', 'pipe', 'inherit'],
+    });
+    const exit = new Promise((resolve, reject) => {
         cp.on('error', reject);
-        cp.on('close', (code) => {
-            if (code !== 0) {
-                reject(new Error(`Gradle batch runner exited with code ${code}`));
+        cp.on('close', (code) => resolve(code ?? 0));
+    });
+    const rl = (0, readline_1.createInterface)({ input: cp.stdout, crlfDelay: Infinity });
+    // Drain stdout into a queue eagerly. Yielding inside the readline loop creates
+    // back-pressure: if the consumer is slow, `yield` blocks, readline pauses, the
+    // OS pipe between Java and Node fills, and Java's NX_RESULT println blocks on
+    // a full pipe — the JVM hangs even though all task work is done.
+    const queue = [];
+    let notifyAvailable = null;
+    let readerClosed = false;
+    rl.on('line', (line) => {
+        if (!line.startsWith('NX_RESULT:'))
+            return;
+        try {
+            const data = JSON.parse(line.slice('NX_RESULT:'.length));
+            queue.push({
+                task: data.task,
+                result: {
+                    success: data.result.success ?? false,
+                    status: data.result.status,
+                    terminalOutput: data.result.terminalOutput ?? '',
+                    startTime: data.result.startTime,
+                    endTime: data.result.endTime,
+                },
+            });
+        }
+        catch (e) {
+            console.error('[Gradle Batch] Failed to parse result line:', line, e);
+            return;
+        }
+        notifyAvailable?.();
+        notifyAvailable = null;
+    });
+    rl.on('close', () => {
+        readerClosed = true;
+        notifyAvailable?.();
+        notifyAvailable = null;
+    });
+    try {
+        while (!readerClosed || queue.length > 0) {
+            if (queue.length > 0) {
+                yield queue.shift();
             }
             else {
-                resolve(Buffer.concat(chunks).toString());
+                await new Promise((resolve) => {
+                    notifyAvailable = resolve;
+                });
             }
-        });
-    });
+        }
+    }
+    finally {
+        rl.close();
+    }
+    const code = await exit;
     const gradlewBatchEnd = performance.mark(`gradlew-batch:end`);
     performance.measure(`gradlew-batch`, gradlewBatchStart.name, gradlewBatchEnd.name);
-    const gradlewBatchResults = JSON.parse(batchResults);
-    return gradlewBatchResults;
+    if (code !== 0) {
+        throw new Error(`Gradle batch runner exited with code ${code}`);
+    }
 }

package/src/executors/gradle/gradle.impl.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gradle.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/gradle.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAShD,wBAA8B,cAAc,CAC1C,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CA8E/B"}
+{"version":3,"file":"gradle.impl.d.ts","sourceRoot":"","sources":["../../../../../../packages/gradle/src/executors/gradle/gradle.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,YAAY,CAAC;AAC5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,UAAU,CAAC;AAShD,wBAA8B,cAAc,CAC1C,OAAO,EAAE,oBAAoB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC;IAAE,OAAO,EAAE,OAAO,CAAA;CAAE,CAAC,CAkF/B"}

package/src/executors/gradle/gradle.impl.js

@@ -44,9 +44,12 @@ async function gradleExecutor(options, context) {
             }
         }
     });
-    if (options.excludeDependsOn) {
+    if (options.excludeDependsOn && context.taskGraph) {
+        const taskId = context.configurationName
+            ? `${context.projectName}:${context.targetName}:${context.configurationName}`
+            : `${context.projectName}:${context.targetName}`;
         const includeDependsOnTasks = new Set(options.includeDependsOnTasks ?? []);
-        (0, get_exclude_task_1.getExcludeTasks)(new Set([{ project: context.projectName, target: context.targetName }]), context.projectGraph.nodes, new Set(), includeDependsOnTasks).forEach((task) => {
+        (0, get_exclude_task_1.getExcludeTasksFromTaskGraph)([taskId], new Set([taskId]), context.taskGraph, context.projectGraph.nodes, includeDependsOnTasks).forEach((task) => {
             if (task) {
                 args.push('--exclude-task', task);
             }