Struct GoalAnalysis 

pub struct GoalAnalysis {
    pub main_goal: String,
    pub success_criteria: Vec<String>,
    pub sub_goals: Vec<String>,
}

Response structure from LLM when analyzing a task into a goal.

This structure is used to deserialize the JSON response from the LLM when it analyzes a task using GoalAnalyzer::create_analysis_prompt.

Examples

use ceylon_next::goal::{GoalAnalysis, Goal};
use serde_json::json;

let json = json!({
    "main_goal": "Build a web server",
    "success_criteria": ["Server responds to HTTP requests", "Handles errors gracefully"],
    "sub_goals": ["Set up HTTP listener", "Implement request routing", "Add error handling"]
});

let analysis: GoalAnalysis = serde_json::from_value(json).unwrap();
let goal = analysis.to_goal();

Fields

main_goal: String

The main goal description

success_criteria: Vec<String>

List of success criteria

sub_goals: Vec<String>

List of sub-goals in execution order

Implementations

impl GoalAnalysis

pub fn to_goal(&self) -> Goal

Converts this analysis into a Goal structure.

Sub-goals are assigned priorities based on their order in the list.

Returns

A new Goal with status set to NotStarted

Examples found in repository

examples/05_with_goals.rs (line 227)

fn example_4_goal_analysis() {
    println!("\n=== Example 4: Goal Analysis from Task Description ===\n");

    // Simulate LLM analyzing a task and breaking it down into a goal
    let task_description = "Help me learn Python programming";

    println!("📝 Original task: \"{}\"", task_description);
    println!("\n🔍 LLM analyzing task...\n");

    // This is what the LLM would return
    let analysis = GoalAnalysis {
        main_goal: "Help user learn Python programming from basics to practical skills".to_string(),
        success_criteria: vec![
            "User's current skill level identified".to_string(),
            "Learning path created based on skill level".to_string(),
            "Resources (tutorials, books) provided".to_string(),
            "Practice exercises suggested".to_string(),
            "Study schedule created".to_string(),
        ],
        sub_goals: vec![
            "Ask about current programming experience".to_string(),
            "Identify learning goals (web dev, data science, etc)".to_string(),
            "Create structured learning path".to_string(),
            "Recommend learning resources".to_string(),
            "Suggest practice projects".to_string(),
            "Create study timeline".to_string(),
        ],
    };

    // Convert analysis to a Goal
    let goal = analysis.to_goal();

    println!("✅ Goal created from analysis:\n");
    println!("{}", goal.get_summary());

    println!("\n✅ Example 4 completed!\n");
}

Trait Implementations

impl Debug for GoalAnalysis

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

Formats the value using the given formatter.

impl<'de> Deserialize<'de> for GoalAnalysis

fn deserialize<__D>(__deserializer: __D) -> Result<Self, __D::Error>

where __D: Deserializer<'de>,

Deserialize this value from the given Serde deserializer.

impl Serialize for GoalAnalysis

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

where __S: Serializer,

Serialize this value into the given Serde serializer.