orchestral-cli 0.2.0

Command line interface for running Orchestral workflows
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128

use tokio::sync::oneshot;

use orchestral_core::store::Event as ChannelEvent;

use crate::runtime::event_projection::UiEvent;
use crate::runtime::protocol::ActivityKind;

pub(super) fn mark_turn_settled(turn_settled_tx: &mut Option<oneshot::Sender<()>>) {
    if let Some(tx) = turn_settled_tx.take() {
        let _ = tx.send(());
    }
}

pub(super) fn event_interaction_id(event: &ChannelEvent) -> Option<&str> {
    match event {
        ChannelEvent::UserInput { interaction_id, .. }
        | ChannelEvent::AssistantOutput { interaction_id, .. }
        | ChannelEvent::Artifact { interaction_id, .. } => Some(interaction_id.as_str()),
        ChannelEvent::SystemTrace {
            interaction_id,
            payload,
            ..
        } => interaction_id
            .as_ref()
            .map(|id| id.as_str())
            .or_else(|| payload.get("interaction_id").and_then(|v| v.as_str())),
        ChannelEvent::ExternalEvent { interaction_id, .. } => {
            interaction_id.as_ref().map(|id| id.as_str())
        }
    }
}

pub(super) fn classify_activity_kind(action: &str) -> ActivityKind {
    match action {
        "file_write" | "edit" | "patch" | "write" => ActivityKind::Edited,
        "http" | "search" | "read_file" | "list_files" | "find" | "grep" => ActivityKind::Explored,
        _ => ActivityKind::Ran,
    }
}

pub(super) fn normalize_step_action_label(step_id: &str, action: Option<String>) -> String {
    action
        .and_then(|raw| {
            let trimmed = raw.trim();
            if trimmed.is_empty() {
                None
            } else {
                Some(trimmed.to_string())
            }
        })
        .unwrap_or_else(|| step_id.to_string())
}

pub(super) fn format_running_label(step_id: &str, action_label: &str) -> String {
    if action_label == step_id {
        format!("Running {}", step_id)
    } else {
        format!("Running {} ({})", step_id, action_label)
    }
}

pub(super) fn channel_event_label(event: &ChannelEvent) -> &'static str {
    match event {
        ChannelEvent::UserInput { .. } => "UserInput",
        ChannelEvent::AssistantOutput { .. } => "AssistantOutput",
        ChannelEvent::Artifact { .. } => "Artifact",
        ChannelEvent::SystemTrace { .. } => "SystemTrace",
        ChannelEvent::ExternalEvent { .. } => "ExternalEvent",
    }
}

pub(super) fn ui_event_label(event: &UiEvent) -> &'static str {
    match event {
        UiEvent::AssistantOutput { .. } => "AssistantOutput",
        UiEvent::AssistantStreamDelta { .. } => "AssistantStreamDelta",
        UiEvent::TurnStarted => "TurnStarted",
        UiEvent::TurnResumed => "TurnResumed",
        UiEvent::TurnRejected { .. } => "TurnRejected",
        UiEvent::TurnQueued => "TurnQueued",
        UiEvent::ReplanningStarted { .. } => "ReplanningStarted",
        UiEvent::ReplanningCompleted { .. } => "ReplanningCompleted",
        UiEvent::ReplanningFailed { .. } => "ReplanningFailed",
        UiEvent::PlanningStarted => "PlanningStarted",
        UiEvent::PlanningCompleted { .. } => "PlanningCompleted",
        UiEvent::ExecutionStarted { .. } => "ExecutionStarted",
        UiEvent::ExecutionCompleted { .. } => "ExecutionCompleted",
        UiEvent::StepStarted { .. } => "StepStarted",
        UiEvent::StepCompleted { .. } => "StepCompleted",
        UiEvent::StepFailed { .. } => "StepFailed",
        UiEvent::AgentProgress { .. } => "AgentProgress",
        UiEvent::InputRequired { .. } => "InputRequired",
        UiEvent::TaskCompleted => "TaskCompleted",
        UiEvent::TaskFailed { .. } => "TaskFailed",
    }
}

pub(super) fn log_preview(text: &str, max_chars: usize) -> String {
    text.chars().take(max_chars).collect()
}

pub(super) fn preview_to_activity_lines(preview: &str) -> Vec<String> {
    let mut out = Vec::new();
    let lines: Vec<&str> = preview.lines().collect();
    let max_lines = 8usize;
    if lines.is_empty() {
        out.push("(empty)".to_string());
        return out;
    }

    for line in lines.iter().take(max_lines) {
        let trimmed = line.trim();
        if trimmed.is_empty() {
            continue;
        }
        let mut snippet: String = trimmed.chars().take(180).collect();
        if trimmed.chars().count() > 180 {
            snippet.push_str("...");
        }
        out.push(snippet);
    }
    if lines.len() > max_lines {
        out.push(format!("... +{} lines", lines.len() - max_lines));
    }
    if out.is_empty() {
        out.push("(empty)".to_string());
    }
    out
}