@ohos-ports/nx 23.2.1-beta.0 → 23.3.0-beta.0

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

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProjectHandler = showProjectHandler;
+const output_1 = require("../../utils/output");
+const project_graph_1 = require("../../project-graph/project-graph");
+const graph_1 = require("../graph/graph");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+const workspace_root_1 = require("../../utils/workspace-root");
+const configuration_1 = require("../../config/configuration");
+const calculate_default_project_name_1 = require("../../config/calculate-default-project-name");
+async function showProjectHandler(args) {
+    performance.mark('code-loading:end');
+    performance.measure('code-loading', 'init-local', 'code-loading:end');
+    const graph = await (0, project_graph_1.createProjectGraphAsync)();
+    let projectName = args.projectName;
+    // If no project name is provided, try to infer from cwd
+    if (!projectName) {
+        const nxJson = (0, configuration_1.readNxJson)();
+        projectName = (0, calculate_default_project_name_1.calculateDefaultProjectName)(process.cwd(), workspace_root_1.workspaceRoot, (0, project_graph_1.readProjectsConfigurationFromProjectGraph)(graph), nxJson);
+        if (!projectName) {
+            output_1.output.error({
+                title: 'Could not find a project in the current working directory.',
+                bodyLines: [
+                    `Please specify a project name using:`,
+                    `  nx show project <project-name>`,
+                    ``,
+                    `Or run this command from within a project directory.`,
+                ],
+            });
+            process.exit(1);
+        }
+    }
+    let node = graph.nodes[projectName];
+    if (!node) {
+        const projects = (0, find_matching_projects_1.findMatchingProjects)([projectName], graph.nodes);
+        if (projects.length === 1) {
+            const matchedProjectName = projects[0];
+            node = graph.nodes[matchedProjectName];
+        }
+        else if (projects.length > 1) {
+            output_1.output.error({
+                title: `Multiple projects matched:`,
+                bodyLines: projects.length > 100 ? [...projects.slice(0, 100), '...'] : projects,
+            });
+            console.log(`Multiple projects matched:\n  ${(projects.length > 100
+                ? [...projects.slice(0, 100), '...']
+                : projects).join('  \n')}`);
+            process.exit(1);
+        }
+        else {
+            console.log(`Could not find project ${projectName}`);
+            process.exit(1);
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify(node.data));
+    }
+    else if (args.web) {
+        await (0, graph_1.generateGraph)({
+            view: 'project-details',
+            focus: node.name,
+            watch: true,
+            open: args.open ?? true,
+        }, []);
+    }
+    else {
+        const pc = require('picocolors');
+        const logIfExists = (label, key) => {
+            if (node.data[key]) {
+                console.log(`${pc.bold(label)}: ${node.data[key]}`);
+            }
+        };
+        logIfExists('Name', 'name');
+        logIfExists('Root', 'root');
+        logIfExists('Source Root', 'sourceRoot');
+        logIfExists('Tags', 'tags');
+        logIfExists('Implicit Dependencies', 'implicitDependencies');
+        const targets = Object.entries(node.data.targets ?? {});
+        const maxTargetNameLength = Math.max(...targets.map(([t]) => t.length));
+        const maxExecutorNameLength = Math.max(...targets.map(([, t]) => t?.executor?.length ?? 0));
+        if (targets.length > 0) {
+            console.log(`${pc.bold('Targets')}: `);
+            for (const [target, targetConfig] of targets) {
+                const executorCommandText = targetConfig.metadata?.scriptContent ??
+                    targetConfig?.options?.command ??
+                    (targetConfig?.options?.commands?.length === 1
+                        ? targetConfig.options.commands[0]
+                        : targetConfig?.executor) ??
+                    '';
+                console.log(`- ${pc.bold((target + ':').padEnd(maxTargetNameLength + 2))} ${executorCommandText.padEnd(maxExecutorNameLength + 2)} ${(() => {
+                    const configurations = Object.keys(targetConfig.configurations ?? {});
+                    if (configurations.length) {
+                        return pc.dim(configurations.join(', '));
+                    }
+                    return '';
+                })()}`);
+            }
+        }
+    }
+    // TODO: Find a better fix for this
+    await new Promise((res) => setImmediate(res));
+    await output_1.output.drain();
+}

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

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

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

@@ -0,0 +1,131 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showProjectsHandler = showProjectsHandler;
+const output_1 = require("../../utils/output");
+const nx_json_1 = require("../../config/nx-json");
+const affected_project_graph_1 = require("../../project-graph/affected/affected-project-graph");
+const affected_tasks_1 = require("../../project-graph/affected/affected-tasks");
+const print_explanation_1 = require("../../project-graph/affected/print-explanation");
+const affected_reasons_1 = require("../../project-graph/affected/affected-reasons");
+const file_utils_1 = require("../../project-graph/file-utils");
+const operators_1 = require("../../project-graph/operators");
+const project_graph_1 = require("../../project-graph/project-graph");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const find_matching_projects_1 = require("../../utils/find-matching-projects");
+async function showProjectsHandler(args) {
+    performance.mark('code-loading:end');
+    performance.measure('code-loading', 'init-local', 'code-loading:end');
+    let graph = await (0, project_graph_1.createProjectGraphAsync)();
+    const nxJson = (0, nx_json_1.readNxJson)();
+    const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+        printWarnings: false,
+    }, nxJson);
+    const explainsTasks = args.affected &&
+        (0, affected_tasks_1.selectsAffectedTasks)() &&
+        !!args.withTarget?.length &&
+        !args.projects;
+    if ((0, affected_reasons_1.isExplaining)(nxArgs.explain) && !explainsTasks) {
+        throw new Error((0, affected_reasons_1.explainUnavailable)([
+            !(0, affected_tasks_1.selectsAffectedTasks)() && 'NX_LEGACY_AFFECTED=false',
+            !args.affected && '--affected',
+            !args.withTarget?.length && 'targets passed with --withTarget (-t)',
+        ].filter(Boolean), args.projects ? ['--projects'] : []));
+    }
+    // Affected touches dependencies so it needs to be processed first.
+    if (args.affected) {
+        const touchedFiles = await getTouchedFiles(nxArgs);
+        // With a target, list projects owning an affected task for it, matching `affected -t`.
+        if ((0, affected_tasks_1.selectsAffectedTasks)() && args.withTarget?.length && !args.projects) {
+            const affectedTasks = await (0, affected_tasks_1.computeAffectedTasks)({
+                projectGraph: graph,
+                nxJson,
+                targets: args.withTarget,
+                touchedFiles,
+                fileChangeArgs: {
+                    base: nxArgs.base,
+                    head: nxArgs.head,
+                    files: nxArgs.files,
+                },
+                explain: (0, affected_reasons_1.isExplaining)(nxArgs.explain),
+                ...(await runCommandModule().runnerInputsForSelection(nxArgs, nxJson)),
+            });
+            if ((0, affected_reasons_1.isExplaining)(nxArgs.explain)) {
+                (0, print_explanation_1.printAffectedExplanation)(affectedTasks.explanation, 'Affected tasks', 
+                // show projects declares its own --json, which has no executor to
+                // pass through to.
+                args.json ? 'stdout' : nxArgs.explain, { verbose: args.verbose });
+                await output_1.output.drain();
+                return;
+            }
+            const { taskGraph, initiatingTaskIds } = affectedTasks.taskSelection;
+            const owning = new Set(initiatingTaskIds.map((id) => taskGraph.tasks[id].target.project));
+            // The graph selection ran against: with the daemon on, the daemon's, not `graph`.
+            graph = {
+                ...affectedTasks.projectGraph,
+                nodes: Object.fromEntries(Object.entries(affectedTasks.projectGraph.nodes).filter(([name]) => owning.has(name))),
+            };
+        }
+        else {
+            graph = await getAffectedGraph(touchedFiles, nxJson, graph);
+        }
+    }
+    const filter = (0, operators_1.filterNodes)((node) => {
+        if (args.type && node.type !== args.type) {
+            return false;
+        }
+        return true;
+    });
+    graph = filter(graph);
+    // Apply projects filter and get resultant graph
+    if (args.projects) {
+        graph.nodes = getGraphNodesMatchingPatterns(graph, args.projects);
+    }
+    // Grab only the nodes with the specified target
+    if (args.withTarget) {
+        graph.nodes = Object.entries(graph.nodes).reduce((acc, [name, node]) => {
+            if (args.withTarget.some((target) => node.data.targets?.[target])) {
+                acc[name] = node;
+            }
+            return acc;
+        }, {});
+    }
+    const selectedProjects = new Set(Object.keys(graph.nodes));
+    if (args.exclude) {
+        const excludedProjects = (0, find_matching_projects_1.findMatchingProjects)(nxArgs.exclude, graph.nodes);
+        for (const excludedProject of excludedProjects) {
+            selectedProjects.delete(excludedProject);
+        }
+    }
+    if (args.json) {
+        console.log(JSON.stringify(Array.from(selectedProjects)));
+    }
+    else if (args.sep) {
+        console.log(Array.from(selectedProjects.values()).join(args.sep));
+    }
+    else {
+        for (const project of selectedProjects) {
+            console.log(project);
+        }
+    }
+    // TODO: Find a better fix for this
+    await new Promise((res) => setImmediate(res));
+    await output_1.output.drain();
+}
+function getGraphNodesMatchingPatterns(graph, patterns) {
+    const nodes = {};
+    const matches = (0, find_matching_projects_1.findMatchingProjects)(patterns, graph.nodes);
+    for (const match of matches) {
+        nodes[match] = graph.nodes[match];
+    }
+    return nodes;
+}
+function getAffectedGraph(touchedFiles, nxJson, graph) {
+    return (0, affected_project_graph_1.filterAffected)(graph, touchedFiles, nxJson);
+}
+async function getTouchedFiles(nxArgs) {
+    return (0, file_utils_1.calculateFileChanges)((0, command_line_utils_1.parseFiles)(nxArgs).files, nxArgs);
+}
+/** Loaded only when task selection needs it. */
+function runCommandModule() {
+    return require('../../tasks-runner/run-command');
+}

package/dist/src/command-line/show/show-target/index.d.ts

@@ -0,0 +1,3 @@
+export { showTargetInfoHandler } from './info';
+export { showTargetInputsHandler } from './inputs';
+export { showTargetOutputsHandler } from './outputs';

package/dist/src/command-line/show/show-target/index.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetOutputsHandler = exports.showTargetInputsHandler = exports.showTargetInfoHandler = void 0;
+var info_1 = require("./info");
+Object.defineProperty(exports, "showTargetInfoHandler", { enumerable: true, get: function () { return info_1.showTargetInfoHandler; } });
+var inputs_1 = require("./inputs");
+Object.defineProperty(exports, "showTargetInputsHandler", { enumerable: true, get: function () { return inputs_1.showTargetInputsHandler; } });
+var outputs_1 = require("./outputs");
+Object.defineProperty(exports, "showTargetOutputsHandler", { enumerable: true, get: function () { return outputs_1.showTargetOutputsHandler; } });

package/dist/src/command-line/show/show-target/info.d.ts

@@ -0,0 +1,28 @@
+import type { InputDefinition } from '../../../config/workspace-json-project-json';
+import type { ShowTargetBaseOptions } from '../command-object';
+import { type ResolvedTarget } from './utils';
+export declare function showTargetInfoHandler(args: ShowTargetBaseOptions): Promise<void>;
+export type TargetInfoData = ReturnType<typeof resolveTargetInfoData>;
+declare function resolveTargetInfoData(t: ResolvedTarget): {
+    project: string;
+    target: string;
+    configuration?: string;
+    executor: string;
+    command?: string;
+    _commandSourceKey?: string;
+    customHasher?: boolean;
+    dependsOn?: string[];
+    _depSources?: number[];
+    transitiveTasks?: string[];
+    parallelism: boolean;
+    continuous: boolean;
+    cache: boolean;
+    inputs?: (string | InputDefinition)[];
+    _inputSources?: number[];
+    outputs?: string[];
+    options: any;
+    configurations?: string[];
+    defaultConfiguration?: string;
+    sourceMap?: Record<string, [file: string, plugin: string]>;
+};
+export {};

package/dist/src/command-line/show/show-target/info.js

@@ -0,0 +1,389 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.showTargetInfoHandler = showTargetInfoHandler;
+const task_hasher_1 = require("../../../hasher/task-hasher");
+const create_task_graph_1 = require("../../../tasks-runner/create-task-graph");
+const utils_1 = require("../../../tasks-runner/utils");
+const utils_2 = require("./utils");
+// ── Handler ─────────────────────────────────────────────────────────
+async function showTargetInfoHandler(args) {
+    const t = await (0, utils_2.resolveTarget)(args, { withSourceMaps: true });
+    const data = resolveTargetInfoData(t);
+    renderTargetInfo(data, args);
+}
+function resolveTargetInfoData(t) {
+    const { projectName, targetName, configuration, node, graph, nxJson, sourceMaps, } = t;
+    const targetConfig = node.data.targets[targetName];
+    const allTargetNames = new Set();
+    for (const n of Object.values(graph.nodes)) {
+        for (const name of Object.keys(n.data.targets ?? {})) {
+            allTargetNames.add(name);
+        }
+    }
+    const depConfigs = (0, utils_1.getDependencyConfigs)({ project: projectName, target: targetName }, 
+    // no programmatic extras — `dependsOn` is already merged into the graph node
+    {}, graph, [...allTargetNames]) ?? [];
+    // Determine the hoisted command value and which option key it came from
+    let command;
+    let commandSourceKey;
+    if (targetConfig.metadata?.scriptContent) {
+        command = targetConfig.metadata.scriptContent;
+        commandSourceKey = 'options.script';
+    }
+    else if (targetConfig.options?.command) {
+        command = targetConfig.options.command;
+        commandSourceKey = 'options.command';
+    }
+    else if (targetConfig.options?.commands?.length === 1) {
+        command = targetConfig.options.commands[0];
+        commandSourceKey = 'options.commands';
+    }
+    else if (targetConfig.executor === 'nx:run-script' &&
+        targetConfig.options?.script) {
+        command = targetConfig.options.script;
+        commandSourceKey = 'options.script';
+    }
+    const { dependsOn, depSourceIndices, transitiveTasks } = resolveTaskGraphDependencies(graph, {}, projectName, targetName, configuration, depConfigs);
+    const configurations = Object.keys(targetConfig.configurations ?? {});
+    const targetSourceMap = extractTargetSourceMap(node.data.root, targetName, sourceMaps);
+    const usesCustomHasher = (0, utils_2.hasCustomHasher)(projectName, targetName, graph);
+    return {
+        project: projectName,
+        target: targetName,
+        ...(configuration ? { configuration } : {}),
+        executor: targetConfig.executor,
+        ...(command ? { command, _commandSourceKey: commandSourceKey } : {}),
+        ...(usesCustomHasher ? { customHasher: true } : {}),
+        ...(dependsOn.length > 0
+            ? { dependsOn, _depSources: depSourceIndices }
+            : {}),
+        ...(transitiveTasks.length > 0 ? { transitiveTasks } : {}),
+        parallelism: targetConfig.parallelism ?? true,
+        continuous: targetConfig.continuous ?? false,
+        cache: targetConfig.cache ?? false,
+        ...(targetConfig.inputs
+            ? (() => {
+                const expanded = expandInputsForDisplay(targetConfig.inputs, node, nxJson);
+                return {
+                    inputs: expanded.map((e) => e.value),
+                    _inputSources: expanded.map((e) => e.originalIndex),
+                };
+            })()
+            : {}),
+        ...(targetConfig.outputs
+            ? { outputs: targetConfig.outputs }
+            : {}),
+        options: {
+            ...targetConfig.options,
+            ...(configuration
+                ? targetConfig.configurations?.[configuration]
+                : undefined),
+        },
+        ...(configurations.length > 0 ? { configurations } : {}),
+        ...(targetConfig.defaultConfiguration
+            ? { defaultConfiguration: targetConfig.defaultConfiguration }
+            : {}),
+        ...(targetSourceMap ? { sourceMap: targetSourceMap } : {}),
+    };
+}
+function resolveDependencyProjects(dep, projectName, graph) {
+    if (dep.projects && dep.projects.length > 0)
+        return dep.projects;
+    if (dep.dependencies) {
+        const depEdges = graph.dependencies[projectName] ?? [];
+        return depEdges
+            .filter((edge) => {
+            const depNode = graph.nodes[edge.target];
+            return depNode && depNode.data.targets?.[dep.target];
+        })
+            .map((edge) => edge.target);
+    }
+    return [projectName];
+}
+/**
+ * Builds a task graph rooted at the requested target and returns:
+ *   - `dependsOn`: direct task dependencies of the root, with real
+ *     project/target resolution applied.
+ *   - `depSourceIndices`: for each direct dep, the index of the original
+ *     depConfig it corresponds to (for source-map hints), or -1 if unknown.
+ *   - `transitiveTasks`: task IDs reachable through the direct deps (not
+ *     the root, not direct deps).
+ *
+ * If `createTaskGraph` throws (e.g. circular dependencies), falls back to
+ * the `depConfig`-based resolution so the output still shows the configured
+ * list rather than silently collapsing to empty.
+ */
+function resolveTaskGraphDependencies(graph, extraTargetDeps, projectName, targetName, configuration, depConfigs) {
+    try {
+        const taskGraph = (0, create_task_graph_1.createTaskGraph)(graph, extraTargetDeps, [projectName], [targetName], configuration, {});
+        // `createTaskGraph` resolves the target's `defaultConfiguration`, so the real
+        // root task id may carry a `:config` suffix that `createTaskId` with the raw
+        // configuration would omit. Find the root task by (project, target) instead.
+        const rootTask = Object.values(taskGraph.tasks).find((task) => task.target.project === projectName && task.target.target === targetName);
+        const rootId = rootTask?.id ?? (0, utils_1.createTaskId)(projectName, targetName, configuration);
+        // Continuous dependencies (e.g. dev servers) live in a separate map but are
+        // direct dependencies just like the entries in `dependencies`.
+        const directDeps = [
+            ...(taskGraph.dependencies[rootId] ?? []),
+            ...(taskGraph.continuousDependencies[rootId] ?? []),
+        ];
+        const directDepSet = new Set(directDeps);
+        const depSourceIndices = directDeps.map((depTaskId) => {
+            const task = taskGraph.tasks[depTaskId];
+            if (!task)
+                return -1;
+            return findDepConfigIndex(task.target, depConfigs, projectName, graph);
+        });
+        // `Object.keys(dependencies)` gives the set of real (non-dummy) tasks
+        // in the graph — `filterDummyTasks` (called inside `createTaskGraph`)
+        // removes dummy entries from `dependencies` but leaves them in `tasks`.
+        const transitiveTasks = Object.keys(taskGraph.dependencies).filter((id) => id !== rootId && !directDepSet.has(id));
+        return { dependsOn: directDeps, depSourceIndices, transitiveTasks };
+    }
+    catch {
+        return {
+            ...resolveDependsOnFromConfigs(depConfigs, projectName, graph),
+            transitiveTasks: [],
+        };
+    }
+}
+function resolveDependsOnFromConfigs(depConfigs, projectName, graph) {
+    const dependsOn = [];
+    const depSourceIndices = [];
+    for (let i = 0; i < depConfigs.length; i++) {
+        const dep = depConfigs[i];
+        const projects = resolveDependencyProjects(dep, projectName, graph);
+        for (const p of projects) {
+            dependsOn.push(`${p}:${dep.target}`);
+            depSourceIndices.push(i);
+        }
+    }
+    return { dependsOn, depSourceIndices };
+}
+/**
+ * Builds the summary line shown beneath the direct `Depends On` list.
+ *
+ * Up to 3 unique target names: list them (`and 5 build, compile transitive tasks`).
+ * Beyond that: collapse to the count alone (`and 12 transitive tasks`).
+ */
+function formatTransitiveSummary(taskIds) {
+    const count = taskIds.length;
+    const plural = count === 1 ? 'task' : 'tasks';
+    const targetNames = uniqueTargetNames(taskIds);
+    if (targetNames.length === 0 || targetNames.length > 3) {
+        return `and ${count} transitive ${plural}`;
+    }
+    return `and ${count} ${targetNames.join(', ')} transitive ${plural}`;
+}
+function uniqueTargetNames(taskIds) {
+    const set = new Set();
+    for (const id of taskIds) {
+        // task ids are `project:target` or `project:target:config`
+        const parts = id.split(':');
+        if (parts.length >= 2)
+            set.add(parts[1]);
+    }
+    return [...set].sort();
+}
+function findDepConfigIndex(taskTarget, depConfigs, rootProject, graph) {
+    for (let i = 0; i < depConfigs.length; i++) {
+        const dep = depConfigs[i];
+        if (dep.target !== taskTarget.target)
+            continue;
+        const resolved = resolveDependencyProjects(dep, rootProject, graph);
+        if (resolved.includes(taskTarget.project))
+            return i;
+    }
+    return -1;
+}
+/**
+ * Expands named inputs (e.g. "production") to their definitions while
+ * tracking which original input index each expanded item came from.
+ * This lets the renderer look up `inputs.${originalIndex}` in the source map.
+ */
+function expandInputsForDisplay(inputs, node, nxJson) {
+    const namedInputs = (0, task_hasher_1.getNamedInputs)(nxJson, node);
+    const result = [];
+    for (let i = 0; i < inputs.length; i++) {
+        const input = inputs[i];
+        if (typeof input === 'string') {
+            if (input.startsWith('^')) {
+                result.push({ value: input, originalIndex: i });
+            }
+            else if (namedInputs[input]) {
+                for (const expanded of namedInputs[input]) {
+                    result.push({ value: expanded, originalIndex: i });
+                }
+            }
+            else {
+                result.push({ value: input, originalIndex: i });
+            }
+        }
+        else if ('input' in input) {
+            const name = input.input;
+            // Don't expand when the input has additional qualifiers (e.g. projects)
+            // since those scopes are meaningful and would be lost by expansion
+            const hasQualifiers = Object.keys(input).length > 1;
+            if (!hasQualifiers && !name.startsWith('^') && namedInputs[name]) {
+                for (const expanded of namedInputs[name]) {
+                    result.push({ value: expanded, originalIndex: i });
+                }
+            }
+            else {
+                result.push({ value: input, originalIndex: i });
+            }
+        }
+        else {
+            result.push({ value: input, originalIndex: i });
+        }
+    }
+    return result;
+}
+function extractTargetSourceMap(projectRoot, targetName, sourceMaps) {
+    if (!sourceMaps)
+        return undefined;
+    const projectSourceMap = sourceMaps[projectRoot];
+    if (!projectSourceMap)
+        return undefined;
+    const prefix = `targets.${targetName}.`;
+    const targetEntry = `targets.${targetName}`;
+    const result = {};
+    for (const [key, value] of Object.entries(projectSourceMap)) {
+        if (key === targetEntry) {
+            result['target'] = value;
+        }
+        else if (key.startsWith(prefix)) {
+            result[key.slice(prefix.length)] = value;
+        }
+    }
+    return Object.keys(result).length > 0 ? result : undefined;
+}
+// ── Render ──────────────────────────────────────────────────────────
+function renderTargetInfo(data, args) {
+    if (args.json) {
+        // Strip internal renderer-only fields from JSON output
+        const { _inputSources, _depSources, _commandSourceKey, ...jsonData } = data;
+        console.log(JSON.stringify(jsonData, null, 2));
+        return;
+    }
+    const c = (0, utils_2.pc)();
+    const sm = data.sourceMap;
+    const sourceHint = (key, fallbackKey) => {
+        if (!args.verbose)
+            return '';
+        const entry = sm?.[key] ?? (fallbackKey ? sm?.[fallbackKey] : undefined);
+        if (!entry)
+            return '';
+        const [file, plugin] = entry;
+        if (file && plugin)
+            return ` ${c.dim(`(from ${file} by ${plugin})`)}`;
+        if (file)
+            return ` ${c.dim(`(from ${file})`)}`;
+        if (plugin)
+            return ` ${c.dim(`(by ${plugin})`)}`;
+        return '';
+    };
+    console.log(`${c.bold('Target')}: ${c.cyan(data.project)}:${c.green(data.target)}${sourceHint('target')}`);
+    if (data.command) {
+        const label = data.executor === 'nx:run-script' ? 'Script' : 'Command';
+        const cmdHint = data._commandSourceKey
+            ? sourceHint(data._commandSourceKey)
+            : '';
+        console.log(`${c.bold(label)}: ${data.command}${cmdHint}`);
+    }
+    else if (data.executor) {
+        console.log(`${c.bold('Executor')}: ${data.executor}${sourceHint('executor')}`);
+    }
+    if (data.customHasher) {
+        console.log(`${c.bold('Hasher')}: ${c.yellow('custom')} ${c.dim('(inputs do not affect cache hash)')}`);
+    }
+    if (data.configuration)
+        console.log(`${c.bold('Configuration')}: ${data.configuration}`);
+    if (data.dependsOn && data.dependsOn.length > 0) {
+        console.log(`${c.bold('Depends On')}:`);
+        for (let i = 0; i < data.dependsOn.length; i++) {
+            const srcIdx = data._depSources?.[i];
+            const hint = srcIdx !== undefined && srcIdx >= 0
+                ? sourceHint(`dependsOn.${srcIdx}`, 'dependsOn')
+                : sourceHint('dependsOn');
+            console.log(`  ${data.dependsOn[i]}${hint}`);
+        }
+        if (data.transitiveTasks && data.transitiveTasks.length > 0) {
+            console.log(`  ${c.dim(formatTransitiveSummary(data.transitiveTasks))}`);
+        }
+    }
+    console.log(`${c.bold('Parallelism')}: ${data.parallelism}${sourceHint('parallelism')}`);
+    console.log(`${c.bold('Continuous')}: ${data.continuous}${sourceHint('continuous')}`);
+    console.log(`${c.bold('Cache')}: ${data.cache}${sourceHint('cache')}`);
+    if (data.inputs && data.inputs.length > 0) {
+        console.log(`${c.bold('Inputs')}:`);
+        const inputSources = data._inputSources;
+        // Build sortable entries with their source index
+        const entries = data.inputs.map((input, i) => ({
+            value: input,
+            sourceIndex: inputSources?.[i],
+        }));
+        entries.sort((a, b) => {
+            const aIsString = typeof a.value === 'string';
+            const bIsString = typeof b.value === 'string';
+            if (!aIsString && bIsString)
+                return 1;
+            if (aIsString && !bIsString)
+                return -1;
+            if (aIsString && bIsString) {
+                const aStr = a.value;
+                const bStr = b.value;
+                const aIsDep = aStr.startsWith('^');
+                const bIsDep = bStr.startsWith('^');
+                if (aIsDep && !bIsDep)
+                    return 1;
+                if (!aIsDep && bIsDep)
+                    return -1;
+                return aStr < bStr ? -1 : aStr > bStr ? 1 : 0;
+            }
+            return 0;
+        });
+        for (const { value, sourceIndex } of entries) {
+            const display = typeof value === 'string' ? value : JSON.stringify(value);
+            const hint = sourceIndex !== undefined
+                ? sourceHint(`inputs.${sourceIndex}`, 'inputs')
+                : '';
+            console.log(`  - ${display}${hint}`);
+        }
+    }
+    if (data.outputs && data.outputs.length > 0) {
+        console.log(`${c.bold('Outputs')}:`);
+        for (let i = 0; i < data.outputs.length; i++) {
+            const hint = sourceHint(`outputs.${i}`, 'outputs');
+            console.log(`  - ${data.outputs[i]}${hint}`);
+        }
+    }
+    // When command is hoisted, hide the corresponding option key from display
+    const hoistedOptionKey = data._commandSourceKey?.startsWith('options.')
+        ? data._commandSourceKey.slice('options.'.length)
+        : undefined;
+    const displayOptions = Object.entries(data.options).filter(([key]) => key !== hoistedOptionKey);
+    if (displayOptions.length > 0) {
+        console.log(`${c.bold('Options')}:`);
+        for (const [key, value] of displayOptions) {
+            const hint = sourceHint(`options.${key}`);
+            if (typeof value === 'object' && value !== null) {
+                console.log(`  ${key}:${hint}`);
+                const lines = JSON.stringify(value, null, 2).split('\n');
+                for (const line of lines) {
+                    console.log(`    ${line}`);
+                }
+            }
+            else {
+                console.log(`  ${key}: ${JSON.stringify(value)}${hint}`);
+            }
+        }
+    }
+    if (data.configurations && data.configurations.length > 0) {
+        const configList = data.configurations
+            .map((cfg) => cfg === data.defaultConfiguration ? `${cfg} ${c.dim('(default)')}` : cfg)
+            .join(', ');
+        console.log(`${c.bold('Configurations')}: ${configList}`);
+    }
+    console.log('');
+}

package/dist/src/command-line/show/show-target/inputs.d.ts

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