Jobs and works

use std::time::Duration;
use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZJobState, ZNewJob};

async fn run_job(api: &AttaccaApiClient) -> zyris::Result<()> {
    let job = api
        .create_job(ZNewJob {
            message: "Summarize this week's changelog".into(),
            agent_id: None,   // the account's Main Agent
            project_id: None, // the default project
            timezone: Some("Europe/Berlin".into()),
            planning: false,
            plan_mode: false,
            data: vec![],
        })
        .await?;

    loop {
        tokio::time::sleep(Duration::from_secs(5)).await;
        let job = api.get_job(job.id.clone()).await?;
        match job.state {
            ZJobState::Done => return Ok(()),
            ZJobState::Failed => {
                eprintln!("failed: {}", job.failure_reason.unwrap_or_default());
                return Ok(());
            }
            ZJobState::Ambiguous => {
                // The agent asked something; answer on the job's own session.
                let session_id = job.session_id.expect("a running job has a session");
                api.send_message(session_id, "Only the public changes.".into(), vec![]).await?;
            }
            _ => println!("{:?}: {}", job.state, job.last_activity.unwrap_or_default()),
        }
    }
}

draft → checking_requirements → awaiting_goal_approval ─approve_work_goal→ planning
      → awaiting_plan_approval ─approve_work_plan→ executing ⇄ halted → verifying → done
                                                   (or failed / cancelled)

use std::time::Duration;
use zyris_attacca::{AttaccaApi, AttaccaApiClient, ZNewWork, ZWork, ZWorkState};

async fn settle(api: &AttaccaApiClient, work_id: &str, gate: ZWorkState) -> zyris::Result<ZWork> {
    loop {
        let work = api.get_work(work_id.to_string()).await?;
        if work.state == gate || matches!(work.state, ZWorkState::Failed | ZWorkState::Cancelled) {
            return Ok(work);
        }
        tokio::time::sleep(Duration::from_secs(5)).await;
    }
}

async fn run_work(api: &AttaccaApiClient, project_id: String) -> zyris::Result<()> {
    let work = api
        .create_work(ZNewWork {
            message: "Make every fixture round-trip\n\nAdd the missing serde tests.".into(),
            agent_id: None,
            project_id: Some(project_id),
        })
        .await?;

    // Gate 1: the goal.
    let work = settle(api, &work.id, ZWorkState::AwaitingGoalApproval).await?;
    println!("goal: {:?}", work.final_goal);
    println!("blockers: {:?}", work.requirements_report);
    api.approve_work_goal(work.id.clone()).await?;

    // Gate 2: the task graph.
    let work = settle(api, &work.id, ZWorkState::AwaitingPlanApproval).await?;
    let graph = api.work_tasks(work.id.clone()).await?;
    for task in &graph.tasks {
        println!("{} {:?} {}", task.id, task.state, task.title);
    }
    for dep in &graph.deps {
        println!("{} -> {}", dep.upstream_task_id, dep.downstream_task_id);
    }
    api.approve_work_plan(work.id).await?;
    Ok(())
}