orchestral-cli 0.4.1

A runtime for reliable, interactive AI agents.
Documentation 
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

//! Skill catalog presentation. Reading details never loads model instructions.
use super::menu::{Choice, LocalAction, Menu, MenuKind};
use crate::skill_command::SkillManager;
use anyhow::{Context, Result};
use std::path::Path;

pub(crate) fn list(manager: &SkillManager) -> Result<Menu> {
    let statuses = manager.statuses()?;
    if statuses.is_empty() {
        return Ok(super::services::detail(
            "Skills · this workspace",
            "No skills discovered in this workspace.",
        ));
    }
    let title = format!("Skills · this workspace · {} discovered", statuses.len());
    let choices = statuses
        .into_iter()
        .map(|skill| {
            let enabled_now = manager.enabled_in_process(&skill.path);
            let status = if enabled_now { "enabled" } else { "disabled" };
            let pending = if enabled_now != skill.enabled {
                " · restart pending"
            } else {
                ""
            };
            Choice::action(
                format!("{} · {status}{pending}", skill.name),
                LocalAction::SkillDetails(skill.name),
                skill
                    .description
                    .split_whitespace()
                    .collect::<Vec<_>>()
                    .join(" "),
            )
        })
        .collect();
    Ok(Menu::new(MenuKind::Skills, title, choices))
}

pub(crate) fn details(manager: &SkillManager, workspace: &Path, name: &str) -> Result<Menu> {
    let skill = manager
        .statuses()?
        .into_iter()
        .find(|skill| skill.name == name)
        .context("This skill is no longer in the discovered catalog")?;
    let enabled_now = manager.enabled_in_process(&skill.path);
    let status = if enabled_now { "enabled" } else { "disabled" };
    let source = Path::new(&skill.path)
        .strip_prefix(workspace)
        .unwrap_or(Path::new(&skill.path));
    let mut lines = vec![format!("This process: {status}")];
    if enabled_now != skill.enabled {
        lines.push(format!(
            "After restart: {} (restart pending)",
            if skill.enabled { "enabled" } else { "disabled" }
        ));
    }
    if !manager.globally_enabled() {
        lines.push("Skills are disabled by --no-skills or process configuration.".to_owned());
    } else {
        lines.push(format!(
            "Space: {} for future launches",
            if skill.enabled { "disable" } else { "enable" }
        ));
    }
    lines.push(format!("Source: {}", source.display()));
    lines.push(
        "Enabled means selectable; instructions load separately for each request.".to_owned(),
    );
    lines.push(format!(
        "\n{}\n\nFull path: {}",
        skill.description, skill.path
    ));
    let mut menu = super::services::detail(format!("Skill · {}", skill.name), lines.join("\n"));
    if manager.globally_enabled() {
        menu.toggle = Some(LocalAction::SetSkillEnabled {
            name: skill.name,
            enabled: !skill.enabled,
        });
    }
    Ok(menu)
}