use a3s_code_core::{Agent, AgentEvent, SessionOptions};

let agent = Agent::new("agent.hcl").await?;
let session = agent.session("/my-project", Some(
    SessionOptions::new()
        .with_planning(true)
        .with_goal_tracking(true)
))?;

let (mut rx, _handle) = session.stream("Refactor auth to use JWT and update all tests").await?;
while let Some(event) = rx.recv().await {
    match event {
        AgentEvent::StepStart { step_id, description, step_number, total_steps } => {
            // During parallel waves, multiple StepStart events fire before any StepEnd
            println!("[{step_number}/{total_steps}] Starting: {description}");
        }
        AgentEvent::StepEnd { step_id, status, step_number, total_steps } => {
            println!("[{step_number}/{total_steps}] {status}");
        }
        AgentEvent::GoalProgress { goal, progress, completed_steps, total_steps } => {
            // Fires after each wave completes
            println!("Goal: {goal}");
            println!("Progress: {:.0}% ({completed_steps}/{total_steps})", progress * 100.0);
        }
        AgentEvent::TextDelta { text } => print!("{text}"),
        AgentEvent::End { .. } => break,
        _ => {} // required: AgentEvent is #[non_exhaustive]
    }
}

const { Agent } = require('@a3s-lab/code');

const agent = await Agent.create('agent.hcl');
const session = agent.session('/my-project', {
  planning: true,
  goalTracking: true,
});

const events = await session.stream('Refactor auth to use JWT and update all tests');
for (const event of events) {
  switch (event.type) {
    case 'step_start':
      // During parallel waves, multiple step_start events fire before any step_end
      console.log(`[${event.stepNumber}/${event.totalSteps}] Starting: ${event.description}`);
      break;
    case 'step_end':
      console.log(`[${event.stepNumber}/${event.totalSteps}] ${event.status}`);
      break;
    case 'goal_progress':
      // Fires after each wave completes
      console.log(`Progress: ${(event.progress * 100).toFixed(0)}% (${event.completedSteps}/${event.totalSteps})`);
      break;
    case 'text_delta':
      process.stdout.write(event.text);
      break;
  }
}

from a3s_code import Agent

agent = Agent.create("agent.hcl")
session = agent.session("/my-project", planning=True, goal_tracking=True)

for event in session.stream("Refactor auth to use JWT and update all tests"):
    if event.event_type == "step_start":
        # During parallel waves, multiple step_start events fire before any step_end
        print(f"[{event.step_number}/{event.total_steps}] Starting: {event.description}")
    elif event.event_type == "step_end":
        print(f"[{event.step_number}/{event.total_steps}] {event.status}")
    elif event.event_type == "goal_progress":
        # Fires after each wave completes
        print(f"Progress: {event.progress:.0%} ({event.completed_steps}/{event.total_steps})")
    elif event.event_type == "text_delta":
        print(event.text, end="", flush=True)

use a3s_code_core::planning::{ExecutionPlan, Task, TaskStatus, Complexity};

let mut plan = ExecutionPlan::new("Refactor auth", Complexity::Complex);

// Independent steps — will run in parallel (Wave 1)
plan.add_step(Task::new("s1", "Analyze auth module"));
plan.add_step(Task::new("s2", "Analyze database schema"));

// Dependent step — waits for Wave 1 (Wave 2)
plan.add_step(
    Task::new("s3", "Implement JWT")
        .with_dependencies(vec!["s1".to_string(), "s2".to_string()])
);

// Wave 1: both s1 and s2 are ready
assert_eq!(plan.get_ready_steps().len(), 2);

// Simulate completing wave 1
plan.mark_status("s1", TaskStatus::Completed);
plan.mark_status("s2", TaskStatus::Completed);

// Wave 2: s3 is now ready
assert_eq!(plan.get_ready_steps().len(), 1);
assert_eq!(plan.get_ready_steps()[0].id, "s3");

// Progress tracking
assert!((plan.progress() - 0.666).abs() < 0.01); // 2/3

// Deadlock detection
assert!(!plan.has_deadlock());

// Count remaining work
assert_eq!(plan.pending_count(), 1);

// The dependency graph is built by the LLM planner automatically.
// In TypeScript, you configure planning and observe events:

const session = agent.session('/my-project', {
  planning: true,       // LLM decomposes task into steps with dependencies
  goalTracking: true,   // track progress against success criteria
});

// The planner produces a JSON plan like:
// {
//   "goal": "Refactor auth",
//   "complexity": "Complex",
//   "steps": [
//     { "id": "s1", "content": "Analyze auth module", "dependencies": [] },
//     { "id": "s2", "content": "Analyze database schema", "dependencies": [] },
//     { "id": "s3", "content": "Implement JWT", "dependencies": ["s1", "s2"] }
//   ]
// }
//
// The executor automatically parallelizes s1 + s2, then runs s3.

# The dependency graph is built by the LLM planner automatically.
# In Python, you configure planning and observe events:

session = agent.session("/my-project", planning=True, goal_tracking=True)

# The planner produces a JSON plan like:
# {
#   "goal": "Refactor auth",
#   "complexity": "Complex",
#   "steps": [
#     {"id": "s1", "content": "Analyze auth module", "dependencies": []},
#     {"id": "s2", "content": "Analyze database schema", "dependencies": []},
#     {"id": "s3", "content": "Implement JWT", "dependencies": ["s1", "s2"]}
#   ]
# }
#
# The executor automatically parallelizes s1 + s2, then runs s3.