@nx/maven 0.0.0-pr-33228-85dcafe → 0.0.0-pr-33228-82dc549

package/dist/executors/maven/batch-runner.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Batch runner for Maven - handles multi-task Maven execution
+ * This is a simplified implementation that can later be migrated to Kotlin/Java
+ * for more advanced features like true parallel execution and result parsing
+ */
+import { BatchResults } from 'nx/src/tasks-runner/batch/batch-messages';
+export interface BatchTask {
+    id: string;
+    phase?: string;
+    goals?: string[];
+    args?: string[];
+}
+export interface BatchRunnerOptions {
+    workspaceRoot: string;
+    mavenExecutable: string;
+    tasks: BatchTask[];
+    verbose?: boolean;
+}
+/**
+ * Run Maven tasks in batch
+ * Groups tasks by shared targets and executes them in batches
+ */
+export declare function runMavenBatch(options: BatchRunnerOptions): Promise<BatchResults>;
+//# sourceMappingURL=batch-runner.d.ts.map

package/dist/executors/maven/batch-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"batch-runner.d.ts","sourceRoot":"","sources":["../../../src/executors/maven/batch-runner.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAGH,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AAExE,MAAM,WAAW,SAAS;IACxB,EAAE,EAAE,MAAM,CAAC;IACX,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,CAAC;IACjB,IAAI,CAAC,EAAE,MAAM,EAAE,CAAC;CACjB;AAED,MAAM,WAAW,kBAAkB;IACjC,aAAa,EAAE,MAAM,CAAC;IACtB,eAAe,EAAE,MAAM,CAAC;IACxB,KAAK,EAAE,SAAS,EAAE,CAAC;IACnB,OAAO,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;;GAGG;AACH,wBAAsB,aAAa,CACjC,OAAO,EAAE,kBAAkB,GAC1B,OAAO,CAAC,YAAY,CAAC,CA2CvB"}

package/dist/executors/maven/batch-runner.js

@@ -0,0 +1,111 @@
+"use strict";
+/**
+ * Batch runner for Maven - handles multi-task Maven execution
+ * This is a simplified implementation that can later be migrated to Kotlin/Java
+ * for more advanced features like true parallel execution and result parsing
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runMavenBatch = runMavenBatch;
+const child_process_1 = require("child_process");
+/**
+ * Run Maven tasks in batch
+ * Groups tasks by shared targets and executes them in batches
+ */
+async function runMavenBatch(options) {
+    const results = {};
+    // Group tasks by target combination
+    const taskGroups = groupTasksByTargets(options.tasks);
+    try {
+        // Execute each group
+        for (const group of taskGroups) {
+            const args = buildMavenArgs(group);
+            if (options.verbose) {
+                console.log(`[Maven Batch] Executing group with targets: ${args.join(' ')}`);
+            }
+            const success = await executeMavenCommand(options.mavenExecutable, args, options.workspaceRoot, options.verbose);
+            // Assign the same result to all tasks in the group
+            for (const taskId of group.taskIds) {
+                results[taskId] = {
+                    success,
+                    terminalOutput: `Executed with Maven batch runner`,
+                };
+            }
+        }
+    }
+    catch (error) {
+        const message = error instanceof Error ? error.message : String(error);
+        for (const task of options.tasks) {
+            results[task.id] = {
+                success: false,
+                terminalOutput: message,
+            };
+        }
+    }
+    return results;
+}
+function groupTasksByTargets(tasks) {
+    const groups = new Map();
+    for (const task of tasks) {
+        const goals = task.goals || [];
+        const args = task.args || [];
+        const key = JSON.stringify({
+            phase: task.phase,
+            goals,
+            args,
+        });
+        if (!groups.has(key)) {
+            groups.set(key, {
+                taskIds: [],
+                phase: task.phase,
+                goals,
+                args,
+            });
+        }
+        groups.get(key).taskIds.push(task.id);
+    }
+    return Array.from(groups.values());
+}
+function buildMavenArgs(group) {
+    const args = [];
+    if (group.phase) {
+        args.push(group.phase);
+    }
+    if (group.goals.length > 0) {
+        args.push(...group.goals);
+    }
+    if (group.args.length > 0) {
+        args.push(...group.args);
+    }
+    return args;
+}
+async function executeMavenCommand(executable, args, cwd, verbose) {
+    return new Promise((resolve) => {
+        let hasErrors = false;
+        const child = (0, child_process_1.spawn)(executable, args, {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        child.stdout?.on('data', (data) => {
+            const text = data.toString();
+            if (verbose) {
+                process.stdout.write(text);
+            }
+            if (text.includes('BUILD FAILURE')) {
+                hasErrors = true;
+            }
+        });
+        child.stderr?.on('data', (data) => {
+            const text = data.toString();
+            if (verbose) {
+                process.stderr.write(text);
+            }
+        });
+        child.on('close', (code) => {
+            resolve(code === 0 && !hasErrors);
+        });
+        child.on('error', () => {
+            resolve(false);
+        });
+    });
+}

package/dist/executors/maven/maven-batch.impl.d.ts

@@ -0,0 +1,9 @@
+import { ExecutorContext, 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 { MavenExecutorSchema } from './schema';
+/**
+ * Maven batch executor using Kotlin batch runner with Maven Invoker API
+ */
+export default function mavenBatchExecutor(taskGraph: TaskGraph, inputs: Record<string, MavenExecutorSchema>, overrides: RunCommandsOptions, context: ExecutorContext): Promise<BatchResults>;
+//# sourceMappingURL=maven-batch.impl.d.ts.map

package/dist/executors/maven/maven-batch.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maven-batch.impl.d.ts","sourceRoot":"","sources":["../../../src/executors/maven/maven-batch.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAU,SAAS,EAAiB,MAAM,YAAY,CAAC;AAI/E,OAAO,EAEL,kBAAkB,EACnB,MAAM,iDAAiD,CAAC;AACzD,OAAO,EAAE,YAAY,EAAE,MAAM,0CAA0C,CAAC;AACxE,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AA6D/C;;GAEG;AACH,wBAA8B,kBAAkB,CAC9C,SAAS,EAAE,SAAS,EACpB,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,mBAAmB,CAAC,EAC3C,SAAS,EAAE,kBAAkB,EAC7B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,YAAY,CAAC,CAsJvB"}

package/dist/executors/maven/maven-batch.impl.js

@@ -0,0 +1,183 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mavenBatchExecutor;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const run_commands_impl_1 = require("nx/src/executors/run-commands/run-commands.impl");
+/**
+ * Get path to the batch runner JAR
+ */
+function getBatchRunnerJar() {
+    // Try multiple locations
+    const possiblePaths = [
+        // Fallback relative to this file's dist location
+        (0, path_1.resolve)(__dirname, '../../../dist/batch-runner.jar'),
+    ];
+    for (const path of possiblePaths) {
+        if ((0, fs_1.existsSync)(path)) {
+            return path;
+        }
+    }
+    throw new Error(`Maven batch runner JAR not found. Tried: ${possiblePaths.join(', ')}`);
+}
+/**
+ * Normalize Maven arguments
+ */
+function normalizeMavenArgs(args) {
+    if (!args)
+        return [];
+    if (Array.isArray(args))
+        return args;
+    return args
+        .trim()
+        .split(' ')
+        .filter((arg) => arg.length > 0);
+}
+function buildTaskData(options, projectName) {
+    return {
+        phase: options.phase,
+        goals: Array.isArray(options.goals)
+            ? options.goals
+            : options.goals
+                ? [options.goals]
+                : [],
+        args: normalizeMavenArgs(options.args),
+        project: projectName,
+    };
+}
+/**
+ * Maven batch executor using Kotlin batch runner with Maven Invoker API
+ */
+async function mavenBatchExecutor(taskGraph, inputs, overrides, context) {
+    try {
+        const batchStart = performance.mark('maven-batch:start');
+        // Get batch runner JAR path
+        const batchRunnerJar = getBatchRunnerJar();
+        // Build task map for batch runner
+        const tasks = {};
+        const taskIds = Object.keys(taskGraph.tasks);
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log('[Maven Batch] Building tasks for execution:');
+        }
+        for (const taskId of taskIds) {
+            const task = taskGraph.tasks[taskId];
+            const projectName = task.target.project;
+            const options = inputs[taskId] || inputs[projectName];
+            tasks[taskId] = buildTaskData(options, projectName);
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.log(`[Maven Batch]   Task ID: "${taskId}"`);
+            }
+        }
+        // Build arguments for batch runner
+        const args = [];
+        if (overrides.__overrides_unparsed__?.length) {
+            args.push(...overrides.__overrides_unparsed__);
+        }
+        // Prepare batch runner arguments - JSON output to stdout like Gradle
+        const tasksJson = JSON.stringify(tasks).replaceAll("'", '"');
+        const argsJson = args.join(' ').replaceAll("'", '"');
+        const workspaceDataDir = (0, path_1.join)(devkit_1.workspaceRoot, '.nx');
+        // Add debug logging flags if verbose mode is enabled
+        let debugFlags = '';
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            debugFlags =
+                '-Dorg.slf4j.simpleLogger.defaultLogLevel=debug -Dorg.slf4j.simpleLogger.log.org.apache.maven=debug ';
+        }
+        const command = `java ${debugFlags}-jar "${batchRunnerJar}" --workspaceRoot="${devkit_1.workspaceRoot}" --workspaceDataDirectory="${workspaceDataDir}" --tasks='${tasksJson}' --args='${argsJson}'`;
+        if (process.env.NX_VERBOSE_LOGGING === 'true') {
+            console.log(`[Maven Batch] Executing: ${command}`);
+        }
+        let batchResults;
+        try {
+            // Execute batch runner - output goes to terminal in real-time
+            // We capture the result but the user sees Maven output on their terminal
+            const buffer = (0, child_process_1.execSync)(command, {
+                cwd: devkit_1.workspaceRoot,
+                input: JSON.stringify(taskGraph),
+                windowsHide: true,
+                env: process.env,
+                maxBuffer: run_commands_impl_1.LARGE_BUFFER,
+                encoding: 'utf-8',
+                stdio: ['pipe', 'pipe', 'inherit'], // Capture stdout, inherit stderr so logs show
+            });
+            batchResults = buffer.toString();
+        }
+        catch (e) {
+            // Batch runner may exit with non-zero code if tasks fail
+            // Try to extract JSON output from the error buffer
+            if (e.stdout) {
+                batchResults = e.stdout.toString();
+            }
+            else if (e.message) {
+                console.error('[Maven Batch] Error:', e.message);
+                throw e;
+            }
+        }
+        // Parse JSON results from stdout
+        let results = {};
+        try {
+            // Extract JSON from output (may have logs before it)
+            const startIndex = batchResults.indexOf('{');
+            const endIndex = batchResults.lastIndexOf('}');
+            if (startIndex >= 0 && endIndex > startIndex) {
+                const jsonStr = batchResults.substring(startIndex, endIndex + 1);
+                const rawResults = JSON.parse(jsonStr);
+                if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                    console.log('[Maven Batch] Expected task IDs:', taskIds);
+                }
+                results = Object.entries(rawResults).reduce((acc, [taskId, taskResult]) => {
+                    const result = taskResult;
+                    acc[taskId] = {
+                        success: result.success ?? false,
+                        terminalOutput: result.terminalOutput ?? '',
+                        startTime: result.startTime,
+                        endTime: result.endTime,
+                    };
+                    return acc;
+                }, {});
+            }
+            else {
+                throw new Error('No JSON found in batch runner output');
+            }
+        }
+        catch (e) {
+            console.warn('Failed to parse batch runner results:', e);
+            if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                console.log('[Maven Batch] Output was:', batchResults);
+            }
+        }
+        // Ensure all tasks have results
+        for (const taskId of taskIds) {
+            if (!results[taskId]) {
+                if (process.env.NX_VERBOSE_LOGGING === 'true') {
+                    console.log(`[Maven Batch] Missing result for task ID: "${taskId}"`);
+                    console.log(`[Maven Batch] Available task IDs in results:`, Object.keys(results));
+                }
+                results[taskId] = {
+                    success: false,
+                    terminalOutput: 'No result returned from batch runner',
+                };
+            }
+        }
+        const batchEnd = performance.mark('maven-batch:end');
+        performance.measure('maven-batch', batchStart.name, batchEnd.name);
+        return results;
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        devkit_1.output.error({
+            title: 'Maven batch execution failed',
+            bodyLines: [errorMessage],
+        });
+        const results = {};
+        for (const taskId of Object.keys(taskGraph.tasks)) {
+            results[taskId] = {
+                success: false,
+                terminalOutput: errorMessage,
+            };
+        }
+        return results;
+    }
+}

package/dist/executors/maven/maven.impl.d.ts

@@ -0,0 +1,11 @@
+import { ExecutorContext } from '@nx/devkit';
+import { MavenExecutorSchema } from './schema';
+export interface MavenExecutorResult {
+    success: boolean;
+    terminalOutput?: string;
+}
+/**
+ * Maven single-task executor
+ */
+export default function mavenExecutor(options: MavenExecutorSchema, context: ExecutorContext): Promise<MavenExecutorResult>;
+//# sourceMappingURL=maven.impl.d.ts.map

package/dist/executors/maven/maven.impl.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"maven.impl.d.ts","sourceRoot":"","sources":["../../../src/executors/maven/maven.impl.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,eAAe,EAAiB,MAAM,YAAY,CAAC;AAI5D,OAAO,EAAE,mBAAmB,EAAE,MAAM,UAAU,CAAC;AAE/C,MAAM,WAAW,mBAAmB;IAClC,OAAO,EAAE,OAAO,CAAC;IACjB,cAAc,CAAC,EAAE,MAAM,CAAC;CACzB;AA2GD;;GAEG;AACH,wBAA8B,aAAa,CACzC,OAAO,EAAE,mBAAmB,EAC5B,OAAO,EAAE,eAAe,GACvB,OAAO,CAAC,mBAAmB,CAAC,CAoB9B"}

package/dist/executors/maven/maven.impl.js

@@ -0,0 +1,118 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.default = mavenExecutor;
+const devkit_1 = require("@nx/devkit");
+const child_process_1 = require("child_process");
+const fs_1 = require("fs");
+const path_1 = require("path");
+/**
+ * Detect Maven executable: mvnw > mvn
+ */
+function detectMavenExecutable(root) {
+    // Check for Maven wrapper
+    if (process.platform === 'win32') {
+        const wrapperPath = (0, path_1.join)(root, 'mvnw.cmd');
+        if ((0, fs_1.existsSync)(wrapperPath)) {
+            return 'mvnw.cmd';
+        }
+    }
+    else {
+        const wrapperPath = (0, path_1.join)(root, 'mvnw');
+        if ((0, fs_1.existsSync)(wrapperPath)) {
+            return './mvnw';
+        }
+    }
+    // Fallback to Maven
+    return 'mvn';
+}
+/**
+ * Build Maven command arguments
+ */
+function buildMavenArgs(options) {
+    const args = [];
+    if (options.phase) {
+        args.push(options.phase);
+    }
+    if (options.goals) {
+        const goals = Array.isArray(options.goals)
+            ? options.goals
+            : options.goals.split(' ');
+        args.push(...goals);
+    }
+    if (options.args) {
+        const additionalArgs = Array.isArray(options.args)
+            ? options.args
+            : options.args.trim().split(' ');
+        args.push(...additionalArgs.filter((arg) => arg.length > 0));
+    }
+    if (options.__unparsed__) {
+        args.push(...options.__unparsed__);
+    }
+    return args;
+}
+/**
+ * Execute Maven command in a child process
+ */
+async function executeMaven(executable, args, cwd) {
+    return new Promise((resolve) => {
+        let stdout = '';
+        let stderr = '';
+        const child = (0, child_process_1.spawn)(executable, args, {
+            cwd,
+            stdio: ['pipe', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                const text = data.toString();
+                stdout += text;
+                process.stdout.write(text);
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                const text = data.toString();
+                stderr += text;
+                process.stderr.write(text);
+            });
+        }
+        child.on('close', (code) => {
+            resolve({
+                success: code === 0,
+                stdout,
+                stderr,
+            });
+        });
+        child.on('error', (error) => {
+            stderr += error.message;
+            process.stderr.write(`Error: ${error.message}`);
+            resolve({
+                success: false,
+                stdout,
+                stderr,
+            });
+        });
+    });
+}
+/**
+ * Maven single-task executor
+ */
+async function mavenExecutor(options, context) {
+    const projectRoot = context.projectGraph.nodes[context.projectName]?.data?.root ?? context.root;
+    const mavenExecutable = detectMavenExecutable(devkit_1.workspaceRoot);
+    const args = buildMavenArgs(options);
+    try {
+        const result = await executeMaven(mavenExecutable, args, projectRoot);
+        return {
+            success: result.success,
+            terminalOutput: result.stdout + result.stderr,
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            success: false,
+            terminalOutput: errorMessage,
+        };
+    }
+}

package/dist/executors/maven/schema.d.ts

@@ -0,0 +1,8 @@
+export interface MavenExecutorSchema {
+    phase?: string;
+    goals?: string[] | string;
+    args?: string[] | string;
+    excludeDependsOn?: boolean;
+    __unparsed__?: string[];
+}
+//# sourceMappingURL=schema.d.ts.map

package/dist/executors/maven/schema.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../../src/executors/maven/schema.ts"],"names":[],"mappings":"AAAA,MAAM,WAAW,mBAAmB;IAClC,KAAK,CAAC,EAAE,MAAM,CAAC;IACf,KAAK,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IAC1B,IAAI,CAAC,EAAE,MAAM,EAAE,GAAG,MAAM,CAAC;IACzB,gBAAgB,CAAC,EAAE,OAAO,CAAC;IAC3B,YAAY,CAAC,EAAE,MAAM,EAAE,CAAC;CACzB"}

package/dist/executors/maven/schema.js

@@ -0,0 +1,2 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });

package/dist/generators/ci-workflow/generator.d.ts

@@ -0,0 +1,15 @@
+import { Tree } from '@nx/devkit';
+export type Command = {
+    command?: string;
+    comments?: string[];
+    alwaysRun?: boolean;
+};
+export interface Schema {
+    name: string;
+    ci: 'github' | 'circleci';
+    packageManager?: null;
+    commands?: Command[];
+}
+export declare function ciWorkflowGenerator(tree: Tree, schema: Schema): Promise<void>;
+export default ciWorkflowGenerator;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generators/ci-workflow/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/ci-workflow/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,IAAI,EACL,MAAM,YAAY,CAAC;AA4CpB,MAAM,MAAM,OAAO,GAAG;IACpB,OAAO,CAAC,EAAE,MAAM,CAAC;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAC;IACpB,SAAS,CAAC,EAAE,OAAO,CAAC;CACrB,CAAC;AAEF,MAAM,WAAW,MAAM;IACrB,IAAI,EAAE,MAAM,CAAC;IACb,EAAE,EAAE,QAAQ,GAAG,UAAU,CAAC;IAC1B,cAAc,CAAC,EAAE,IAAI,CAAC;IACtB,QAAQ,CAAC,EAAE,OAAO,EAAE,CAAC;CACtB;AAED,wBAAsB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,MAAM,EAAE,MAAM,iBAMnE;AAsCD,eAAe,mBAAmB,CAAC"}

package/dist/generators/ci-workflow/generator.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ciWorkflowGenerator = ciWorkflowGenerator;
+const devkit_1 = require("@nx/devkit");
+const path_1 = require("path");
+const nx_cloud_utils_1 = require("nx/src/utils/nx-cloud-utils");
+const default_base_1 = require("nx/src/utils/default-base");
+function getCiCommands(ci) {
+    switch (ci) {
+        case 'circleci': {
+            return [
+                {
+                    comments: [
+                        `# Nx Affected runs only tasks affected by the changes in this PR/commit. Learn more: https://nx.dev/ci/features/affected.`,
+                    ],
+                },
+                {
+                    command: `./nx affected --base=$NX_BASE --head=$NX_HEAD -t verify-ci`,
+                },
+                getNxCloudFixCiCommand(),
+            ];
+        }
+        default: {
+            return [
+                {
+                    comments: [
+                        `Nx Affected runs only tasks affected by the changes in this PR/commit. Learn more: https://nx.dev/ci/features/affected.`,
+                    ],
+                    command: `./nx affected -t verify-ci`,
+                },
+                getNxCloudFixCiCommand(),
+            ];
+        }
+    }
+}
+function getNxCloudFixCiCommand() {
+    return {
+        comments: [
+            `Nx Cloud recommends fixes for failures to help you get CI green faster. Learn more: https://nx.dev/ci/features/self-healing-ci`,
+        ],
+        command: `./nx fix-ci`,
+        alwaysRun: true,
+    };
+}
+async function ciWorkflowGenerator(tree, schema) {
+    const ci = schema.ci;
+    const options = getTemplateData(tree, schema);
+    (0, devkit_1.generateFiles)(tree, (0, path_1.join)(__dirname, 'files', ci), '', options);
+    await (0, devkit_1.formatFiles)(tree);
+}
+function getTemplateData(tree, options) {
+    const { name: workflowName, fileName: workflowFileName } = (0, devkit_1.names)(options.name);
+    let nxCloudHost = 'nx.app';
+    try {
+        const nxCloudUrl = (0, nx_cloud_utils_1.getNxCloudUrl)((0, devkit_1.readNxJson)(tree));
+        nxCloudHost = new URL(nxCloudUrl).host;
+    }
+    catch { }
+    const mainBranch = (0, default_base_1.deduceDefaultBase)();
+    const commands = options.commands ?? getCiCommands(options.ci);
+    const connectedToCloud = (0, nx_cloud_utils_1.isNxCloudUsed)((0, devkit_1.readNxJson)(tree));
+    return {
+        workflowName,
+        workflowFileName,
+        commands,
+        mainBranch,
+        nxCloudHost,
+        connectedToCloud,
+    };
+}
+exports.default = ciWorkflowGenerator;

package/dist/generators/init/generator.d.ts

@@ -0,0 +1,7 @@
+import { Tree } from '@nx/devkit';
+export interface MavenInitGeneratorSchema {
+    skipFormat?: boolean;
+}
+export declare function mavenInitGenerator(tree: Tree, options: MavenInitGeneratorSchema): Promise<() => Promise<void>>;
+export default mavenInitGenerator;
+//# sourceMappingURL=generator.d.ts.map

package/dist/generators/init/generator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"generator.d.ts","sourceRoot":"","sources":["../../../src/generators/init/generator.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,IAAI,EAIL,MAAM,YAAY,CAAC;AAIpB,MAAM,WAAW,wBAAwB;IACvC,UAAU,CAAC,EAAE,OAAO,CAAC;CACtB;AAED,wBAAsB,kBAAkB,CACtC,IAAI,EAAE,IAAI,EACV,OAAO,EAAE,wBAAwB,gCAiClC;AAsID,eAAe,kBAAkB,CAAC"}