Enum Command 

pub(crate) enum Command {
    Porch {
        maildir: Vec<PathBuf>,
        open: bool,
        all: bool,
    },
    Done,
    Card {
        file: PathBuf,
    },
    Projects {
        store: Option<PathBuf>,
    },
    Window,
    Budgets {
        file: Option<PathBuf>,
        maildir: Vec<PathBuf>,
    },
    Account(AccountCommand),
    Mail(MailCommand),
    Pgp(PgpCommand),
    Dav(DavCommand),
    Contacts {
        query: Option<String>,
    },
    Contact {
        name: String,
        email: Vec<String>,
        phone: Vec<String>,
    },
    Agenda {
        days: i64,
    },
    Event {
        title: String,
        start: String,
        end: Option<String>,
        all_day: bool,
        location: Option<String>,
        repeat: Option<String>,
    },
    Block {
        entry: Option<String>,
    },
    Unblock {
        entry: String,
    },
    Verify {
        again: bool,
    },
    Tasks(TasksCommand),
    Focus(FocusCommand),
    Links {
        uri: String,
    },
    Notes {
        query: Vec<String>,
        path: Option<String>,
    },
    Sync {
        account: Option<String>,
    },
    Watch,
    Remind {
        watch: bool,
    },
    Shield {
        account: Option<String>,
        read: bool,
    },
    Mcp,
    Spam(SpamCommand),
}

Variants

Porch

What came, checked and sorted. Outside admin windows, only one-time codes show.

Fields

maildir: Vec<PathBuf>

Read this Maildir or folder of .eml files instead of the configured accounts.

open: bool

Show everything now, even outside an admin window.

all: bool

Also show what was there when the Porch was last closed.

Done

Closes the Porch on what it shows: what comes next waits for the next window.

Card

One message: its card, its lane and the reasons (a developer’s view).

Fields

file: PathBuf

Projects

The projects of the notes folder, and the files they name.

Fields

store: Option<PathBuf>

The notes folder (default: case_store in the configuration).

Window

When the next admin window opens.

Budgets

Budgets and reserves at a glance, and the lines mail proposes.

Fields

file: Option<PathBuf>

The budget file (default: sioul-budgets.toml at the root of the notes folder).

maildir: Vec<PathBuf>

Read mail about money in this Maildir or folder of .eml files, instead of the accounts’.

Account(AccountCommand)

Mail accounts: add, list, test, change a password, remove.

Mail(MailCommand)

The mail client: folders, messages, what you do to them, writing and sending.

Pgp(PgpCommand)

OpenPGP keys: yours and others’.

Dav(DavCommand)

Contacts and calendars on a CardDAV and CalDAV server: add an account, sync.

Contacts

Your contacts, or those matching a name, an address, a number.

Fields

query: Option<String>

Contact

Adds a contact to the first address book, and sends it.

Fields

name: String

email: Vec<String>

phone: Vec<String>

Agenda

What comes: today, then the next days.

Fields

days: i64

Event

Adds an event to the first calendar, and sends it. Times: “2026-10-05T09:00”, or a date with –all-day.

Fields

title: String

start: String

end: Option<String>

all_day: bool

location: Option<String>

repeat: Option<String>

daily, weekly, monthly or yearly.

Block

Blocks a sender (an address, or @domain for everyone there): their mail is set aside for good, never shown, never counted. Without an argument, lists who is blocked.

Fields

entry: Option<String>

Unblock

Unblocks a sender.

Fields

entry: String

Verify

Checks SPF, DKIM, DMARC, ARC and reverse DNS on the mail Sioul has not checked yet (mail fetched from now on is checked as it arrives).

Fields

again: bool

Check all the mail again, replacing earlier results.

Tasks(TasksCommand)

Tasks: the next step, the list, the board, the timeline; adding, importing.

Focus(FocusCommand)

A focus session on one task: start, status, stop.

Links

What a thing is tied to, both ways: sioul:task/<UID>, mid:<Message-ID>, sioul:note/<path>…

Fields

uri: String

Notes

Notes of the notes folder: those matching, or one with –path.

Fields

query: Vec<String>

path: Option<String>

Sync

Fetches new mail, changing nothing on the server: from every account, or one.

Fields

account: Option<String>

Watch

Stays open and fetches mail as it arrives; verified codes come as notifications.

Remind

Reminders before dates: what comes in the next two weeks, and what was told.

Fields

watch: bool

Stays open, with Sioul’s window closed too: each minute, what is due becomes one quiet notification, never repeated (the window marks the same ones).

Shield

What the shield of a public address makes of its mail: tone, topic, and the words that weighed. Hostile mail shows neither its sender’s name nor its subject.

Fields

account: Option<String>

The account, by its id; every shielded one by default.

read: bool

First lets the AI read what it has not read yet, where the address allows it.

Mcp

Serves Sioul to AI agents (Claude Code, Claude Desktop…) over MCP, on standard input and output: they read and write this computer’s files only, and never send (docs/mcp.md).

Spam(SpamCommand)

Sioul’s own spam filter, learned on this computer from your mail: the training corpus, training, its numbers, and why it judges a message as it does.

Trait Implementations

impl FromArgMatches for Command

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 Command

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