Struct CliInterface 

pub struct CliInterface { /* private fields */ }

CLI (Command-Line Interface) handler

Provides a simple interface for executing commands from command-line arguments. The CLI parses arguments, executes the command, and exits.

Architecture

Command-line args → CliParser → CommandExecutor → Handler
                                      ↓
                                 ExecutionContext

Error Handling

Errors are displayed to stderr with colored formatting (if enabled) and the process exits with appropriate exit codes:

• 0: Success
• 1: Execution error
• 2: Argument parsing error
• 3: Other errors

Implementations

impl CliInterface

pub fn new( registry: CommandRegistry, context: Box<dyn ExecutionContext>, ) -> Self

Create a new CLI interface

Arguments

• registry - Command registry with all registered commands
• context - Execution context (will be consumed by the interface)

Example

use dynamic_cli::interface::CliInterface;
use dynamic_cli::prelude::*;

let registry = CommandRegistry::new();
let context = Box::new(MyContext::default());

let cli = CliInterface::new(registry, context);

pub fn run(self, args: Vec<String>) -> Result<()>

Run the CLI with provided arguments

Parses the arguments, executes the corresponding command, and handles errors. This method consumes self as the CLI typically runs once and exits.

Arguments

• args - Command-line arguments (typically from env::args().skip(1))

Returns

• Ok(()) on success
• Err(DynamicCliError) on any error (parsing, validation, execution)

Exit Codes

The caller should handle errors and exit with appropriate codes:

• Parse errors → exit code 2
• Execution errors → exit code 1
• Other errors → exit code 3

Example

use dynamic_cli::interface::CliInterface;
use dynamic_cli::prelude::*;
use std::process;

let registry = CommandRegistry::new();
let context = Box::new(MyContext::default());
let cli = CliInterface::new(registry, context);

if let Err(e) = cli.run(std::env::args().skip(1).collect()) {
    eprintln!("Error: {}", e);
    process::exit(1);
}

pub fn run_and_exit(self, args: Vec<String>) -> !

Run the CLI with automatic error handling and exit

This is a convenience method that:

1. Runs the CLI with provided arguments
2. Handles errors by displaying them to stderr
3. Exits the process with appropriate exit code

This method never returns.

Arguments

• args - Command-line arguments

Example

use dynamic_cli::interface::CliInterface;
use dynamic_cli::prelude::*;

let registry = CommandRegistry::new();
let context = Box::new(MyContext::default());
let cli = CliInterface::new(registry, context);

// This will handle errors and exit automatically
cli.run_and_exit(std::env::args().skip(1).collect());

pub fn run_script( self, path: impl AsRef<Path>, policy: ScriptErrorPolicy, ) -> Result<ScriptOutcome>

Run a batch of command lines read from a file (#41).

Each non-blank, non-comment (#-prefixed) line is tokenized the same quote-aware way as a typed REPL line (via ReplParser::tokenize), then dispatched through the exact same resolve → parse → execute path as run — no duplicate parsing logic, and repeatable options (DD-024) are fully preserved since dispatch goes through parse_typed() either way.

Error policy

policy decides what happens when a line fails:

• ScriptErrorPolicy::Abort: stop immediately, returning Err for the failing line. Lines before it have already run.
• ScriptErrorPolicy::Continue: record the failure and proceed to the next line. The method still returns Ok, with every failure listed in the returned ScriptOutcome.

Every failure — whether it aborts the run or not — is reported with its 1-based line number, wrapped in ExecutionError::CommandFailed (reusing the existing error hierarchy; no new enum variant, so no breaking change to ExecutionError’s non-#[non_exhaustive] shape).

Example

use dynamic_cli::interface::{CliInterface, ScriptErrorPolicy};
use dynamic_cli::prelude::*;

let registry = CommandRegistry::new();
let context = Box::new(MyContext::default());
let cli = CliInterface::new(registry, context);

let outcome = cli.run_script("commands.txt", ScriptErrorPolicy::Continue)?;
println!("{}/{} lines succeeded", outcome.lines_succeeded, outcome.lines_executed);