Struct Args 

pub struct Args {

    pub text: Option<String>,
    pub mem: Option<String>,
    pub entity_type: Option<String>,
    pub field: Option<String>,
    pub exclude: Vec<String>,
    pub phrase: Option<String>,
    pub edge_type: Option<String>,
    pub related_to: Option<String>,
    pub depth: Option<usize>,
    pub limit: Option<usize>,
    pub offset: Option<usize>,
    pub level: Option<String>,
    pub status: Option<String>,
    pub filter: Vec<String>,
    pub range_filter: Vec<String>,
    pub expand_via: Vec<String>,
    pub expand_depth: Option<usize>,
    pub direction: DirectionArg,
    pub stub: bool,
    pub no_stub: bool,
}

Find entities by text or graph proximity.

Fields

text: Option<String>

Free-text query. Omit for a pure structural filter.

mem: Option<String>

entity_type: Option<String>

field: Option<String>

Restrict text matching to a single field (title or section key). Maps to Query.field — narrows any, not, and phrase for the query. Replaces the former repeatable plural form, which was orphaned at the engine level.

exclude: Vec<String>

Exclude entities whose text matches this token. Repeatable — --exclude OAuth --exclude SAML drops every hit driven by either. Maps to Query.not. When combined with --field, the exclude scopes to that field via the engine’s existing Query.field semantics.

Example: memstead search auth --exclude OAuth returns “auth”-matching entities that are not driven by an OAuth match.

phrase: Option<String>

Restrict hits to entities containing this exact phrase (adjacency-sensitive). Maps to Query.phrase. Composable with --field (narrows the phrase match to one field) and --exclude (drops phrase-matching hits that also match the excluded token). Shell quoting is stripped before the binary sees the positional text argument — use this flag rather than quoting in the positional to express adjacency.

edge_type: Option<String>

Filter by edge type (e.g. USES, IMPLEMENTS).

related_to: Option<String>

Only entities within --depth hops of this ID.

depth: Option<usize>

limit: Option<usize>

offset: Option<usize>

level: Option<String>

status: Option<String>

filter: Vec<String>

Equality filter on any schema-declared filterable field: repeatable --filter KEY=VALUE. The four named-flag shortcuts (--type / --level / --status / --edge-type) handle their common cases; every other filterable: equality field (e.g. tags, scope) is reachable via this generic flag. Unknown keys are dropped and surface as engine warnings. There is no --confidence shortcut: a field reached only when a schema declares it goes through --filter <field>=<value> rather than a dedicated flag.

range_filter: Vec<String>

Range filter on any filterable: range field: repeatable --range-filter KEY=VALUE with the same key grammar as the MCP range_filters map — min_<field> / max_<field> for numbers, <field>_after / <field>_before for dates. The strings go to the same engine path the MCP tool uses, so the same four outcome codes apply with the same meaning: RANGE_FILTER_KEY_MALFORMED (key ignored), UNKNOWN_RANGE_FILTER_FIELD (no type declares the field — results stay unfiltered), RANGE_FILTER_TYPE_SCOPED (other types declare it — applied with strict type-narrowing), FIELD_NOT_RANGE_FILTERABLE (declared, but not filterable: range). Composable with --filter and the named shortcuts.

expand_via: Vec<String>

Relationship types to follow from primary hits to pull in graph-proximal neighbours: repeatable --expand-via REL_TYPE. Mirrors the MCP expand_via parameter — expanded hits carry expansion: { of, via_edge, via_direction, depth } and a decayed score (0.5^depth).

expand_depth: Option<usize>

Max hops to traverse via --expand-via (default: 1). Mirrors the MCP expand_depth parameter.

direction: DirectionArg

Traversal direction for --related-to and --expand-via, applied at EVERY hop: out follows edges pointing away from the seed (what does this rest on), in follows edges pointing at it (what rests on this), both (default) is the historical undirected walk. Depth > 1 is a pure transitive closure in the chosen direction — never a mixed walk.

stub: bool

Return only stub entities (conflicts with –no-stub).

no_stub: bool

Return only real (non-stub) entities (conflicts with –stub).

Trait Implementations

impl Args for Args

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

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

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

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

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

impl CommandFactory for Args

fn command<'b>() -> Command

Build a Command that can instantiate Self.

fn command_for_update<'b>() -> Command

Build a Command that can update self.

impl Debug for Args

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

Formats the value using the given formatter.

impl FromArgMatches for Args

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( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

impl Parser for Args

fn parse() -> Self

Parse from std::env::args_os(), exit on error.

fn try_parse() -> Result<Self, Error>

Parse from std::env::args_os(), return Err on error.

fn parse_from<I, T>(itr: I) -> Self

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

Parse from iterator, exit on error.

fn try_parse_from<I, T>(itr: I) -> Result<Self, Error>

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

Parse from iterator, return Err on error.

fn update_from<I, T>(&mut self, itr: I)

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

Update from iterator, exit on error.

fn try_update_from<I, T>(&mut self, itr: I) -> Result<(), Error>

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

Update from iterator, return Err on error.