# Hermes Agent Codebase Packing Tool Usage Guide (repomix-rs High-Performance Edition)

> Source: <https://dev.to/sopaco/hermes-agent-codebase-packing-tool-usage-guide-repomix-rs-high-performance-edition-3hko>
> Published: 2026-06-22 01:59:35+00:00

This is the official recommended usage guide for repomix-rs— repomix-rs is a high-performance Rust rewriting of the original Repomix (TypeScript), fully compatible with the original usage pattern, and Faster, Safer, and better suited for AI Agent scenarios.

repomix-rs is a tool that packages an entire codebase into a single, AI-friendly file. It works seamlessly with all major LLM application scenarios including Hermes Agent, Claude, ChatGPT, and Gemini. Through repomix-rs, your codebase is presented to AI in a structured, token-controllable format, enabling AI to perform code reviews, documentation generation, and vulnerability audits more accurately.

Compared to the original Repomix, repomix-rs rewrites all core logic in Rust, bringing a qualitative leap in performance, security, and embedding capabilities.

| Feature | repomix-rs (Rust) | Original Repomix (TypeScript) |
|---|---|---|
| Core Language | Rust | TypeScript |
| Runtime Speed |
Millisecond-level (parallel file scanning) |
Second-level (single-threaded Node.js) |
| Memory Safety | Compile-time guaranteed | Runtime checking |
| Built-in MCP Support | ✅ Official MCP Server included | ❌ Additional configuration required |
| Secretlint Integration | ✅ | ✅ |
| Tree-sitter | ✅ 10 languages | ✅ 10 languages |
| Token Counting | tiktoken-rs (`o200k_base` ) |
tiktoken (JS) |
| Remote Repository Packing | ✅ git clone + cleanup | ✅ |
| Parallel Processing | rayon + tokio | No parallelism |

Have you noticed a trend? **More and more developer ecosystem infrastructure is moving from TypeScript/Node.js to Rust.** This is no accident — Rust's language characteristics are a perfect match for the demands of the AI era:

[Rust-based high-performance runtime Bun](https://blog.csdn.net/weixin_45541665/article/details/161105498) uses Rust to rewrite the JavaScript engine, delivering:

Bun's success proves the **feasibility of Rust as a JS engine底层**, and repomix-rs leverages Rust's high-performance characteristics to achieve a repomix rewrite.

[How Vite ditched Webpack and used Rust to refactor frontend builds](https://zhuanlan.zhihu.com/p/2017213814882463972) Webpack was the ruler of frontend builds, but it suffered from:

The Vue.js team decided to ditch Webpack and rewrite Vite in Rust:

Vite's success proves that **Rust is the core choice for the next generation of frontend build engines**.

Open your terminal, navigate to the project root directory, and execute any of the following:

```
# Method 1: Run with npx (no global installation needed)
npx repomix-rs .

# Method 2: Install globally then run directly
npm install -g repomix-rs
repomix .

# After the terminal outputs a result, send it to Hermes with: "Please read this first"
```

After execution, an output file (default `repomix-output.xml`

) will be generated in the current directory. Drag that file into the Hermes Agent chat window and send the message: **"Please read this project structure file first"**.

💡

Why repomix-rs?In AI Agent scenarios like Hermes Agent, we recommend the Rust version repomix-rs over the TypeScript original:

Smaller image size: Rust binary ~15MB vs Node.js runtime 50+MBFaster startup: Rust ~0.05s vs Node.js ~200msSmaller memory footprint: Rust ~50MB vs Node.js ~150MBBetter native MCP support: repomix-rs includes a built-in MCP Server

This is a technology choice problem— The success of Bun and Vite has already proven:

In the AI era, Rust is the better infrastructure choice.

No cloning required — one command to pack a remote GitHub repository:

```
npx repomix-rs --remote https://github.com/username/project-name
```

Specify a branch (safer):

```
npx repomix-rs --remote https://github.com/username/project-name --branch main
```

repomix-rs's remote packing is based on the system

`git`

command. The first run pulls the full repository snapshot.

If git is unavailable, this step is skipped with a warning and the main process continues uninterrupted.

Create a `.repomixrc`

configuration file:

```
{
  "include": ["src/**/*", "tests/**/*", "pyproject.toml", "README.md"],
  "exclude": ["**/*.log", "**/dist/**", "**/.git/**", "node_modules/**"]
}
```

Enable compression (extracts function signatures, compression ratio up to 50%-90%):

```
npx repomix-rs --compress --remove-comments --remove-empty-lines .
```

Include only specific language files and ignore test directories:

```
npx repomix-rs --include "*.rs,*.toml,Cargo.*" --ignore "target/**,tests/**" .
```

repomix-rs supports four output formats, switchable via the `--style`

parameter:

```
npx repomix-rs --style markdown --output output.md .
npx repomix-rs --style json --output output.json .
npx repomix-rs --style plain --output output.txt .
```

Hermes Agent does not automatically scan attachment content — it must be triggered manually. The correct process is:

`npx repomix-rs .`

to generate the packed file`repomix-output.xml`

(or `.md`

/ `.txt`

) into the Hermes Agent chat windowNote: Hermes only supports

`.md`

/`.xml`

/`.txt`

plain text files.

If you accidentally send a compressed archive or binary file, the AI side will not be able to parse it.

repomix-rs includes a built-in MCP Server that can be directly embedded into any AI Agent supporting the Model Context Protocol (including Hermes Agent, Cursor, and Claude Desktop):

```
repomix --mcp
```

After startup, the following MCP tools are exposed:

| Tool Name | Purpose |
|---|---|
`pack_codebase` |
Pack a local codebase directory |
`pack_remote_repository` |
Fetch and pack a remote Git repository |
`read_repomix_output` |
Read a previously generated repomix output file |
`grep_repomix_output` |
Search content within the output file |

Edit `~/Library/Application Support/Claude/claude_desktop_config.json`

:

```
{
  "mcpServers": {
    "repomix": {
      "command": "repomix",
      "args": ["--mcp"]
    }
  }
}
```

Go to Settings → MCP → Add new global MCP server:

```
Command: repomix
Args: --mcp
```

| Scenario | Original Repomix (Node.js) | repomix-rs (Rust) | Speedup |
|---|---|---|---|
| Small-to-medium projects (< 500 files) | ~3-8 seconds | ~0.3-0.8 seconds | 5-10× |
| Medium projects (500-5,000 files) | ~30-120 seconds | ~2-8 seconds | 15-40× |
| Large projects (5,000+ files) | Risk of OOM | Stable completion | Unbounded |
| Remote repository packing | Slow (Node.js clone) | Extremely fast (git + rayon) | 10-20× |

`repomix --mcp`

directly integrates with Hermes, Claude, Cursor, and more with no additional wrapper layer needed.`tiktoken-rs`

uses OpenAI's official `o200k_base`

encoding, consistent with GPT-4o, with far less counting bias than the JS version.**Q: What's the difference between npx repomix-rs and npx repomix?**

A: `npx repomix-rs`

invokes repomix-rs (Rust implementation), which is faster and more stable; `npx repomix`

invokes the original TypeScript implementation. Their command-line parameters are largely compatible.

**Q: Can repomix-rs handle my Node.js project?**

A: Absolutely — it is language-agnostic. repomix-rs identifies file types through file extensions and glob rules.

**Q: How do I verify that exclude rules are working?**

A: After generating the output, run a grep check: `grep -i "secrets\|password\|API_KEY" repomix-output.xml`

. If sensitive words appear, check whether your glob rules are correct (e.g., `**/.env`

, not `.env`

).

**Q: Does repomix-rs support Windows?**

A: Yes, Windows x64 precompiled binaries have been released. The npm package also covers Linux/macOS/Windows.

👉 [https://github.com/sopaco/repomix-rs](https://github.com/sopaco/repomix-rs)

*This guide is adapted from the original Hermes Agent Repomix usage guide, with all content migrated to repomix-rs.*

*repomix-rs project: https://github.com/sopaco/repomix-rs*

`repomix-rs`

, CLI command: `repomix`