Enum Commands 

pub enum Commands {
    Start {
        program: PathBuf,
        args: Vec<String>,
        adapter: Option<String>,
        stop_on_entry: bool,
        initial_breakpoints: Vec<String>,
    },
    Attach {
        pid: u32,
        adapter: Option<String>,
    },
    Breakpoint(BreakpointCommands),
    Break {
        location: String,
        condition: Option<String>,
    },
    Continue,
    Next,
    Step,
    Finish,
    Pause,
    Backtrace {
        limit: usize,
        locals: bool,
    },
    Locals,
    Print {
        expression: String,
    },
    Eval {
        expression: String,
    },
    Context {
        lines: usize,
    },
    Threads,
    Thread {
        id: Option<i64>,
    },
    Frame {
        number: Option<usize>,
    },
    Up,
    Down,
    Await {
        timeout: u64,
    },
    Output {
        follow: bool,
        tail: Option<usize>,
        clear: bool,
    },
    Status,
    Stop,
    Detach,
    Restart,
    Logs {
        lines: usize,
        follow: bool,
        clear: bool,
    },
    Daemon,
    Setup {
        debugger: Option<String>,
        version: Option<String>,
        list: bool,
        check: bool,
        auto_detect: bool,
        uninstall: bool,
        path: bool,
        force: bool,
        dry_run: bool,
        json: bool,
    },
    Test {
        path: PathBuf,
        verbose: bool,
    },
}

Variants

Start

Start debugging a program

Fields

program: PathBuf

Path to the executable to debug

args: Vec<String>

Arguments to pass to the program

adapter: Option<String>

Debug adapter to use (default: lldb-dap)

stop_on_entry: bool

Stop at program entry point

initial_breakpoints: Vec<String>

Set initial breakpoint(s) before program starts (file:line or function name) Can be specified multiple times: –break main –break src/file.c:42

Attach

Attach to a running process

Fields

pid: u32

Process ID to attach to

adapter: Option<String>

Debug adapter to use (default: lldb-dap)

Breakpoint(BreakpointCommands)

Breakpoint management

Break

Shorthand for ‘breakpoint add’

Fields

location: String

Location: file:line or function name

condition: Option<String>

Condition for the breakpoint

Continue

Continue execution

Next

Step over (execute current line, step over function calls)

Step

Step into (execute current line, step into function calls)

Finish

Step out (run until current function returns)

Pause

Pause execution

Backtrace

Print stack trace

Fields

limit: usize

Maximum number of frames to show

locals: bool

Show local variables for each frame

Locals

Show local variables in current frame

Print

Print/evaluate expression

Fields

expression: String

Expression to evaluate

Eval

Evaluate expression (can have side effects)

Fields

expression: String

Expression to evaluate

Context

Show current position with source context and variables

Fields

lines: usize

Number of context lines to show

Threads

List all threads

Thread

Switch to a specific thread

Fields

id: Option<i64>

Thread ID to switch to

Frame

Navigate to a specific stack frame

Fields

number: Option<usize>

Frame number (0 = innermost/current)

Up

Move up the stack (to caller)

Down

Move down the stack (toward current frame)

Await

Wait for next stop event (breakpoint, step completion, etc.)

Fields

timeout: u64

Timeout in seconds

Output

Get debuggee stdout/stderr output

Fields

follow: bool

Stream output continuously

tail: Option<usize>

Get last N lines of output

clear: bool

Clear output buffer

Status

Get daemon/session status

Stop

Stop debugging (terminates debuggee and session)

Detach

Detach from process (process keeps running)

Restart

Restart program (re-launch with same arguments)

Logs

View daemon logs (for debugging)

Fields

lines: usize

Number of lines to show (default: 50)

follow: bool

Follow log output (like tail -f)

clear: bool

Clear the log file

Daemon

[Hidden] Run in daemon mode - spawned automatically

Setup

Install and manage debug adapters

Fields

debugger: Option<String>

Debugger to install (e.g., lldb, codelldb, python, go)

version: Option<String>

Install specific version

list: bool

List available debuggers and their status

check: bool

Check installed debuggers

auto_detect: bool

Auto-install debuggers for detected project types

uninstall: bool

Uninstall a debugger

path: bool

Show installation path for a debugger

force: bool

Force reinstall even if already installed

dry_run: bool

Show what would be installed without installing

json: bool

Output results as JSON

Test

Execute a test scenario defined in a YAML file

Fields

path: PathBuf

Path to the YAML test scenario file

verbose: bool

Verbose output

Trait Implementations

impl FromArgMatches for Commands

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut<'b>( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Subcommand for Commands

fn augment_subcommands<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_subcommands_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

fn has_subcommand(__clap_name: &str) -> bool

Test whether Self can parse a specific subcommand