Enum ClientFilter 

pub enum ClientFilter {
    Opencode,
    Claude,
    Codex,
    Cursor,
    Gemini,
    Amp,
    Droid,
    Openclaw,
    Pi,
    Kimi,
    Qwen,
    Roocode,
    Kilocode,
    Mux,
    Kilo,
    Crush,
    Hermes,
    Copilot,
    Goose,
    Codebuff,
    Antigravity,
    Zed,
    Kiro,
    Trae,
    Warp,
    Cline,
    NineRouter,
    Gjc,
    Grok,
    Jcode,
    Commandcode,
    Micode,
    AntigravityCli,
    Junie,
    Zcode,
    Opencodereview,
    Codebuddy,
    Workbuddy,
    DevinCli,
    DevinDesktop,
    Synthetic,
}

Client identifiers exposed via --client.

Mirrors tokmesh_core::ClientId plus the Synthetic meta-client. We duplicate the variant set on the CLI side so tokmesh-core stays free of CLI-parsing dependencies and so Synthetic (which has no scan path of its own) can be treated as a first-class filter value without changing core invariants.

Variant order intentionally mirrors ClientId::ALL declaration order so the TUI source picker, --help’s [possible values: ...] listing, and any future iteration over ClientFilter::value_variants() agree on a single chronological ordering. Synthetic is appended at the end since it has no ClientId counterpart.

Variants

Opencode

Claude

Codex

Cursor

Gemini

Amp

Droid

Openclaw

Pi

Kimi

Qwen

Roocode

Kilocode

Mux

Kilo

Crush

Hermes

Copilot

Goose

Codebuff

Antigravity

Zed

Kiro

Trae

Warp

Cline

NineRouter

Gjc

Grok

Jcode

Commandcode

Micode

AntigravityCli

Junie

Zcode

Opencodereview

Codebuddy

Workbuddy

DevinCli

DevinDesktop

Synthetic

Implementations

impl ClientFilter

pub fn as_filter_str(&self) -> &'static str

Returns the canonical lowercase identifier consumed by tokmesh_core filter lists. Must match ClientId::as_str for every variant that has a corresponding ClientId.

pub fn to_client_id(self) -> Option<ClientId>

Convert to the corresponding ClientId, or None for the Synthetic meta-client which has no scan path of its own.

Used at boundaries where TUI state (HashSet<ClientFilter>) needs to feed core APIs that still consume Vec<ClientId>.

pub fn from_client_id(client: ClientId) -> Self

Lift a ClientId back into a ClientFilter. Total inverse of to_client_id for non-Synthetic variants.

pub fn from_filter_str(s: &str) -> Option<Self>

Parse a canonical lowercase identifier (the same form as_filter_str returns) into a ClientFilter. Returns None for any unknown id so callers can drop unrecognized settings entries without erroring.

pub fn default_set() -> HashSet<Self>

The “no filter” default set: every real client, with Synthetic excluded. Matches the pre-refactor behavior where a missing filter scanned every ClientId but did NOT post-process synthetic (synthetic detection has always been opt-in because it re-attributes messages from other clients to a different bucket).

Single source of truth: every code path that needs a default filter (TUI launch, submit warm cache, etc.) must consult this so the cache key, the in-app state, and the loader filter all agree. Drift between them produces stale-cache misses on every launch.

Trait Implementations

impl Clone for ClientFilter

fn clone(&self) -> ClientFilter

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Copy for ClientFilter

impl Debug for ClientFilter

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

Formats the value using the given formatter.

impl Eq for ClientFilter

impl Hash for ClientFilter

fn hash<__H: Hasher>(&self, state: &mut __H)

Feeds this value into the given Hasher.

fn hash_slice<H>(data: &[Self], state: &mut H)

where H: Hasher, Self: Sized,

Feeds a slice of this type into the given Hasher.

impl PartialEq for ClientFilter

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

Equality operator ==.

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

Inequality operator !=.

impl StructuralPartialEq for ClientFilter

impl ValueEnum for ClientFilter

fn value_variants<'a>() -> &'a [Self]

All possible argument values, in display order.

fn to_possible_value<'a>(&self) -> Option<PossibleValue>

The canonical argument value.

fn from_str(input: &str, ignore_case: bool) -> Result<Self, String>

Parse an argument into Self.