Struct Task 

pub struct Task {

    pub id: String,
    pub title: String,
    pub description: String,
    pub status: TaskStatus,
    pub complexity: u32,
    pub priority: Priority,
    pub dependencies: Vec<String>,
    pub parent_id: Option<String>,
    pub subtasks: Vec<String>,
    pub details: Option<String>,
    pub test_strategy: Option<String>,
    pub created_at: Option<String>,
    pub updated_at: Option<String>,
    pub assigned_to: Option<String>,
}

Fields

id: String

title: String

description: String

status: TaskStatus

complexity: u32

priority: Priority

dependencies: Vec<String>

parent_id: Option<String>

subtasks: Vec<String>

details: Option<String>

test_strategy: Option<String>

created_at: Option<String>

updated_at: Option<String>

assigned_to: Option<String>

Implementations

impl Task

pub const ID_SEPARATOR: char = ':'

ID separator for namespaced IDs (epic:local_id)

pub fn new(id: String, title: String, description: String) -> Self

pub fn parse_id(id: &str) -> Option<(&str, &str)>

Parse a task ID into (epic_tag, local_id) parts e.g., “phase1:10.1” -> Some((“phase1”, “10.1”)) e.g., “10.1” -> None (legacy format)

pub fn make_id(epic_tag: &str, local_id: &str) -> String

Create a namespaced task ID

pub fn local_id(&self) -> &str

Get the local ID part (without epic prefix)

pub fn epic_tag(&self) -> Option<&str>

Get the epic tag from a namespaced ID

pub fn is_subtask(&self) -> bool

Check if this is a subtask (has parent)

pub fn is_expanded(&self) -> bool

Check if this task has been expanded into subtasks

pub fn validate_id(id: &str) -> Result<(), String>

Validate task ID - must contain only alphanumeric characters, hyphens, underscores, colons (for namespacing), and dots (for subtask IDs)

pub fn validate_title(title: &str) -> Result<(), String>

Validate title - must not be empty and within length limit

pub fn validate_description(description: &str) -> Result<(), String>

Validate description - within length limit

pub fn validate_complexity(complexity: u32) -> Result<(), String>

Validate complexity - must be a Fibonacci number

pub fn sanitize_text(text: &str) -> String

Sanitize text by removing potentially dangerous HTML/script tags

pub fn validate(&self) -> Result<(), Vec<String>>

Comprehensive validation of all task fields

pub fn set_status(&mut self, status: TaskStatus)

pub fn update(&mut self)

pub fn has_dependencies_met(&self, all_tasks: &[Task]) -> bool

pub fn has_dependencies_met_refs(&self, all_tasks: &[&Task]) -> bool

Check if all dependencies are met, searching across provided task references Supports cross-tag dependencies when passed tasks from all phases

pub fn needs_expansion(&self) -> bool

Returns whether this task should be expanded into subtasks All tasks with complexity >= 3 can benefit from expansion Subtasks and already-expanded tasks don’t need expansion

pub fn recommended_subtasks(&self) -> usize

Returns the recommended number of subtasks based on complexity Complexity 1-2: 2 subtasks Complexity 3: 2-3 subtasks Complexity 5: 3-4 subtasks Complexity 8: 4-5 subtasks Complexity 13: 5-6 subtasks Complexity 21+: 6-8 subtasks

pub fn recommended_subtasks_for_complexity(complexity: u32) -> usize

Static version for use when we only have complexity value

pub fn assign(&mut self, assignee: &str)

pub fn is_assigned_to(&self, assignee: &str) -> bool

pub fn would_create_cycle( &self, new_dep_id: &str, all_tasks: &[Task], ) -> Result<(), String>

Check if adding a dependency would create a circular reference Returns Err with the cycle path if circular dependency detected

Trait Implementations

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<'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 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.