orchestratectl 0.1.1

Rust CLI for orchestrating AI-agent workflows on a developer's machine.
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

//! `discussion` subcommand — read (`list`, `show`) and resolve (`resolve`)
//! discussion projections under `<root>/runs/<run-id>/discussions/`.
//!
//! Verbs follow the noun-module pattern set by `run` and `event`:
//! one file per verb, shared types + dispatch in `mod.rs`.

pub mod dto;
pub mod list;
pub mod resolve;
pub mod show;

use clap::{Subcommand, ValueEnum};

use crate::error::CliError;
use crate::output::OutputSpec;

/// Status filter for `discussion list`.
#[derive(Debug, Clone, Copy, ValueEnum, PartialEq, Eq)]
#[clap(rename_all = "kebab-case")]
pub enum StatusArg {
    Open,
    Resolved,
}

#[derive(Subcommand, Debug)]
pub enum DiscussionAction {
    /// List discussions for a run.
    List {
        run_id: String,
        /// Filter by status (`open` or `resolved`). When omitted, all are listed.
        #[arg(long, value_enum)]
        status: Option<StatusArg>,
    },
    /// Show a single discussion projection.
    Show {
        run_id: String,
        discussion_id: String,
    },
    /// Resolve a discussion — emits `discussion.resolved`, updates the
    /// projection. Idempotent on `--choice`; conflict on `--choice` change.
    Resolve {
        run_id: String,
        discussion_id: String,
        /// Resolution choice (free-form string from the agent operator).
        #[arg(long)]
        choice: String,
        /// Optional human-readable note recorded with the resolution.
        #[arg(long)]
        note: Option<String>,
        /// Dedup token for retries (e.g. supervisor crash + replay).
        #[arg(long)]
        idempotency_key: Option<String>,
        /// Print the would-be event and exit 0 without touching the
        /// filesystem.
        #[arg(long)]
        dry_run: bool,
    },
}

pub fn dispatch(
    action: DiscussionAction,
    spec: &OutputSpec,
    warnings: &[String],
) -> Result<(), CliError> {
    match action {
        DiscussionAction::List { run_id, status } => list::run(list::Args {
            run_id,
            status,
            spec,
            warnings,
        }),
        DiscussionAction::Show {
            run_id,
            discussion_id,
        } => show::run(&run_id, &discussion_id, spec, warnings),
        DiscussionAction::Resolve {
            run_id,
            discussion_id,
            choice,
            note,
            idempotency_key,
            dry_run,
        } => resolve::run(resolve::Args {
            run_id,
            discussion_id,
            choice,
            note,
            idempotency_key,
            dry_run,
            spec,
            warnings,
        }),
    }
}

pub fn status_kebab(s: octl_core::DiscussionStatus) -> &'static str {
    use octl_core::DiscussionStatus::{Open, Resolved};
    match s {
        Open => "open",
        Resolved => "resolved",
    }
}