Struct CommandPolicy 

pub struct CommandPolicy {
    pub path: CommandPath,
    pub visibility: VisibilityMode,
    pub availability: CommandAvailability,
    pub required_capabilities: BTreeSet<String>,
    pub feature_flags: BTreeSet<String>,
    pub allowed_profiles: Option<BTreeSet<String>>,
    pub denied_message: Option<String>,
    pub hidden_reason: Option<String>,
}

Declarative policy used to decide whether a command is visible and runnable.

Fields

path: CommandPath

Normalized command path used as the registry key.

visibility: VisibilityMode

Baseline visibility rule for the command.

availability: CommandAvailability

Product-level availability state for the command.

required_capabilities: BTreeSet<String>

Capabilities that must be present for capability-gated commands.

feature_flags: BTreeSet<String>

Feature flags that must be enabled before the command is exposed.

allowed_profiles: Option<BTreeSet<String>>

Profiles allowed to see the command, when restricted.

denied_message: Option<String>

Optional message shown when the command is visible but denied.

hidden_reason: Option<String>

Optional explanation for why the command is hidden.

Implementations

impl CommandPolicy

pub fn new(path: CommandPath) -> Self

Creates a public, available policy for the given command path.

Examples

use osp_cli::core::command_policy::{CommandPath, CommandPolicy, VisibilityMode};

let policy = CommandPolicy::new(CommandPath::new([" Orch ", "Approval "]))
    .visibility(VisibilityMode::CapabilityGated)
    .require_capability(" Orch.Approval.Decide ")
    .feature_flag(" Orch ")
    .allow_profiles([" Dev ", ""]);

assert_eq!(policy.path.as_slice(), &["orch", "approval"]);
assert!(policy.required_capabilities.contains("orch.approval.decide"));
assert!(policy.feature_flags.contains("orch"));
assert!(policy.allowed_profiles.as_ref().unwrap().contains("dev"));

pub fn visibility(self, visibility: VisibilityMode) -> Self

Sets the visibility mode applied during policy evaluation.

pub fn require_capability(self, capability: impl Into<String>) -> Self

Adds a required capability after trimming and lowercasing it.

pub fn feature_flag(self, flag: impl Into<String>) -> Self

Adds a feature flag prerequisite after trimming and lowercasing it.

pub fn allow_profiles<I, S>(self, profiles: I) -> Self

where I: IntoIterator<Item = S>, S: Into<String>,

Restricts the policy to the provided normalized profile names.

pub fn denied_message(self, message: impl Into<String>) -> Self

Sets the user-facing denial message when the command is visible but not runnable.

pub fn hidden_reason(self, reason: impl Into<String>) -> Self

Sets the hidden-reason metadata after trimming empty values away.

Trait Implementations

impl Clone for CommandPolicy

fn clone(&self) -> CommandPolicy

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for CommandPolicy

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl PartialEq for CommandPolicy

fn eq(&self, other: &CommandPolicy) -> bool

Tests for self and other values to be equal, and is used by ==.

fn ne(&self, other: &Rhs) -> bool

Tests for !=. The default implementation is almost always sufficient, and should not be overridden without very good reason.

impl Eq for CommandPolicy

impl StructuralPartialEq for CommandPolicy