Enum Command 

pub enum Command {
    Index {
        path: PathBuf,
        force: bool,
        languages: Vec<String>,
        quiet: bool,
        command: Option<IndexSubcommand>,
    },
    Query {

        pattern: Option<String>,
        symbols: bool,
        lang: Option<String>,
        kind: Option<String>,
        ast: bool,
        regex: bool,
        json: bool,
        pretty: bool,
        ai: bool,
        limit: Option<usize>,
        offset: Option<usize>,
        expand: bool,
        file: Option<String>,
        exact: bool,
        contains: bool,
        count: bool,
        timeout: u64,
        plain: bool,
        glob: Vec<String>,
        exclude: Vec<String>,
        paths: bool,
        no_truncate: bool,
        all: bool,
        force: bool,
        dependencies: bool,
    
},
    Serve {
        port: u16,
        host: String,
    },
    Stats {
        json: bool,
        pretty: bool,
    },
    Clear {
        yes: bool,
    },
    ListFiles {
        json: bool,
        pretty: bool,
    },
    Watch {
        path: PathBuf,
        debounce: u64,
        quiet: bool,
    },
    Mcp,
    Analyze {

        circular: bool,
        hotspots: bool,
        min_dependents: usize,
        unused: bool,
        islands: bool,
        min_island_size: usize,
        max_island_size: Option<usize>,
        format: String,
        json: bool,
        pretty: bool,
        count: bool,
        all: bool,
        plain: bool,
        glob: Vec<String>,
        exclude: Vec<String>,
        force: bool,
        limit: Option<usize>,
        offset: Option<usize>,
        sort: Option<String>,
    
},
    Deps {
        file: PathBuf,
        reverse: bool,
        depth: usize,
        format: String,
        json: bool,
        pretty: bool,
    },
    Ask {

        question: Option<String>,
        execute: bool,
        provider: Option<String>,
        json: bool,
        pretty: bool,
        additional_context: Option<String>,
        configure: bool,
        agentic: bool,
        max_iterations: usize,
        no_eval: bool,
        show_reasoning: bool,
        verbose: bool,
        quiet: bool,
        answer: bool,
        interactive: bool,
        debug: bool,
    
},
    Context {
        structure: bool,
        path: Option<String>,
        file_types: bool,
        project_type: bool,
        framework: bool,
        entry_points: bool,
        test_layout: bool,
        config_files: bool,
        depth: usize,
        json: bool,
    },
    IndexSymbolsInternal {
        cache_dir: PathBuf,
    },
}

Variants

Index

Build or update the local code index

Fields

path: PathBuf

Directory to index (defaults to current directory)

force: bool

Force full rebuild (ignore incremental cache)

languages: Vec<String>

Languages to include (empty = all)

quiet: bool

Suppress all output (no progress bar, no summary)

command: Option<IndexSubcommand>

Subcommand (status, compact)

Query

Query the code index

If no pattern is provided, launches interactive mode (TUI).

Search modes:

• Default: Word-boundary matching (precise, finds complete identifiers) Example: rfx query “Error” → finds “Error” but not “NetworkError” Example: rfx query “test” → finds “test” but not “test_helper”

• Symbol search: Word-boundary for text, exact match for symbols Example: rfx query “parse” –symbols → finds only “parse” function/class Example: rfx query “parse” –kind function → finds only “parse” functions

• Substring search: Expansive matching (opt-in with –contains) Example: rfx query “mb” –contains → finds “mb”, “kmb_dai_ops”, “symbol”, etc.

• Regex search: Pattern-controlled matching (opt-in with –regex) Example: rfx query “^mb_.*” –regex → finds “mb_init”, “mb_start”, etc.

Interactive mode:

• Launch with: rfx query
• Search, filter, and navigate code results in a live TUI
• Press ‘?’ for help, ‘q’ to quit

Fields

pattern: Option<String>

Search pattern (omit to launch interactive mode)

symbols: bool

Search symbol definitions only (functions, classes, etc.)

lang: Option<String>

Filter by language Supported: rust, python, javascript, typescript, vue, svelte, go, java, php, c, c++, c#, ruby, kotlin, zig

kind: Option<String>

Filter by symbol kind (implies –symbols) Supported: function, class, struct, enum, interface, trait, constant, variable, method, module, namespace, type, macro, property, event, import, export, attribute

ast: bool

Use AST pattern matching (SLOW: 500ms-2s+, scans all files)

WARNING: AST queries bypass trigram optimization and scan the entire codebase. In 95% of cases, use –symbols instead which is 10-100x faster.

When –ast is set, the pattern parameter is interpreted as a Tree-sitter S-expression query instead of text search.

RECOMMENDED: Always use –glob to limit scope for better performance.

Examples: Fast (2-50ms): rfx query “fetch” –symbols –kind function –lang python Slow (500ms-2s): rfx query “(function_definition) @fn” –ast –lang python Faster with glob: rfx query “(class_declaration) @class” –ast –lang typescript –glob “src/**/*.ts”

regex: bool

Use regex pattern matching

Enables standard regex syntax in the search pattern: | for alternation (OR) - NO backslash needed . matches any character .* matches zero or more characters ^ anchors to start of line $ anchors to end of line

Examples: –regex “belongsTo|hasMany” Match belongsTo OR hasMany –regex “^import.*from” Lines starting with import…from –regex “fn.*test” Functions containing ‘test’

Note: Cannot be combined with –contains (mutually exclusive)

json: bool

Output format as JSON

pretty: bool

Pretty-print JSON output (only with –json) By default, JSON is minified to reduce token usage

ai: bool

AI-optimized mode: returns JSON with ai_instruction field Implies –json (minified by default, use –pretty for formatted output) Provides context-aware guidance to AI agents on response format and next actions

limit: Option<usize>

Maximum number of results

offset: Option<usize>

Pagination offset (skip first N results after sorting) Use with –limit for pagination: –offset 0 –limit 10, then –offset 10 –limit 10

expand: bool

Show full symbol definition (entire function/class body) Only applicable to symbol searches

file: Option<String>

Filter by file path (supports substring matching) Example: –file math.rs or –file helpers/

exact: bool

Exact symbol name match (no substring matching) Only applicable to symbol searches

contains: bool

Use substring matching for both text and symbols (expansive search)

Default behavior uses word-boundary matching for precision: “Error” matches “Error” but not “NetworkError”

With –contains, enables substring matching (expansive): “Error” matches “Error”, “NetworkError”, “error_handler”, etc.

Use cases:

• Finding partial matches: –contains “partial”
• When you’re unsure of exact names
• Exploratory searches

Note: Cannot be combined with –regex or –exact (mutually exclusive)

count: bool

Only show count and timing, not the actual results

timeout: u64

Query timeout in seconds (0 = no timeout, default: 30)

plain: bool

Use plain text output (disable colors and syntax highlighting)

glob: Vec<String>

Include files matching glob pattern (can be repeated)

Pattern syntax (NO shell quotes in the pattern itself): ** = recursive match (all subdirectories)

• = single level match (one directory)

Examples: –glob src//.rs All .rs files under src/ (recursive) –glob app/Models/.php PHP files directly in Models/ (not subdirs) –glob tests//*_test.go All test files under tests/

Tip: Use –file for simple substring matching instead: –file User.php Simpler than –glob **/User.php

exclude: Vec<String>

Exclude files matching glob pattern (can be repeated)

Same syntax as –glob (** for recursive, * for single level)

Examples: –exclude target/** Exclude all files under target/ –exclude /*.gen.rs Exclude generated Rust files –exclude node_modules/ Exclude npm dependencies

paths: bool

Return only unique file paths (no line numbers or content) Compatible with –json to output [“path1”, “path2”, …]

no_truncate: bool

Disable smart preview truncation (show full lines) By default, previews are truncated to ~100 chars to reduce token usage

all: bool

Return all results (no limit) Equivalent to –limit 0, convenience flag for getting unlimited results

force: bool

Force execution of potentially expensive queries Bypasses broad query detection that prevents queries with: • Short patterns (< 3 characters) • High candidate counts (> 5,000 files for symbol/AST queries) • AST queries without –glob restrictions

dependencies: bool

Include dependency information (imports) in results Currently only available for Rust files

Serve

Start a local HTTP API server

Fields

port: u16

Port to listen on

host: String

Host to bind to

Stats

Show index statistics and cache information

Fields

json: bool

Output format as JSON

pretty: bool

Pretty-print JSON output (only with –json)

Clear

Clear the local cache

Fields

yes: bool

Skip confirmation prompt

ListFiles

List all indexed files

Fields

json: bool

Output format as JSON

pretty: bool

Pretty-print JSON output (only with –json)

Watch

Watch for file changes and auto-reindex

Continuously monitors the workspace for changes and automatically triggers incremental reindexing. Useful for IDE integrations and keeping the index always fresh during active development.

The debounce timer resets on every file change, batching rapid edits (e.g., multi-file refactors, format-on-save) into a single reindex.

Fields

path: PathBuf

Directory to watch (defaults to current directory)

debounce: u64

Debounce duration in milliseconds (default: 15000 = 15s) Waits this long after the last change before reindexing Valid range: 5000-30000 (5-30 seconds)

quiet: bool

Suppress output (only log errors)

Mcp

Start MCP server for AI agent integration

Runs Reflex as a Model Context Protocol (MCP) server using stdio transport. This command is automatically invoked by MCP clients like Claude Code and should not be run manually.

Configuration example for Claude Code (~/.claude/claude_code_config.json): { “mcpServers”: { “reflex”: { “type”: “stdio”, “command”: “rfx”, “args”: [“mcp”] } } }

Analyze

Analyze codebase structure and dependencies

Perform graph-wide dependency analysis to understand code architecture. By default, shows a summary report with counts. Use specific flags for detailed results.

Examples: rfx analyze # Summary report rfx analyze –circular # Find cycles rfx analyze –hotspots # Most-imported files rfx analyze –hotspots –min-dependents 5 # Filter by minimum rfx analyze –unused # Orphaned files rfx analyze –islands # Disconnected components rfx analyze –hotspots –count # Just show count rfx analyze –circular –glob “src/**” # Limit to src/

Fields

circular: bool

Show circular dependencies

hotspots: bool

Show most-imported files (hotspots)

min_dependents: usize

Minimum number of dependents for hotspots (default: 2)

unused: bool

Show unused/orphaned files

islands: bool

Show disconnected components (islands)

min_island_size: usize

Minimum island size (default: 2)

max_island_size: Option<usize>

Maximum island size (default: 500 or 50% of total files)

format: String

Output format: tree (default), table, dot

json: bool

Output as JSON

pretty: bool

Pretty-print JSON output

count: bool

Only show count and timing, not the actual results

all: bool

Return all results (no limit) Equivalent to –limit 0, convenience flag for unlimited results

plain: bool

Use plain text output (disable colors and syntax highlighting)

glob: Vec<String>

Include files matching glob pattern (can be repeated) Example: –glob “src//*.rs” –glob “tests//*.rs”

exclude: Vec<String>

Exclude files matching glob pattern (can be repeated) Example: –exclude “target/**” –exclude “*.gen.rs”

force: bool

Force execution of potentially expensive queries Bypasses broad query detection

limit: Option<usize>

Maximum number of results

offset: Option<usize>

Pagination offset

sort: Option<String>

Sort order for results: asc (ascending) or desc (descending) Applies to –hotspots (by import_count), –islands (by size), –circular (by cycle length) Default: desc (most important first)

Deps

Analyze dependencies for a specific file

Show dependencies and dependents for a single file. For graph-wide analysis, use ‘rfx analyze’ instead.

Examples: rfx deps src/main.rs # Show dependencies rfx deps src/config.rs –reverse # Show dependents rfx deps src/api.rs –depth 3 # Transitive deps

Fields

file: PathBuf

File path to analyze

reverse: bool

Show files that depend on this file (reverse lookup)

depth: usize

Traversal depth for transitive dependencies (default: 1)

format: String

Output format: tree (default), table, dot

json: bool

Output as JSON

pretty: bool

Pretty-print JSON output

Ask

Ask a natural language question and generate search queries

Uses an LLM to translate natural language questions into rfx query commands. Requires API key configuration for one of: OpenAI, Anthropic, or Groq.

If no question is provided, launches interactive chat mode by default.

Configuration:

1. Run interactive setup wizard (recommended): rfx ask –configure

2. OR set API key via environment variable:

   • OPENAI_API_KEY, ANTHROPIC_API_KEY, or GROQ_API_KEY

3. Optional: Configure provider in .reflex/config.toml: [semantic] provider = “groq” # or openai, anthropic model = “llama-3.3-70b-versatile” # optional, defaults to provider default

Examples: rfx ask –configure # Interactive setup wizard rfx ask # Launch interactive chat (default) rfx ask “Find all TODOs in Rust files” rfx ask “Where is the main function defined?” –execute rfx ask “Show me error handling code” –provider groq

Fields

question: Option<String>

Natural language question

execute: bool

Execute queries immediately without confirmation

provider: Option<String>

Override configured LLM provider (openai, anthropic, groq)

json: bool

Output format as JSON

pretty: bool

Pretty-print JSON output (only with –json)

additional_context: Option<String>

Additional context to inject into prompt (e.g., from rfx context)

configure: bool

Launch interactive configuration wizard to set up AI provider and API key

agentic: bool

Enable agentic mode (multi-step reasoning with context gathering)

max_iterations: usize

Maximum iterations for query refinement in agentic mode (default: 2)

no_eval: bool

Skip result evaluation in agentic mode

show_reasoning: bool

Show LLM reasoning blocks at each phase (agentic mode only)

verbose: bool

Verbose output: show tool results and details (agentic mode only)

quiet: bool

Quiet mode: suppress progress output (agentic mode only)

answer: bool

Generate a conversational answer based on search results

interactive: bool

Launch interactive chat mode (TUI) with conversation history

debug: bool

Debug mode: output full LLM prompts and retain terminal history

Context

Generate codebase context for AI prompts

Provides structural and organizational context about the project to help LLMs understand project layout. Use with rfx ask --additional-context.

By default (no flags), shows all context types. Use individual flags to select specific context types.

Examples: rfx context # Full context (all types) rfx context –path services/backend # Full context for monorepo subdirectory rfx context –framework –entry-points # Specific context types only rfx context –structure –depth 5 # Deep directory tree

Use with semantic queries

rfx ask “find auth” –additional-context “$(rfx context –framework)”

Fields

structure: bool

Show directory structure (enabled by default)

path: Option<String>

Focus on specific directory path

file_types: bool

Show file type distribution (enabled by default)

project_type: bool

Detect project type (CLI/library/webapp/monorepo)

framework: bool

Detect frameworks and conventions

entry_points: bool

Show entry point files

test_layout: bool

Show test organization pattern

config_files: bool

List important configuration files

depth: usize

Tree depth for –structure (default: 1)

json: bool

Output as JSON

IndexSymbolsInternal

Internal command: Run background symbol indexing (hidden from help)

Fields

cache_dir: PathBuf

Cache directory path

Trait Implementations

impl Debug for Command

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

Formats the value using the given formatter.

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