home / skills / scarletkc / vexor / vexor-cli

vexor-cli skill

safe

This skill helps you locate implementation and loading points across large codebases by using vexor to perform intent-based file discovery.

npx playbooks add skill scarletkc/vexor --skill vexor-cli

Review the files below or copy the command above to add this skill to your agents.

Files (2)

SKILL.md

2.7 KB

---
name: vexor-cli
description: Semantic file discovery via `vexor`. Use whenever locating where something is implemented/loaded/defined in a medium or large repo, or when the file location is unclear. Prefer this over manual browsing.
---

# Vexor CLI Skill

## Goal

Find files by intent (what they do), not exact text.

## Use It Like This

- Use `vexor` first for intent-based file discovery.
- If `vexor` is missing, follow [references/install-vexor.md](references/install-vexor.md).

## Command

```bash
vexor "<QUERY>" [--path <ROOT>] [--mode <MODE>] [--ext .py,.md] [--exclude-pattern <PATTERN>] [--top 5] [--format rich|porcelain|porcelain-z]
```

## Common Flags

- `--path/-p`: root directory (default: current dir)
- `--mode/-m`: indexing/search strategy
- `--ext/-e`: limit file extensions (e.g., `.py,.md`)
- `--exclude-pattern`: exclude paths by gitignore-style pattern (repeatable; `.js` → `**/*.js`)
- `--top/-k`: number of results
- `--include-hidden`: include dotfiles
- `--no-respect-gitignore`: include ignored files
- `--no-recursive`: only the top directory
- `--format`: `rich` (default) or `porcelain`/`porcelain-z` for scripts
- `--no-cache`: in-memory only, do not read/write index cache

## Modes (pick the cheapest that works)

- `auto`: routes by file type (default)
- `name`: filename-only (fastest)
- `head`: first lines only (fast)
- `brief`: keyword summary (good for PRDs)
- `code`: code-aware chunking for `.py/.js/.ts` (best default for codebases)
- `outline`: Markdown headings/sections (best for docs)
- `full`: chunk full file contents (slowest, highest recall)

## Troubleshooting

- Need ignored or hidden files: add `--include-hidden` and/or `--no-respect-gitignore`.
- Scriptable output: use `--format porcelain` (TSV) or `--format porcelain-z` (NUL-delimited).
- Get detailed help: `vexor search --help`.
- Config issues: `vexor doctor` or `vexor config --show` diagnoses API, cache, and connectivity (tell the user to set up).

## Examples

```bash
# Find CLI entrypoints / commands
vexor search "typer app commands" --top 5
```

```bash
# Search docs by headings/sections
vexor search "user authentication flow" --path docs --mode outline --ext .md --format porcelain
```

```bash
# Locate config loading/validation logic
vexor search "config loader" --path . --mode code --ext .py
```

```bash
# Exclude tests and JavaScript files
vexor search "config loader" --path . --exclude-pattern tests/** --exclude-pattern .js
```

## Tips

- First time search will index files (may take a minute). Subsequent searches are fast. Use longer timeouts if needed.
- Results return similarity ranking, exact file location, line numbers, and matching snippet preview.
- Combine `--ext` with `--exclude-pattern` to focus on a subset (exclude rules apply on top).

Overview

This skill provides a CLI for semantic file discovery using vexor. It finds where behavior is implemented, loaded, or documented across medium to large repositories by searching intent instead of literal text. Use it to quickly locate files, function definitions, configs, and relevant doc sections without manual browsing.

How this skill works

vexor indexes files into embedding-backed vectors and searches by semantic similarity to your query. You run vexor search "<QUERY>" with optional flags to scope by path, file extensions, or search mode. Results include similarity scores, file paths, line numbers, and snippet previews for quick inspection.

When to use it

Locating where a feature, command, or config is implemented in a large repo
Finding documentation sections or headings relevant to a user flow
Discovering where files load or validate configuration data
Rapidly narrowing candidates before opening files or creating PRs
Scripting automated scans for files that match an intent across projects

Best practices

Start with a short intent phrase rather than exact code; vexor is semantic
Pick the cheapest mode that returns useful results (auto → code → full) to save time
Use --ext to limit languages and --exclude-pattern to remove noisy paths
Use --format porcelain or porcelain-z for reliable scripting output
Run vexor once to build the index; subsequent searches are much faster

Example use cases

Find CLI entrypoints: vexor search "typer app commands" --top 5
Locate config loading/validation: vexor search "config loader" --path . --mode code --ext .py
Search docs by headings: vexor search "user authentication flow" --path docs --mode outline --ext .md --format porcelain
Exclude tests and noise: vexor search "config loader" --path . --exclude-pattern tests/** --exclude-pattern .js
Scripted pipelines: use --format porcelain-z for NUL-delimited output in automation

FAQ

What mode should I pick?

Start with auto. If results miss code structure, try code. Use outline for docs and full only when you need maximum recall.

How do I include hidden or gitignored files?

Add --include-hidden to include dotfiles and --no-respect-gitignore to index files ignored by git.