Struct Orchestrator 

pub struct Orchestrator { /* private fields */ }

Simple orchestrator - coordinates tool execution timing

The Orchestrator manages the execution lifecycle of DX tools, handling:

• Tool Registration: Register tools for execution
• Priority Ordering: Execute tools in priority order (lower first)
• Dependency Resolution: Validate and resolve tool dependencies
• Circular Dependency Detection: Prevent infinite dependency loops
• Lifecycle Hooks: Invoke before/after/error hooks
• Parallel Execution: Support concurrent tool execution (optional)
• Traffic Branch Integration: Analyze file changes for merge safety
• Error Handling: Fail-fast or continue-on-error modes

Example

use dx_forge::{Orchestrator, DxTool, ExecutionContext, ToolOutput};
use anyhow::Result;
 
struct MyTool;
impl DxTool for MyTool {
    fn name(&self) -> &str { "my-tool" }
    fn version(&self) -> &str { "1.0.0" }
    fn priority(&self) -> u32 { 50 }
    fn execute(&mut self, _ctx: &ExecutionContext) -> Result<ToolOutput> {
        Ok(ToolOutput::success())
    }
}
 
fn main() -> Result<()> {
    let mut orch = Orchestrator::new(".")?;
    orch.register_tool(Box::new(MyTool))?;
    let results = orch.execute_all()?;
    println!("Executed {} tools", results.len());
    Ok(())
}

Implementations

impl Orchestrator

pub fn new(repo_root: impl Into<PathBuf>) -> Result<Self>

Create a new orchestrator

pub fn with_config( repo_root: impl Into<PathBuf>, config: OrchestratorConfig, ) -> Result<Self>

Create orchestrator with custom configuration

pub fn set_config(&mut self, config: OrchestratorConfig)

Update configuration

pub fn register_tool(&mut self, tool: Box<dyn DxTool>) -> Result<()>

Register a tool (tools configure themselves)

pub fn execute_all(&mut self) -> Result<Vec<ToolOutput>>

Execute all registered tools in priority order

pub fn context(&self) -> &ExecutionContext

Get execution context

pub fn context_mut(&mut self) -> &mut ExecutionContext

Get mutable context