Struct App 

pub struct App { /* private fields */ }

Top-level application entrypoint for CLI and REPL execution.

Most embedders should start here or with AppBuilder instead of trying to assemble runtime/session machinery directly.

Implementations

impl App

pub fn builder() -> AppBuilder

Starts the canonical public builder for host construction.

pub fn new() -> Self

Creates an application with the default native command registry and no wrapper-owned defaults.

pub fn with_native_commands( self, native_commands: NativeCommandRegistry, ) -> Self

Replaces the native command registry used for command dispatch.

Use this when an embedder wants extra in-process commands to participate in the same command surface as the built-in host commands. When omitted, the application uses the crate’s default native-command registry.

This is the main extension seam for downstream product crates that wrap osp-cli and add site-specific native commands while keeping the rest of the host/runtime behavior unchanged.

Examples

use anyhow::Result;
use clap::Command;
use osp_cli::app::BufferedUiSink;
use osp_cli::{
    App, NativeCommand, NativeCommandContext, NativeCommandOutcome, NativeCommandRegistry,
};

struct VersionCommand;

impl NativeCommand for VersionCommand {
    fn command(&self) -> Command {
        Command::new("version").about("Show custom version")
    }

    fn execute(
        &self,
        _args: &[String],
        _context: &NativeCommandContext<'_>,
    ) -> Result<NativeCommandOutcome> {
        Ok(NativeCommandOutcome::Exit(0))
    }
}

let app = App::new().with_native_commands(
    NativeCommandRegistry::new().with_command(VersionCommand),
);
let mut sink = BufferedUiSink::default();
let exit = app.run_process_with_sink(["osp", "--help"], &mut sink);

assert_eq!(exit, 0);
assert!(sink.stdout.contains("version"));

pub fn with_product_defaults(self, product_defaults: ConfigLayer) -> Self

Replaces the product-owned defaults layered into runtime bootstrap.

Use this when a wrapper crate owns extension keys such as extensions.<site>.* and wants them resolved through the normal host bootstrap path instead of maintaining a side-channel config helper.

When omitted, the application uses only the built-in runtime defaults.

pub fn run_from<I, T>(&self, args: I) -> Result<i32>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Runs the application and returns a structured exit status.

Use this when your caller wants ordinary Rust error handling instead of the process-style exit code conversion performed by App::run_process.

Examples

use osp_cli::App;

let exit = App::new().run_from(["osp", "--help"])?;

assert_eq!(exit, 0);

pub fn with_sink<'a>(self, sink: &'a mut dyn UiSink) -> AppRunner<'a>

Binds the application to a specific UI sink for repeated invocations.

Prefer this in tests, editor integrations, or foreign hosts that need the same host behavior as osp but want the rendered text captured in a buffer instead of written to process stdio.

Examples

use osp_cli::app::BufferedUiSink;
use osp_cli::App;

let mut sink = BufferedUiSink::default();
let exit = App::new()
    .with_sink(&mut sink)
    .run_process(["osp", "--help"]);

assert_eq!(exit, 0);
assert!(!sink.stdout.is_empty());
assert!(sink.stderr.is_empty());

pub fn run_with_sink<I, T>(&self, args: I, sink: &mut dyn UiSink) -> Result<i32>

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Runs the application with the provided UI sink.

Prefer this over App::with_sink when the caller only needs one invocation. Use App::with_sink and AppRunner when the same sink should be reused across multiple calls.

Examples

use osp_cli::App;
use osp_cli::app::BufferedUiSink;

let mut sink = BufferedUiSink::default();
let exit = App::new().run_with_sink(["osp", "--help"], &mut sink)?;

assert_eq!(exit, 0);
assert!(!sink.stdout.is_empty());
assert!(sink.stderr.is_empty());

pub fn run_process<I, T>(&self, args: I) -> i32

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Runs the application and converts execution failures into process exit codes.

Use this when the caller wants osp-style process behavior rather than structured error propagation. User-facing failures are rendered to the process stdio streams before the exit code is returned.

Examples

use osp_cli::App;

let exit = App::new().run_process(["osp", "--help"]);

assert_eq!(exit, 0);

pub fn run_process_with_sink<I, T>(&self, args: I, sink: &mut dyn UiSink) -> i32

where I: IntoIterator<Item = T>, T: Into<OsString> + Clone,

Runs the application with the provided sink and returns a process exit code.

This mirrors App::run_process but writes all rendered output and user-facing errors through the supplied sink instead of touching process stdio.

Examples

use osp_cli::App;
use osp_cli::app::BufferedUiSink;

let mut sink = BufferedUiSink::default();
let exit = App::new().run_process_with_sink(["osp", "--help"], &mut sink);

assert_eq!(exit, 0);
assert!(!sink.stdout.is_empty());
assert!(sink.stderr.is_empty());

Trait Implementations

impl Clone for App

fn clone(&self) -> App

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Default for App

fn default() -> App

Returns the “default value” for a type.