Struct Task 

pub struct Task {

    pub shell: Option<Shell>,
    pub command: String,
    pub script: Option<String>,
    pub script_shell: Option<ScriptShell>,
    pub shell_options: Option<ShellOptions>,
    pub args: Vec<String>,
    pub env: HashMap<String, Value>,
    pub dagger: Option<DaggerTaskConfig>,
    pub runtime: Option<Runtime>,
    pub hermetic: bool,
    pub depends_on: Vec<TaskDependency>,
    pub inputs: Vec<Input>,
    pub outputs: Vec<String>,
    pub description: Option<String>,
    pub params: Option<TaskParams>,
    pub labels: Vec<String>,
    pub timeout: Option<String>,
    pub retry: Option<RetryConfig>,
    pub continue_on_error: bool,
    pub task_ref: Option<String>,
    pub project_root: Option<PathBuf>,
    pub source: Option<SourceLocation>,
    pub directory: Option<String>,
}

A single executable task

Note: Custom deserialization is used to ensure that a Task can only be deserialized when it has a command or script field. This is necessary because TaskNode uses untagged enum, and we need to distinguish between Task, TaskGroup, and TaskList during deserialization.

Fields

shell: Option<Shell>

Shell configuration for command execution (legacy, for backwards compatibility)

command: String

Command to execute. Required unless ‘script’ is provided.

script: Option<String>

Inline script to execute (alternative to command). When script is provided, shell defaults to bash if not specified.

script_shell: Option<ScriptShell>

Shell interpreter for script-based tasks (e.g., bash, python, node) Only used when script is provided.

shell_options: Option<ShellOptions>

Shell options for bash-like shells (errexit, nounset, pipefail, xtrace) Only used when script is provided with a POSIX-compatible shell.

args: Vec<String>

Arguments for the command

env: HashMap<String, Value>

Environment variables for this task

dagger: Option<DaggerTaskConfig>

Dagger-specific configuration for running this task in a container DEPRECATED: Use runtime field with Dagger variant instead

runtime: Option<Runtime>

Runtime override for this task (inherits from project if not set)

hermetic: bool

When true (default), task runs in isolated hermetic directory. When false, task runs directly in workspace/project root.

depends_on: Vec<TaskDependency>

Task dependencies - embedded task references with _name field In CUE, users write dependsOn: [build, test] with direct references. The Go bridge injects _name into each embedded task for identification.

inputs: Vec<Input>

Input files/resources

outputs: Vec<String>

Output files/resources

description: Option<String>

Description of the task

params: Option<TaskParams>

Task parameter definitions for CLI arguments

labels: Vec<String>

Labels for task discovery via TaskMatcher Example: labels: [“projen”, “codegen”]

timeout: Option<String>

Execution timeout (e.g., “30m”, “1h”)

retry: Option<RetryConfig>

Retry configuration for failed tasks

continue_on_error: bool

Continue execution even if this task fails (default: false)

task_ref: Option<String>

If set, this task is a reference to another project’s task that should be resolved at runtime using TaskDiscovery. Format: “#project-name:task-name”

project_root: Option<PathBuf>

If set, specifies the project root where this task should execute. Used for TaskRef resolution to run tasks in their original project.

source: Option<SourceLocation>

Source file location where this task was defined (from CUE metadata). Used to determine default execution directory and for task listing grouping.

directory: Option<String>

Working directory override (relative to cue.mod root). Defaults to the directory of the source file if not set.

Implementations

impl Task

pub fn from_task_ref(ref_str: &str) -> Self

Creates a new TaskRef placeholder task. This task will be resolved at runtime using TaskDiscovery.

pub fn is_task_ref(&self) -> bool

Returns true if this task is a TaskRef placeholder that needs resolution.

pub fn dependency_names(&self) -> impl Iterator<Item = &str>

Returns an iterator over dependency task names.

pub fn description(&self) -> &str

Returns the description, or a default if not set.

pub fn iter_path_inputs(&self) -> impl Iterator<Item = &String>

Returns an iterator over local path/glob inputs.

pub fn iter_project_refs(&self) -> impl Iterator<Item = &ProjectReference>

Returns an iterator over project references.

pub fn iter_task_outputs(&self) -> impl Iterator<Item = &TaskOutput>

Returns an iterator over same-project task output references.

pub fn collect_path_inputs_with_prefix( &self, prefix: Option<&Path>, ) -> Vec<String>

Collects path/glob inputs applying an optional prefix (for workspace roots).

pub fn collect_project_destinations_with_prefix( &self, prefix: Option<&Path>, ) -> Vec<String>

Collects mapped destinations from project references, applying an optional prefix.

pub fn collect_all_inputs_with_prefix( &self, prefix: Option<&Path>, ) -> Vec<String>

Collects all input patterns (local + project destinations) with an optional prefix.

Trait Implementations

impl AffectedBy for Task

fn is_affected_by(&self, changed_files: &[PathBuf], project_root: &Path) -> bool

Returns true if this task is affected by the given file changes.

Behavior

• Tasks with NO inputs are always considered affected (we can’t determine what affects them)
• Tasks with inputs are affected if any input pattern matches changed files

fn input_patterns(&self) -> Vec<&str>

Returns the input patterns that determine what affects this item.

impl Clone for Task

fn clone(&self) -> Task

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for Task

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for Task

fn default() -> Self

Returns the “default value” for a type.

impl<'de> Deserialize<'de> for Task

fn deserialize<D>(deserializer: D) -> Result<Self, D::Error>

where D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl PartialEq for Task

fn eq(&self, other: &Task) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Serialize for Task

fn serialize<__S>(&self, __serializer: __S) -> Result<__S::Ok, __S::Error>

where __S: Serializer,

Serialize this value into the given Serde serializer.

impl TaskNodeData for Task

fn dependency_names(&self) -> impl Iterator<Item = &str>

Returns an iterator over the names of tasks this task depends on.

fn add_dependency(&mut self, dep: String)

Adds a dependency to this task by name.

fn has_dependency(&self, name: &str) -> bool

Returns true if this task has a dependency on the given task name.

impl TaskResolver<Task> for Tasks

fn resolve(&self, name: &str) -> Option<TaskResolution<Task>>

Resolve a task name to its definition (single or group).

impl StructuralPartialEq for Task