aipm-pack 0.22.0

AI Plugin Manager — author CLI (init, pack, publish, yank, login)
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

//! TTY bridge for `aipm-pack init` wizard.
//!
//! This module contains **only** the terminal-dependent code that calls
//! `inquire::*.prompt()`. It is excluded from the coverage gate because
//! it requires a real TTY and cannot run in CI.
//!
//! All logic (prompt definitions, answer resolution, validation, theming)
//! lives in [`super::wizard`] and is fully tested (snapshot + unit tests).

use std::path::Path;

use libaipm::manifest::types::PluginType;

use super::wizard::{
    package_prompt_steps, resolve_package_answers, styled_render_config, PromptAnswer, PromptKind,
    PromptStep,
};

/// Resolved wizard output: `(name, plugin_type)`.
type WizardResult = (Option<String>, Option<PluginType>);

/// Resolve package init options, launching the interactive wizard if needed.
///
/// When `interactive` is `true`, sets the global render config, prompts the
/// user for any values not provided via flags, and returns the resolved tuple.
/// When `false`, returns the flag values as-is (today's behavior).
pub fn resolve(
    interactive: bool,
    dir: &Path,
    flag_name: Option<String>,
    flag_type: Option<PluginType>,
) -> Result<WizardResult, Box<dyn std::error::Error>> {
    if interactive {
        inquire::set_global_render_config(styled_render_config());
        let steps = package_prompt_steps(dir, flag_name.as_deref(), flag_type);
        let answers = execute_prompts(&steps)?;
        Ok(resolve_package_answers(&answers, flag_name.as_deref(), flag_type))
    } else {
        Ok((flag_name, flag_type))
    }
}

/// Execute prompt steps against the real terminal via `inquire`.
///
/// Returns one [`PromptAnswer`] per step, in order.
fn execute_prompts(steps: &[PromptStep]) -> Result<Vec<PromptAnswer>, Box<dyn std::error::Error>> {
    let mut answers = Vec::with_capacity(steps.len());

    for step in steps {
        let answer = match &step.kind {
            PromptKind::Text { placeholder, validate } => {
                let mut prompt = inquire::Text::new(step.label).with_placeholder(placeholder);
                if let Some(help) = step.help {
                    prompt = prompt.with_help_message(help);
                }
                if *validate {
                    prompt = prompt.with_validator(|input: &str| {
                        match libaipm::manifest::validate::check_name(
                            input,
                            libaipm::manifest::validate::ValidationMode::Interactive,
                        ) {
                            Ok(()) => Ok(inquire::validator::Validation::Valid),
                            Err(msg) => Ok(inquire::validator::Validation::Invalid(msg.into())),
                        }
                    });
                }
                let result = prompt.prompt()?;
                PromptAnswer::Text(result)
            },
            PromptKind::Confirm { default } => {
                let mut prompt = inquire::Confirm::new(step.label).with_default(*default);
                if let Some(help) = step.help {
                    prompt = prompt.with_help_message(help);
                }
                let result = prompt.prompt()?;
                PromptAnswer::Bool(result)
            },
            PromptKind::Select { options, default_index } => {
                let mut prompt = inquire::Select::new(step.label, options.clone())
                    .with_starting_cursor(*default_index);
                if let Some(help) = step.help {
                    prompt = prompt.with_help_message(help);
                }
                let choice = prompt.prompt()?;
                let index = options.iter().position(|o| *o == choice).ok_or_else(|| {
                    format!(
                        "internal error: selected choice `{choice}` not found in options for prompt `{}`",
                        step.label
                    )
                })?;
                PromptAnswer::Selected(index)
            },
            PromptKind::MultiSelect { options, defaults } => {
                let mut prompt = inquire::MultiSelect::new(step.label, options.clone());
                let default_indices: Vec<usize> = defaults
                    .iter()
                    .enumerate()
                    .filter_map(|(i, &d)| if d { Some(i) } else { None })
                    .collect();
                prompt = prompt.with_default(&default_indices);
                if let Some(help) = step.help {
                    prompt = prompt.with_help_message(help);
                }
                let selected = prompt.prompt()?;
                let indices: Vec<usize> =
                    selected.iter().filter_map(|s| options.iter().position(|o| o == s)).collect();
                PromptAnswer::MultiSelected(indices)
            },
        };
        answers.push(answer);
    }

    Ok(answers)
}