loopflow 0.12.29

Run steps and flows with coding 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
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
129
130
131
132
133
134
135
136
137
138
139
140

use std::num::NonZeroU32;

use anyhow::{Context, Result};
use clap::Args;

use crate::durable::FlowFilter;
use crate::repository::CanonicalRepo;
use crate::session::FlowSummaryState;
use crate::store::{open_store, storage_config_from_env};

#[derive(Debug, Default, Args)]
pub struct FlowInventoryArgs {
    /// List or show saved FlowSessions instead of reusable templates
    #[arg(long)]
    pub sessions: bool,
    /// Include every repository and flows with unknown repository evidence
    #[arg(long)]
    pub all: bool,
    /// FlowSession page size (default 100)
    #[arg(long)]
    pub limit: Option<NonZeroU32>,
    /// Previous page's next identity; retain the same filters
    #[arg(long)]
    pub after: Option<String>,
    /// Literal name or identity containment
    #[arg(long)]
    pub search: Option<String>,
    #[arg(long, value_parser = ["current", "completed", "replaced"])]
    pub state: Option<String>,
    /// Retained Task ID or issue identifier, including completed Tasks
    #[arg(long, conflicts_with = "taskless")]
    pub for_task: Option<String>,
    /// Retained Wave ID or name
    #[arg(long)]
    pub for_wave: Option<String>,
    #[arg(long)]
    pub taskless: bool,
    /// Whether the Task currently selects this FlowSession
    #[arg(long, action = clap::ArgAction::Set)]
    pub managed: Option<bool>,
}

impl FlowInventoryArgs {
    pub fn is_empty(&self) -> bool {
        !self.sessions
            && !self.all
            && self.limit.is_none()
            && self.after.is_none()
            && self.search.is_none()
            && self.state.is_none()
            && self.for_task.is_none()
            && self.for_wave.is_none()
            && !self.taskless
            && self.managed.is_none()
    }
}

pub fn list(args: &FlowInventoryArgs, json: bool) -> Result<()> {
    tokio::runtime::Runtime::new()?.block_on(async {
        let store = open_store(&storage_config_from_env()?).await?;
        let repo = if args.all {
            None
        } else {
            CanonicalRepo::current()?.map(|repo| repo.to_string())
        };
        let filter = FlowFilter {
            task_id: args
                .for_task
                .as_deref()
                .map(|task| {
                    store
                        .sqlite
                        .resolve_task_id(task, repo.as_deref())
                        .map_err(anyhow::Error::from)?
                        .context("Task was not found")
                })
                .transpose()?,
            wave_id: args
                .for_wave
                .as_deref()
                .map(|wave| {
                    store
                        .sqlite
                        .resolve_wave_id(wave, repo.as_deref())
                        .map_err(anyhow::Error::from)?
                        .context("Wave was not found")
                })
                .transpose()?,
            state: args.state.as_deref().map(|state| match state {
                "completed" => FlowSummaryState::Completed,
                "replaced" => FlowSummaryState::Replaced,
                _ => FlowSummaryState::Current,
            }),
            repo,
            taskless: args.taskless,
            managed: args.managed,
            search: args.search.clone(),
        };
        let page = store
            .flow_inventory(
                &filter,
                args.after.as_deref(),
                args.limit
                    .unwrap_or(NonZeroU32::new(100).expect("100 is nonzero")),
            )
            .await?;
        if json {
            println!("{}", serde_json::to_string_pretty(&page)?);
        } else {
            for entry in page.entries {
                println!(
                    "{}  {:?}  {}{}",
                    entry.summary.id,
                    entry.summary.state,
                    entry.summary.name.as_deref().unwrap_or("unknown template"),
                    if entry.managed { "  [managed]" } else { "" }
                );
            }
            if let Some(next) = page.next {
                println!("Continue with --after '{}' and the same filters", next);
            }
        }
        Ok(())
    })
}

pub fn inspect(selector: &str, json: bool) -> Result<()> {
    tokio::runtime::Runtime::new()?.block_on(async {
        let store = open_store(&storage_config_from_env()?).await?;
        let detail = store
            .flow_detail(selector)
            .await?
            .context("FlowSession was not found")?;
        if !json {
            println!("Resume with lf flow resume {}", detail.entry.summary.id);
        }
        println!("{}", serde_json::to_string_pretty(&detail)?);
        Ok(())
    })
}