Skip to main content

systemprompt_cli/commands/plugins/capabilities/
mod.rs

1//! `plugins capabilities` subcommands.
2//!
3//! Aggregates the capabilities each extension contributes — jobs, templates,
4//! schemas, tools, roles, and LLM providers — either as a per-kind listing or
5//! as a single rolled-up summary across the whole extension registry.
6
7pub mod jobs;
8pub mod llm_providers;
9pub mod roles;
10pub mod schemas;
11pub mod templates;
12pub mod tools;
13
14use clap::{Args, Subcommand};
15
16use super::discover_registry;
17use super::types::CapabilitiesSummaryOutput;
18use crate::CliConfig;
19use crate::shared::{CommandOutput, render_result};
20
21#[derive(Debug, Args)]
22pub struct CapabilitiesArgs {
23    #[command(subcommand)]
24    pub cmd: Option<CapabilitiesCommands>,
25}
26
27#[derive(Debug, Subcommand)]
28pub enum CapabilitiesCommands {
29    #[command(about = "List all jobs across extensions")]
30    Jobs(jobs::JobsArgs),
31
32    #[command(about = "List all templates across extensions")]
33    Templates(templates::TemplatesArgs),
34
35    #[command(about = "List all schemas across extensions")]
36    Schemas(schemas::SchemasArgs),
37
38    #[command(about = "List all tools across extensions")]
39    Tools(tools::ToolsArgs),
40
41    #[command(about = "List all roles across extensions")]
42    Roles(roles::RolesArgs),
43
44    #[command(about = "List all LLM providers across extensions")]
45    LlmProviders(llm_providers::LlmProvidersArgs),
46}
47
48pub(super) fn execute(args: CapabilitiesArgs, config: &CliConfig) {
49    match args.cmd {
50        None => {
51            render_result(&execute_summary(config), config);
52        },
53        Some(CapabilitiesCommands::Jobs(args)) => {
54            render_result(&jobs::execute(&args, config), config);
55        },
56        Some(CapabilitiesCommands::Templates(args)) => {
57            render_result(&templates::execute(&args, config), config);
58        },
59        Some(CapabilitiesCommands::Schemas(args)) => {
60            render_result(&schemas::execute(&args, config), config);
61        },
62        Some(CapabilitiesCommands::Tools(args)) => {
63            render_result(&tools::execute(&args, config), config);
64        },
65        Some(CapabilitiesCommands::Roles(args)) => {
66            render_result(&roles::execute(&args, config), config);
67        },
68        Some(CapabilitiesCommands::LlmProviders(args)) => {
69            render_result(&llm_providers::execute(&args, config), config);
70        },
71    }
72}
73
74fn execute_summary(_config: &CliConfig) -> CommandOutput {
75    let registry = discover_registry();
76
77    let mut jobs = 0;
78    let mut templates = 0;
79    let mut schemas = 0;
80    let mut tools = 0;
81    let mut roles = 0;
82    let mut llm_providers = 0;
83    let mut extension_count = 0;
84
85    for ext in registry.extensions() {
86        extension_count += 1;
87        jobs += ext.jobs().len();
88        schemas += ext.schemas().len();
89        roles += ext.roles().len();
90        llm_providers += ext.llm_providers().len();
91        tools += ext.tool_providers().len();
92
93        for provider in ext.template_providers() {
94            templates += provider.templates().len();
95        }
96    }
97
98    let output = CapabilitiesSummaryOutput {
99        jobs,
100        templates,
101        schemas,
102        tools,
103        roles,
104        llm_providers,
105        extension_count,
106    };
107
108    CommandOutput::card_value("Capabilities Summary", &output)
109}