Repomix

Use Repomix online! 👉 repomix.com

Need discussion? Join us on Discord!
Share your experience and tips
Stay updated on new features
Get help with configuration and usage

[npm] [npm] [Actions Status] [codecov] [CodeRabbit Pull Request Reviews] [Sponsors] [Discord]

[DeepWiki]

📦 Repomix is a powerful tool that packs your entire repository into a single, AI-friendly file.
It is perfect for when you need to feed your codebase to Large Language Models (LLMs) or other AI tools like Claude, ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok, and more.

Please consider sponsoring me.

[Sponsor]

[Sponsors]

🏆 Open Source Awards Nomination

We're honored! Repomix has been nominated for the Powered by AI category at the JSNation Open Source Awards 2025.

This wouldn't have been possible without all of you using and supporting Repomix. Thank you!

🎉 New: Repomix Website & Discord Community!

• Try Repomix in your browser at repomix.com
• Join our Discord Server for support and discussion

We look forward to seeing you there!

🌟 Features

• AI-Optimized: Formats your codebase in a way that's easy for AI to understand and process.
• Token Counting: Provides token counts for each file and the entire repository, useful for LLM context limits.
• Simple to Use: You need just one command to pack your entire repository.
• Customizable: Easily configure what to include or exclude.
• Git-Aware: Automatically respects your .gitignore, .ignore, and .repomixignore files.
• Security-Focused: Incorporates Secretlint to detect files matching known credential formats and leave them out of the output.
• Code Compression: The --compress option uses Tree-sitter to extract key code elements, reducing token count while preserving structure.

🚀 Quick Start

Using the CLI Tool >_

You can try Repomix instantly in your project directory without installation:

npx repomix@latest

Or install globally for repeated use:

# Install using npmnpm install -g repomix
# Alternatively using yarnyarn global add repomix
# Alternatively using bunbun add -g repomix
# Alternatively using Homebrew (macOS/Linux)brew install repomix
# Then run in any project directoryrepomix

That's it! Repomix will generate a repomix-output.xml file in your current directory, containing your entire repository in an AI-friendly format.

You can then send this file to an AI assistant with a prompt like:

This file contains all the files in the repository combined into one.I want to refactor the code, so please review it first.

[Repomix File Usage 1]

When you propose specific changes, the AI might be able to generate code accordingly. With features like Claude's Artifacts, you could potentially output multiple files, allowing for the generation of multiple interdependent pieces of code.

[Repomix File Usage 2]

Happy coding! 🚀

Using The Website 🌐

Want to try it quickly? Visit the official website at repomix.com. Simply enter your repository name, fill in any optional details, and click the Pack button to see your generated output.

Available Options

The website offers several convenient features:

• Customizable output format (XML, Markdown, or Plain Text)
• Instant token count estimation
• Much more!

Using The Browser Extension 🧩

Get instant access to Repomix directly from any GitHub repository! Our Chrome extension adds a convenient "Repomix" button to GitHub repository pages.

[Repomix Browser Extension]

Install

• Chrome Extension: Repomix - Chrome Web Store
• Firefox Add-on: Repomix - Firefox Add-ons

Features

• One-click access to Repomix for any GitHub repository
• More exciting features coming soon!

Using The VSCode Extension ⚡️

A community-maintained VSCode extension called Repomix Runner (created by massdo) lets you run Repomix right inside your editor with just a few clicks. Run it on any folder, manage outputs seamlessly, and control everything through VSCode's intuitive interface.

Want your output as a file or just the content? Need automatic cleanup? This extension has you covered. Plus, it works smoothly with your existing repomix.config.json.

Try it now on the VSCode Marketplace! Source code is available on GitHub.

Alternative Tools 🛠️

If you're using Python, you might want to check out Gitingest, which is better suited for Python ecosystem and data science workflows: https://github.com/cyclotruc/gitingest

📊 Usage

To pack your entire repository:

repomix

To pack a specific directory:

repomix path/to/directory

To pack specific files or directories using glob patterns:

repomix --include "src/**/*.ts,**/*.md"

To exclude specific files or directories:

repomix --ignore "**/*.log,tmp/"

To pack a remote repository:

repomix --remote https://github.com/yamadashy/repomix
# You can also use GitHub shorthand:repomix --remote yamadashy/repomix
# You can specify the branch name, tag, or commit hash:repomix --remote https://github.com/yamadashy/repomix --remote-branch main
# Or use a specific commit hash:repomix --remote https://github.com/yamadashy/repomix --remote-branch 935b695
# Another convenient way is specifying the branch's URLrepomix --remote https://github.com/yamadashy/repomix/tree/main
# Commit's URL is also supportedrepomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1

To pack files from a file list (pipe via stdin):

# Using find commandfind src -name "*.ts" -type f | repomix --stdin
# Using git to get tracked filesgit ls-files "*.ts" | repomix --stdin
# Using grep to find files containing specific contentgrep -l "TODO" **/*.ts | repomix --stdin
# Using ripgrep to find files with specific contentrg -l "TODO|FIXME" --type ts | repomix --stdin
# Using ripgrep (rg) to find filesrg --files --type ts | repomix --stdin
# Using sharkdp/fd to find filesfd -e ts | repomix --stdin
# Using fzf to select from all filesfzf -m | repomix --stdin
# Interactive file selection with fzffind . -name "*.ts" -type f | fzf -m | repomix --stdin
# Using ls with glob patternsls src/**/*.ts | repomix --stdin
# From a file containing file pathscat file-list.txt | repomix --stdin
# Direct input with echoecho -e "src/index.ts\nsrc/utils.ts" | repomix --stdin

The --stdin option allows you to pipe a list of file paths to Repomix, giving you ultimate flexibility in selecting which files to pack.

When using --stdin, the specified files are effectively added to the include patterns. This means that the normal include and ignore behavior still applies - files specified via stdin will still be excluded if they match ignore patterns.

[!NOTE] When using --stdin, file paths can be relative or absolute, and Repomix will automatically handle path resolution and deduplication.

To include git logs in the output:

# Include git logs with default count (50 commits)repomix --include-logs
# Include git logs with specific commit countrepomix --include-logs --include-logs-count 10
# Combine with diffs for comprehensive git contextrepomix --include-logs --include-diffs

The git logs include commit dates, messages, and file paths for each commit, providing valuable context for AI analysis of code evolution and development patterns.

To compress the output:

repomix --compress
# You can also use it with remote repositories:repomix --remote yamadashy/repomix --compress

To initialize a new configuration file (repomix.config.json):

repomix --init

Once you have generated the packed file, you can use it with Generative AI tools like ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok, and more.

Docker Usage 🐳

You can also run Repomix using Docker.
This is useful if you want to run Repomix in an isolated environment or prefer using containers.

Basic usage (current directory):

docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix

To pack a specific directory:

docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory

Process a remote repository and output to a output directory:

docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix

Prompt Examples

Once you have generated the packed file with Repomix, you can use it with AI tools like ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok, and more. Here are some example prompts to get you started:

Code Review and Refactoring

For a comprehensive code review and refactoring suggestions:

This file contains my entire codebase. Please review the overall structure and suggest any improvements or refactoring opportunities, focusing on maintainability and scalability.

Documentation Generation

To generate project documentation:

Based on the codebase in this file, please generate a detailed README.md that includes an overview of the project, its main features, setup instructions, and usage examples.

Test Case Generation

For generating test cases:

Analyze the code in this file and suggest a comprehensive set of unit tests for the main functions and classes. Include edge cases and potential error scenarios.

Code Quality Assessment

Evaluate code quality and adherence to best practices:

Review the codebase for adherence to coding best practices and industry standards. Identify areas where the code could be improved in terms of readability, maintainability, and efficiency. Suggest specific changes to align the code with best practices.

Library Overview

Get a high-level understanding of the library

This file contains the entire codebase of library. Please provide a comprehensive overview of the library, including its main purpose, key features, and overall architecture.

Feel free to modify these prompts based on your specific needs and the capabilities of the AI tool you're using.

Community Discussion

Check out our community discussion where users share:

• Which AI tools they're using with Repomix
• Effective prompts they've discovered
• How Repomix has helped them
• Tips and tricks for getting the most out of AI code analysis

Feel free to join the discussion and share your own experiences! Your insights could help others make better use of Repomix.

Output File Format

Repomix generates a single file with clear separators between different parts of your codebase.
To enhance AI comprehension, the output file begins with an AI-oriented explanation, making it easier for AI models to understand the context and structure of the packed repository.

XML Format (default)

The XML format structures the content in a hierarchical manner:

This file is a merged representation of the entire codebase, combining all repository files into a single document.
<file_summary>  (Metadata and usage AI instructions)</file_summary>
<directory_structure>src/cli/cliOutput.tsindex.ts
(...remaining directories)</directory_structure>
<files><file path="src/index.js">  // File contents here</file>
(...remaining files)</files>
<instruction>(Custom instructions from `output.instructionFilePath`)</instruction>

For those interested in the potential of XML tags in AI contexts:
https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags

When your prompts involve multiple components like context, instructions, and examples, XML tags can be a game-changer. They help Claude parse your prompts more accurately, leading to higher-quality outputs.

This means that the XML output from Repomix is not just a different format, but potentially a more effective way to feed your codebase into AI systems for analysis, code review, or other tasks.

Markdown Format

To generate output in Markdown format, use the --style markdown option:

repomix --style markdown

The Markdown format structures the content in a hierarchical manner:

This file is a merged representation of the entire codebase, combining all repository files into a single document.
# File Summary
(Metadata and usage AI instructions)
# Repository Structure
```src/  cli/    cliOutput.ts    index.ts```
(...remaining directories)
# Repository Files
## File: src/index.js
```// File contents here```
(...remaining files)
# Instruction
(Custom instructions from `output.instructionFilePath`)

This format provides a clean, readable structure that is both human-friendly and easily parseable by AI systems.

JSON Format

To generate output in JSON format, use the --style json option:

repomix --style json

The JSON format structures the content as a hierarchical JSON object with camelCase property names:

{  "fileSummary": {    "generationHeader": "This file is a merged representation of the entire codebase, combined into a single document by Repomix.",    "purpose": "This file contains a packed representation of the entire repository's contents...",    "fileFormat": "The content is organized as follows...",    "usageGuidelines": "- This file should be treated as read-only...",    "notes": "- Some files may have been excluded based on .gitignore, .ignore, and .repomixignore rules..."  },  "userProvidedHeader": "Custom header text if specified",  "directoryStructure": "src/\n  cli/\n    cliOutput.ts\n    index.ts\n  config/\n    configLoader.ts",  "files": {    "src/index.js": "// File contents here",    "src/utils.js": "// File contents here"  },  "instruction": "Custom instructions from instructionFilePath"}

This format is ideal for:

• Programmatic processing: Easy to parse and manipulate with JSON libraries
• API integration: Direct consumption by web services and applications
• AI tool compatibility: Structured format for machine learning and AI systems
• Data analysis: Straightforward extraction of specific information using tools like jq

Working with JSON Output Using jq

The JSON format makes it easy to extract specific information programmatically:

# List all file pathscat repomix-output.json | jq -r '.files | keys[]'
# Count total number of filescat repomix-output.json | jq '.files | keys | length'
# Extract specific file contentcat repomix-output.json | jq -r '.files["README.md"]'cat repomix-output.json | jq -r '.files["src/index.js"]'
# Find files by extensioncat repomix-output.json | jq -r '.files | keys[] | select(endswith(".ts"))'
# Get files containing specific textcat repomix-output.json | jq -r '.files | to_entries[] | select(.value | contains("function")) | .key'
# Extract directory structurecat repomix-output.json | jq -r '.directoryStructure'
# Get file summary informationcat repomix-output.json | jq '.fileSummary.purpose'cat repomix-output.json | jq -r '.fileSummary.generationHeader'
# Extract user-provided header (if exists)cat repomix-output.json | jq -r '.userProvidedHeader // "No header provided"'
# Create a file list with sizescat repomix-output.json | jq -r '.files | to_entries[] | "\(.key): \(.value | length) characters"'

Plain Text Format

To generate output in plain text format, use the --style plain option:

repomix --style plain

This file is a merged representation of the entire codebase, combining all repository files into a single document.
================================================================File Summary================================================================(Metadata and usage AI instructions)
================================================================Directory Structure================================================================src/  cli/    cliOutput.ts    index.ts  config/    configLoader.ts
(...remaining directories)
================================================================Files================================================================
================File: src/index.js================// File contents here
================File: src/utils.js================// File contents here
(...remaining files)
================================================================Instruction================================================================(Custom instructions from `output.instructionFilePath`)

Command Line Options

Basic Options

• -v, --version: Show version information and exit

CLI Input/Output Options

Repomix Output Options

File Selection Options

Remote Repository Options

Configuration Options

Security Options

• --no-security-check: Skip scanning for sensitive data like API keys and passwords

Token Count Options

• --token-count-encoding <encoding>: Tokenizer model for counting: o200k_base (GPT-4o), cl100k_base (GPT-3.5/4), etc. (default: o200k_base)
• --token-budget <number>: Fail with a non-zero exit code when the packed output exceeds N tokens. Useful as a guard in CI pipelines and agent workflows to keep output within a target model's context window. The output is still generated; only the exit code signals the overflow.

MCP

• --mcp: Run as Model Context Protocol server for AI tool integration
• --sandbox [dir]: (with --mcp) confine the MCP server's file tools to a workspace directory (defaults to the working directory; e.g. --sandbox path/to/project) — every path is relative to that root, absolute/host paths are refused, and remote packing, skill generation, and attaching external outputs are disabled.

Agent Skills Generation

Watch Mode

• -w, --watch: Watch for file changes and automatically re-pack. Debounces rapid changes (300ms) and logs a timestamp on each rebuild. Stop with Ctrl+C.

  Watch mode only works with local directories, so it cannot be combined with --remote, a positional remote repository URL, --stdout, --stdin, --split-output, --skill-generate, or --copy (whether set on the command line or in your config file).

Examples

# Basic usagerepomix
# Custom outputrepomix -o output.xml --style xml
# Output to stdoutrepomix --stdout > custom-output.txt
# Send output to stdout, then pipe into another command (for example, simonw/llm)repomix --stdout | llm "Please explain what this code does."
# Custom output with compressionrepomix --compress
# Process specific filesrepomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# Split output into multiple files (max size per part)repomix --split-output 20mb
# Remote repository with branchrepomix --remote https://github.com/user/repo/tree/main
# Remote repository with commitrepomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# Remote repository with shorthandrepomix --remote user/repo
# Watch mode — automatically re-pack on file changesrepomix --watchrepomix -w --include "src/**/*.ts"

Updating Repomix

To update a globally installed Repomix:

# Using npmnpm update -g repomix
# Using yarnyarn global upgrade repomix
# Using bunbun update -g repomix

Using npx repomix is generally more convenient as it always uses the latest version.

Remote Repository Processing

Repomix supports processing remote Git repositories without the need for manual cloning. This feature allows you to quickly analyze any public Git repository with a single command.

To process a remote repository, use the --remote option followed by the repository URL:

repomix --remote https://github.com/yamadashy/repomix

You can also use GitHub's shorthand format:

repomix --remote yamadashy/repomix

You can specify the branch name, tag, or commit hash:

# Using --remote-branch optionrepomix --remote https://github.com/yamadashy/repomix --remote-branch main
# Using branch's URLrepomix --remote https://github.com/yamadashy/repomix/tree/main

Or use a specific commit hash:

# Using --remote-branch optionrepomix --remote https://github.com/yamadashy/repomix --remote-branch 935b695
# Using commit's URLrepomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1

[!NOTE] For security, config files (repomix.config.*) in remote repositories are not loaded by default. This prevents untrusted repositories from executing code via config files. Your global config and CLI options are still applied. To trust a remote repository's config, use --remote-trust-config or set REPOMIX_REMOTE_TRUST_CONFIG=true — on an interactive terminal Repomix then shows that config and asks you to confirm before loading it. See Remote Repository Config Trust.

When using --config with --remote, an absolute path is required (e.g., --config /home/user/repomix.config.json).

Code Compression

The --compress option utilizes Tree-sitter to perform intelligent code extraction, focusing on essential function and class signatures while removing implementation details. This can help reduce token count while retaining important structural information.

repomix --compress

For example, this code:

import { ShoppingItem } from './shopping-item';
/** * Calculate the total price of shopping items */const calculateTotal = (  items: ShoppingItem[]) => {  let total = 0;  for (const item of items) {    total += item.price * item.quantity;  }  return total;}
// Shopping item interfaceinterface Item {  name: string;  price: number;  quantity: number;}

Will be compressed to:

import { ShoppingItem } from './shopping-item';⋮----/** * Calculate the total price of shopping items */const calculateTotal = (  items: ShoppingItem[]) => {⋮----// Shopping item interfaceinterface Item {  name: string;  price: number;  quantity: number;}

[!NOTE] This is an experimental feature that we'll be actively improving based on user feedback and real-world usage

Per-file Inclusion Levels (output.patterns)

While --compress applies one level to every file, output.patterns lets you control the detail level per glob from your config file. Each entry targets files by glob (matched the same way as include/ignore) and overrides the global output.compress setting for matching files:

{  "output": {    "compress": false, // global default acts as the catch-all    "patterns": [      { "pattern": "docs/**/*", "compress": true },      { "pattern": "website/**/*", "directoryStructureOnly": true }    ]  }}

There are three levels:

• Full content (default) — the file's full content is included.
• Compressed (compress: true) — the content is passed through the same Tree-sitter pipeline as --compress.
• Directory-structure-only (directoryStructureOnly: true) — the file is listed in the directory structure, but its content block is omitted from the output entirely.

Semantics:

• Patterns are evaluated in array order and the first matching pattern wins for a given file.
• A matched pattern's flags override the global output.compress setting. A pattern that matches without setting either flag forces full content for that file (useful for whitelisting files out of a global compress).
• directoryStructureOnly takes precedence over compress when both are set.
• If no pattern matches, the global behavior applies (full content, or compressed when output.compress is true).

This is a config-file-only option; there is no CLI flag for per-pattern levels.

Token Count Optimization

Understanding your codebase's token distribution is crucial for optimizing AI interactions. Use the --token-count-tree option to visualize token usage across your project:

repomix --token-count-tree

This displays a hierarchical view of your codebase with token counts:

🔢 Token Count Tree:────────────────────└── src/ (70,925 tokens)    ├── cli/ (12,714 tokens)    │   ├── actions/ (7,546 tokens)    │   └── reporters/ (990 tokens)    └── core/ (41,600 tokens)        ├── file/ (10,098 tokens)        └── output/ (5,808 tokens)

You can also set a minimum token threshold to focus on larger files:

repomix --token-count-tree 1000  # Only show files/directories with 1000+ tokens

This helps you:

• Identify token-heavy files that might exceed AI context limits
• Optimize file selection using --include and --ignore patterns
• Plan compression strategies by targeting the largest contributors
• Balance content vs. context when preparing code for AI analysis

Splitting Output for Large Codebases

When working with large codebases, the packed output may exceed file size limits imposed by some AI tools (e.g., Google AI Studio's 1MB limit). Use --split-output to automatically split the output into multiple files:

repomix --split-output 1mb

This generates numbered files like:

• repomix-output.1.xml
• repomix-output.2.xml
• repomix-output.3.xml

Size can be specified with units: 500kb, 1mb, 2mb, 1.5mb, etc. Decimal values are supported.

[!NOTE] Files are grouped by top-level directory to maintain context. A single file or directory will never be split across multiple output files.

MCP Server Integration

Repomix supports the Model Context Protocol (MCP), allowing AI assistants to directly interact with your codebase. When run as an MCP server, Repomix provides tools that enable AI assistants to package local or remote repositories for analysis without requiring manual file preparation.

repomix --mcp

Sandbox Mode

By default the MCP server can read any path the host user can. That is convenient for a trusted local assistant, but too broad when the server is exposed to an untrusted client or agent. The --sandbox flag confines the server's file tools to a single workspace directory:

# Confine to the current working directoryrepomix --mcp --sandbox
# Confine to a specific directoryrepomix --mcp --sandbox path/to/project

When sandbox mode is on, every path is relative to the workspace root (absolute, ~, .., and Windows drive/UNC paths are refused, as are paths that resolve outside the root through symlinks), config files are not loaded, and only the read-only, root-confined tools are registered; remote packing, skill generation, and attaching external outputs are disabled. The raw file tools (file_system_read_file, file_system_read_directory) are available only in sandbox mode, where the workspace root bounds what they can reach. This is an application-level confinement of the tool surface, not an OS-level sandbox.

Without --sandbox, pack_codebase loads and trusts the repomix.config.* in the directory it packs, the same as running repomix there from the command line. A config file is code: it can run when loaded and read files outside the repository. If your assistant may pack directories you don't trust, such as cloned third-party repositories, use --sandbox. See the MCP Server guide for details.

Configuring MCP Servers

To use Repomix as an MCP server with AI assistants like Claude, you need to configure the MCP settings:

For VS Code:

You can install the Repomix MCP server in VS Code using one of these methods:

1. Using the Install Badge:

[Install in VS Code] [Install in VS Code Insiders]

2. Using the Command Line:

code --add-mcp '{"name":"repomix","command":"npx","args":["-y","repomix","--mcp"]}'

For VS Code Insiders:

code-insiders --add-mcp '{"name":"repomix","command":"npx","args":["-y","repomix","--mcp"]}'

For Cline (VS Code extension):

Edit the cline_mcp_settings.json file:

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

For Cursor:

In Cursor, add a new MCP server from Cursor Settings > MCP > + Add new global MCP server with a configuration similar to Cline.

For Claude Desktop:

Edit the claude_desktop_config.json file with similar configuration to Cline's config.

For Claude Code:

To configure Repomix as an MCP server in Claude Code, use the following command:

claude mcp add repomix -- npx -y repomix --mcp

Alternatively, you can use the official Repomix plugins (see Claude Code Plugins section below).

Using Docker instead of npx:

You can use Docker as an alternative to npx for running Repomix as an MCP server:

{  "mcpServers": {    "repomix-docker": {      "command": "docker",      "args": [        "run",        "-i",        "--rm",        "ghcr.io/yamadashy/repomix",        "--mcp"      ]    }  }}

Once configured, your AI assistant can directly use Repomix's capabilities to analyze codebases without manual file preparation, making code analysis workflows more efficient.

Available MCP Tools

When running as an MCP server, Repomix provides the following tools:

1. pack_codebase: Package a local code directory into a consolidated XML file for AI analysis

• Parameters:
  • directory: Absolute path to the directory to pack
  • compress: (Optional, default: false) Enable Tree-sitter compression to extract essential code signatures and structure while removing implementation details. Reduces token usage by ~70% while preserving semantic meaning. Generally not needed since grep_repomix_output allows incremental content retrieval. Use only when you specifically need the entire codebase content for large repositories.
  • includePatterns: (Optional) Specify files to include using fast-glob patterns. Multiple patterns can be comma-separated (e.g., "/*.{js,ts}", "src/,docs/**"). Only matching files will be processed.
  • ignorePatterns: (Optional) Specify additional files to exclude using fast-glob patterns. Multiple patterns can be comma-separated (e.g., "test/,*.spec.js", "node_modules/,dist/**"). These patterns supplement .gitignore, .ignore, and built-in exclusions.
  • outputPatterns: (Optional) Per-file inclusion levels, mirroring the config-file output.patterns option. An array of { pattern, compress?, directoryStructureOnly? } entries; the first matching pattern wins, directoryStructureOnly takes precedence over compress, and a match with neither flag forces full content (useful for exempting files from a global compress). Overrides any output.patterns from the target repository's repomix.config.json.
  • topFilesLength: (Optional, default: 10) Number of largest files by size to display in the metrics summary for codebase analysis.

2. attach_packed_output: Attach an existing Repomix packed output file for AI analysis

• Parameters:
  • path: Path to a directory containing repomix-output.xml or direct path to a packed repository XML file
  • topFilesLength: (Optional, default: 10) Number of largest files by size to display in the metrics summary
• Features:
  • Accepts either a directory containing a repomix-output.xml file or a direct path to an XML file
  • Registers the file with the MCP server and returns the same structure as the pack_codebase tool
  • Provides access to existing packed outputs without requiring re-processing
  • Useful for working with previously generated packed repositories

3. pack_remote_repository: Fetch, clone, and package a GitHub repository into a consolidated XML file for AI analysis

• Parameters:
  • remote: GitHub repository URL or user/repo format (e.g., "yamadashy/repomix", "https://github.com/user/repo", or "https://github.com/user/repo/tree/branch")
  • compress: (Optional, default: false) Enable Tree-sitter compression to extract essential code signatures and structure while removing implementation details. Reduces token usage by ~70% while preserving semantic meaning. Generally not needed since grep_repomix_output allows incremental content retrieval. Use only when you specifically need the entire codebase content for large repositories.
  • includePatterns: (Optional) Specify files to include using fast-glob patterns. Multiple patterns can be comma-separated (e.g., "/*.{js,ts}", "src/,docs/**"). Only matching files will be processed.
  • ignorePatterns: (Optional) Specify additional files to exclude using fast-glob patterns. Multiple patterns can be comma-separated (e.g., "test/,*.spec.js", "node_modules/,dist/**"). These patterns supplement .gitignore, .ignore, and built-in exclusions.
  • outputPatterns: (Optional) Per-file inclusion levels, mirroring the config-file output.patterns option. An array of { pattern, compress?, directoryStructureOnly? } entries; the first matching pattern wins, directoryStructureOnly takes precedence over compress, and a match with neither flag forces full content (useful for exempting files from a global compress).
  • topFilesLength: (Optional, default: 10) Number of largest files by size to display in the metrics summary for codebase analysis.

4. read_repomix_output: Read the contents of a Repomix-generated output file. Supports partial reading with line range specification for large files.

• Parameters:
  • outputId: ID of the Repomix output file to read
  • startLine: (Optional) Starting line number (1-based, inclusive). If not specified, reads from beginning.
  • endLine: (Optional) Ending line number (1-based, inclusive). If not specified, reads to end.
• Features:
  • Specifically designed for web-based environments or sandboxed applications
  • Retrieves the content of previously generated outputs using their ID
  • Provides access to packed codebase without requiring file system access
  • Supports partial reading for large files

5. grep_repomix_output: Search for patterns in a Repomix output file using grep-like functionality with JavaScript RegExp syntax

• Parameters:
  • outputId: ID of the Repomix output file to search
  • pattern: Search pattern (JavaScript RegExp regular expression syntax)
  • contextLines: (Optional, default: 0) Number of context lines to show before and after each match. Overridden by beforeLines/afterLines if specified.
  • beforeLines: (Optional) Number of context lines to show before each match (like grep -B). Takes precedence over contextLines.
  • afterLines: (Optional) Number of context lines to show after each match (like grep -A). Takes precedence over contextLines.
  • ignoreCase: (Optional, default: false) Perform case-insensitive matching
• Features:
  • Uses JavaScript RegExp syntax for powerful pattern matching
  • Supports context lines for better understanding of matches
  • Allows separate control of before/after context lines
  • Case-sensitive and case-insensitive search options

6. file_system_read_file: Read a file inside the sandbox workspace. Only available in sandbox mode (--sandbox), where the workspace root bounds what it can reach.

• Parameters:
  • path: Path to the file to read, relative to the workspace root (e.g. src/index.ts)
• Notes:
  • Not registered without --sandbox
  • Content matching known secret formats (Secretlint) is refused as an additional heuristic safeguard — the access boundary is the workspace root, not the scan

7. file_system_read_directory: List the contents of a directory inside the sandbox workspace. Only available in sandbox mode (--sandbox).

• Parameters:
  • path: Path to the directory to list, relative to the workspace root (e.g. . or src)
• Features:
  • Shows files and directories with clear indicators ([FILE] or [DIR])
  • Useful for exploring project structure and understanding codebase organization

Claude Code Plugins

Repomix provides official plugins for Claude Code that integrate seamlessly with the AI-powered development environment.

Installation

1. Add the Repomix plugin marketplace:

/plugin marketplace add yamadashy/repomix

2. Install plugins:

# Install MCP server plugin (recommended foundation)/plugin install repomix-mcp@repomix
# Install commands plugin (extends functionality)/plugin install repomix-commands@repomix
# Install repository explorer plugin (AI-powered analysis)/plugin install repomix-explorer@repomix

Note: The repomix-mcp plugin is recommended as a foundation. The repomix-commands plugin provides convenient slash commands, while repomix-explorer adds AI-powered analysis capabilities. While you can install them independently, using all three provides the most comprehensive experience.

Alternatively, use the interactive plugin installer:

/plugin

This will open an interactive interface where you can browse and install available plugins.

Available Plugins

1. repomix-mcp (MCP Server Plugin)

Foundation plugin that provides AI-powered codebase analysis through MCP server integration.

Features:

• Pack local and remote repositories
• Read and search packed outputs
• Automatic Tree-sitter compression (~70% token reduction)

2. repomix-commands (Slash Commands Plugin)

Provides convenient slash commands for quick operations with natural language support.

Available Commands:

• /repomix-commands:pack-local - Pack local codebase with various options
• /repomix-commands:pack-remote - Pack and analyze remote GitHub repositories

Example usage:

/repomix-commands:pack-localPack this project as markdown with compression
/repomix-commands:pack-remote yamadashy/repomixPack only TypeScript files from the yamadashy/repomix repository

3. repomix-explorer (AI Analysis Agent Plugin)

AI-powered repository analysis agent that intelligently explores codebases using Repomix CLI.

Features:

• Natural language codebase exploration and analysis
• Intelligent pattern discovery and code structure understanding
• Incremental analysis using grep and targeted file reading
• Automatic context management for large repositories

Available Commands:

• /repomix-explorer:explore-local - Analyze local codebase with AI assistance
• /repomix-explorer:explore-remote - Analyze remote GitHub repositories with AI assistance

Example usage:

/repomix-explorer:explore-local ./srcFind all authentication-related code
/repomix-explorer:explore-remote facebook/reactShow me the main component architecture

The agent automatically:

1. Runs npx repomix@latest to pack the repository
2. Uses Grep and Read tools to efficiently search the output
3. Provides comprehensive analysis without consuming excessive context

Benefits

• Seamless Integration: Claude can directly analyze codebases without manual preparation
• Natural Language: Use conversational commands instead of remembering CLI syntax
• Always Latest: Automatically uses npx repomix@latest for up-to-date features
• Secret Scanning: Secretlint flags files matching known credential formats so they are left out of the output
• Token Optimization: Tree-sitter compression for large codebases

For more details, see the plugin documentation in the .claude/plugins/ directory.

Agent Skills Generation

Repomix can generate Claude Agent Skills format output, creating a structured Skills directory that can be used as a reusable codebase reference for AI assistants. This feature is particularly powerful when you want to reference implementations from remote repositories.

Basic Usage

# Generate Skills from local directoryrepomix --skill-generate
# Generate with custom Skills namerepomix --skill-generate my-project-reference
# Generate with a custom project name in Skills descriptionsrepomix --skill-generate --skill-project-name "My Project"
# Generate from remote repositoryrepomix --remote https://github.com/user/repo --skill-generate

When you run the command, Repomix prompts you to choose where to save the Skills:

1. Personal Skills (~/.claude/skills/) - Available across all projects on your machine
2. Project Skills (.claude/skills/) - Shared with your team via git

Non-Interactive Usage

For CI pipelines and automation scripts, you can skip all interactive prompts using --skill-output and --force:

# Specify output directory directlyrepomix --skill-generate --skill-output ./my-skills
# Skip overwrite confirmation with --forcerepomix --skill-generate --skill-output ./my-skills --force
# Full non-interactive examplerepomix --remote user/repo --skill-generate my-skill --skill-output ./output --force

Generated Structure

The Skills are generated with the following structure:

.claude/skills/<skill-name>/├── SKILL.md                 # Main Skills metadata & documentation└── references/    ├── summary.md           # Purpose, format, and statistics    ├── project-structure.md # Directory tree with line counts    ├── files.md             # All file contents (grep-friendly)    └── tech-stacks.md       # Languages, frameworks, dependencies

What's Included

• SKILL.md: Contains Skills metadata, file/line/token counts, overview, and usage instructions
• summary.md: Explains the Skills' purpose, usage guidelines, and provides statistics breakdown by file type and language
• project-structure.md: Directory tree with line counts per file for easy file discovery
• files.md: All file contents with syntax highlighting headers, optimized for grep-friendly searching
• tech-stacks.md: Auto-detected tech stack per package from dependency files (package.json, requirements.txt, Cargo.toml, etc.)

Auto-Generated Skills Names

If no name is provided, Repomix auto-generates one:

repomix src/ --skill-generate                # → repomix-reference-srcrepomix --remote user/repo --skill-generate  # → repomix-reference-reporepomix --skill-generate CustomName          # → custom-name (normalized to kebab-case)

Integration with Repomix Features

Skills generation respects all standard Repomix options:

# Generate Skills with file filteringrepomix --skill-generate --include "src/**/*.ts" --ignore "**/*.test.ts"
# Generate Skills with compressionrepomix --skill-generate --compress
# Generate Skills from remote repositoryrepomix --remote yamadashy/repomix --skill-generate

Repomix Explorer Skill (Agent Skills)

Repomix provides a ready-to-use Repomix Explorer skill that enables AI coding assistants to analyze and explore codebases using Repomix CLI. This skill is designed to work with various AI tools including Claude Code, Cursor, Codex, GitHub Copilot, and more.

Quick Install

For Claude Code, install the official Repomix Explorer plugin:

/plugin marketplace add yamadashy/repomix/plugin install repomix-explorer@repomix

For Codex, Cursor, OpenClaw, and other Agent Skills-compatible assistants, install the standalone skill with the Skills CLI:

npx skills add yamadashy/repomix --skill repomix-explorer

To target a specific assistant, pass --agent:

npx skills add yamadashy/repomix --skill repomix-explorer --agent codexnpx skills add yamadashy/repomix --skill repomix-explorer --agent openclaw

For Hermes Agent, install the single-file skill with Hermes Agent's native skills command:

hermes skills install https://raw.githubusercontent.com/yamadashy/repomix/main/skills/repomix-explorer/SKILL.md

What It Does

Once installed, you can analyze codebases with natural language instructions.

Analyze remote repositories:

"What's the structure of this repo?https://github.com/facebook/react"

Explore local codebases:

"What's in this project?~/projects/my-app"

This is useful not only for understanding codebases, but also when you want to implement features by referencing your other repositories.

⚙️ Configuration

Repomix supports multiple configuration file formats for flexibility and ease of use.

Configuration File Formats

Repomix will automatically search for configuration files in the following priority order:

1. TypeScript (repomix.config.ts, repomix.config.mts, repomix.config.cts)
2. JavaScript/ES Module (repomix.config.js, repomix.config.mjs, repomix.config.cjs)
3. JSON (repomix.config.json5, repomix.config.jsonc, repomix.config.json)

JSON Configuration

Create a repomix.config.json file in your project root:

repomix --init

This will create a repomix.config.json file with default settings.

TypeScript Configuration

TypeScript configuration files provide the best developer experience with full type checking and IDE support.

Installation:

To use TypeScript or JavaScript configuration with defineConfig, you need to install Repomix as a dev dependency:

npm install -D repomix

Example:

// repomix.config.tsimport { defineConfig } from 'repomix';
export default defineConfig({  output: {    filePath: 'output.xml',    style: 'xml',    removeComments: true,  },  ignore: {    customPatterns: ['**/node_modules/**', '**/dist/**'],  },});

Benefits:

• ✅ Full TypeScript type checking in your IDE
• ✅ Excellent IDE autocomplete and IntelliSense
• ✅ Use dynamic values (timestamps, environment variables, etc.)

Dynamic Values Example:

// repomix.config.tsimport { defineConfig } from 'repomix';
// Generate timestamp-based filenameconst timestamp = new Date().toISOString().slice(0, 19).replace(/[:.]/g, '-');
export default defineConfig({  output: {    filePath: `output-${timestamp}.xml`,    style: 'xml',  },});

JavaScript Configuration

JavaScript configuration files work the same as TypeScript, supporting defineConfig and dynamic values.

Configuration Options

Here's an explanation of the configuration options:

The configuration file supports JSON5 syntax, which allows:

• Comments (both single-line and multi-line)
• Trailing commas in objects and arrays
• Unquoted property names
• More relaxed string syntax

Schema Validation

You can enable schema validation for your configuration file by adding the $schema property:

{  "$schema": "https://repomix.com/schemas/latest/schema.json",  "output": {    "filePath": "repomix-output.xml",    "style": "xml"  }}

This provides auto-completion and validation in editors that support JSON schema.

Example Configuration

Example configuration:

{  "$schema": "https://repomix.com/schemas/latest/schema.json",  "input": {    "maxFileSize": 50000000,    // Optional: transform matching files with an external command before packing (local CLI only)    // "processors": [    //   { "pattern": "**/*.json", "command": "npx @toon-format/cli {file}" }    // ]  },  "output": {    "filePath": "repomix-output.xml",    "style": "xml",    "filePathStyle": "target-relative",    "parsableStyle": false,    "compress": false,    // Optional: override the inclusion level per glob (first match wins)    // "patterns": [    //   { "pattern": "docs/**/*", "compress": true },    //   { "pattern": "website/**/*", "directoryStructureOnly": true }    // ],    "headerText": "Custom header information for the packed file.",    "fileSummary": true,    "directoryStructure": true,    "files": true,    "removeComments": false,    "removeEmptyLines": false,    "topFilesLength": 5,    "tokenCountTree": false, // or true, or a number like 10 for minimum token threshold    // "tokenBudget": 180000, // optional: fail when the packed output exceeds this many tokens    "showLineNumbers": false,    "truncateBase64": false,    "copyToClipboard": false,    // "splitOutput": 1000000, // optional: split output into multiple ~1MB files    "includeEmptyDirectories": false,    "git": {      "sortByChanges": true,      "sortByChangesMaxCommits": 100,      "includeDiffs": false,      "includeLogs": false,      "includeLogsCount": 50    }  },  "include": ["**/*"],  "ignore": {    "useGitignore": true,    "useDefaultPatterns": true,    // Patterns can also be specified in .repomixignore    "customPatterns": [      "additional-folder",      "**/*.log"    ],  },  "security": {    "enableSecurityCheck": true  },  "tokenCount": {    "encoding": "o200k_base"  }}

Global Configuration

To create a global configuration file:

repomix --init --global

The global configuration file will be created in:

• Windows: %LOCALAPPDATA%\Repomix\repomix.config.json
• macOS/Linux: $XDG_CONFIG_HOME/repomix/repomix.config.json or ~/.config/repomix/repomix.config.json

Note: Local configuration (if present) takes precedence over global configuration.

Include and Ignore

Include Patterns

Repomix now supports specifying files to include using glob patterns. This allows for more flexible and powerful file selection:

• Use **/*.js to include all JavaScript files in any directory
• Use src/**/* to include all files within the src directory and its subdirectories
• Combine multiple patterns like ["src/**/*.js", "**/*.md"] to include JavaScript files in src and all Markdown files

Ignore Patterns

Repomix offers multiple methods to set ignore patterns for excluding specific files or directories during the packing process:

• .gitignore: By default, patterns listed in your project's .gitignore files and .git/info/exclude are used. This behavior can be controlled with the ignore.useGitignore setting or the --no-gitignore cli option.
• .ignore: You can use a .ignore file in your project root, following the same format as .gitignore. This file is respected by tools like ripgrep and the silver searcher, reducing the need to maintain multiple ignore files. This behavior can be controlled with the ignore.useDotIgnore setting or the --no-dot-ignore cli option.
• Default patterns: Repomix includes a default list of commonly excluded files and directories (e.g., node_modules, .git, binary files). This feature can be controlled with the ignore.useDefaultPatterns setting or the --no-default-patterns cli option. Please see defaultIgnore.ts for more details.
• .repomixignore: You can create a .repomixignore file in your project root to define Repomix-specific ignore patterns. This file follows the same format as .gitignore.
• Custom patterns: Additional ignore patterns can be specified using the ignore.customPatterns option in the configuration file. You can overwrite this setting with the -i, --ignore command line option.

Priority Order (from highest to lowest):

1. Custom patterns (ignore.customPatterns)
2. Ignore files (.repomixignore, .ignore, .gitignore, and .git/info/exclude):
   • When in nested directories, files in deeper directories have higher priority
   • When in the same directory, these files are merged in no particular order
3. Default patterns (if ignore.useDefaultPatterns is true and --no-default-patterns is not used)

This approach allows for flexible file exclusion configuration based on your project's needs. It helps optimize the size of the generated pack file by ensuring the exclusion of security-sensitive files and large binary files, while preventing the leakage of confidential information.

Note: Binary files are not included in the packed output by default, but their paths are listed in the "Repository Structure" section of the output file. This provides a complete overview of the repository structure while keeping the packed file efficient and text-based.

Custom Instruction

The output.instructionFilePath option allows you to specify a separate file containing detailed instructions or context about your project. This allows AI systems to understand the specific context and requirements of your project, potentially leading to more relevant and tailored analysis or suggestions.

Here's an example of how you might use this feature:

1. Create a file named repomix-instruction.md in your project root:

# Coding Guidelines
- Follow the Airbnb JavaScript Style Guide- Suggest splitting files into smaller, focused units when appropriate- Add comments for non-obvious logic. Keep all text in English- All new features should have corresponding unit tests
# Generate Comprehensive Output
- Include all content without abbreviation, unless specified otherwise- Optimize for handling large codebases while maintaining output quality

2. In your repomix.config.json, add the instructionFilePath option:

{  "output": {    "instructionFilePath": "repomix-instruction.md",    // other options...  }}

When Repomix generates the output, it will include the contents of repomix-instruction.md in a dedicated section.

Note: The instruction content is appended at the end of the output file. This placement can be particularly effective for AI systems. For those interested in understanding why this might be beneficial, Anthropic provides some insights in their documentation:
https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/long-context-tips

Put long-form data at the top: Place your long documents and inputs (~20K+ tokens) near the top of your prompt, above your query, instructions, and examples. This can significantly improve Claude's performance across all models. Queries at the end can improve response quality by up to 30% in tests, especially with complex, multi-document inputs.

Comment Removal

When output.removeComments is set to true, Repomix will attempt to remove comments from supported file types. This feature can help reduce the size of the output file and focus on the essential code content.

Supported languages include:
HTML, CSS, JavaScript, TypeScript, Vue, Svelte, Python, PHP, Ruby, C, C#, Java, Go, Rust, Swift, Kotlin, Dart, Shell, and YAML.

Note: The comment removal process is conservative to avoid accidentally removing code. In complex cases, some comments might be retained.

File Processors

input.processors runs an external command to transform a file's content before it is packed. Each entry targets files by glob (matched like include/ignore) and replaces the matching files' content with the command's standard output — useful for token-reducing or format-converting transforms such as JSON→TOON, SVG minification, or notebook→script conversion.

{  "input": {    "processors": [      { "pattern": "**/*.json", "command": "npx @toon-format/cli {file}" }    ]  }}

The {file} placeholder (required) is replaced with a temp file holding the file's content, and the command's stdout becomes the new content. Patterns are evaluated in order and the first match wins (one processor per file). Each entry also accepts timeout (ms, default 60000) and onError ("fail" to abort the pack, default; "skip" to warn and keep the original content).

Example commands (each is a command value paired with a suitable pattern):

Apply only one processor per file (first match wins), and make sure the tool it invokes is on your PATH (npx-based commands download it on first use).

[!WARNING] File processors run arbitrary commands from your config file, so execution is default-deny:

• Enabled only for local CLI runs, where Repomix assumes the config in your working directory is your own — the same trust boundary as an npm script or a Makefile. As with those, if you run repomix inside a repository you obtained from someone else without reviewing its repomix.config.json first, its processor commands will execute on your machine. Review the config of untrusted repositories before packing them.
• Disabled for the library API (pack() / runCli()), the MCP server, and the hosted repomix.com.
• For remote repositories (--remote), the cloned config — and its processors — is trusted only when you explicitly pass --remote-trust-config; without it the remote config is not even loaded.

Active processors are printed at startup and in error messages, so reference credentials via environment variables (e.g. $TOKEN), which are logged unexpanded, rather than inlining them. On timeout Repomix kills the command's shell, but a command that spawns its own long-lived background processes may leave them running. See the configuration guide for details.

🔍 Security Check

Repomix includes a security check feature that uses Secretlint to detect potentially sensitive information in your files. This feature helps you identify possible security risks before sharing your packed repository.

The security check results will be displayed in the CLI output after the packing process is complete. If any suspicious files are detected, you'll see a list of these files along with a warning message.

Example output:

🔍 Security Check:──────────────────2 suspicious file(s) detected:1. src/utils/test.txt2. tests/utils/secretLintUtils.test.ts
Please review these files for potentially sensitive information.

By default, Repomix's security check feature is enabled. You can disable it by setting security.enableSecurityCheck to false in your configuration file:

{  "security": {    "enableSecurityCheck": false  }}

Or using the --no-security-check command line option:

repomix --no-security-check

[!NOTE] Disabling security checks may expose sensitive information. Use this option with caution and only when necessary, such as when working with test files or documentation that contains example credentials.

Remote Repository Config Trust

A repomix.config.* is code, not just data: a .ts / .js config is executed when loaded, input.processors runs external commands, and path options can read files outside the repository. Loading one from an unfamiliar repository is comparable to running its Makefile.

For that reason, a cloned repository's config is never loaded by default. Your global config and CLI options still apply.

When you opt in with --remote-trust-config (or REPOMIX_REMOTE_TRUST_CONFIG=true) on an interactive terminal, Repomix shows the config that is about to run and asks before loading it:

• Yes, once — trust this run only.
• Yes, and don't ask again for this repository — the decision is content-pinned: it records a hash of the config you approved, so you are asked again if that repository later ships a different one (the direnv allow model).
• No (the default selection) — abort without loading the config.

The displayed config is written by the repository's author, so control, ANSI, and bidirectional characters are escaped, the output is capped, every config line is prefixed, and symlinked configs pointing outside the clone are refused — what you review is what runs.

The prompt is skipped with --force, in non-interactive shells such as CI (existing automation keeps working), and once you have chosen to always trust that repository.

[!IMPORTANT] The content pin covers the entry config file only. A .ts / .js config can import other files and input.processors can invoke external scripts; neither is hashed. Treat "don't ask again" as trust in the repository, not only in the file you read.

See the security guide for the full trust model.

🤖 Using Repomix with GitHub Actions

You can also use Repomix in your GitHub Actions workflows. This is useful for automating the process of packing your codebase for AI analysis.

Basic usage:

- name: Pack repository with Repomix  uses: yamadashy/repomix/.github/actions/repomix@main  with:    output: repomix-output.xml    style: xml

Use --style to generate output in different formats:

- name: Pack repository with Repomix  uses: yamadashy/repomix/.github/actions/repomix@main  with:    output: repomix-output.md    style: markdown

- name: Pack repository with Repomix (JSON format)  uses: yamadashy/repomix/.github/actions/repomix@main  with:    output: repomix-output.json    style: json

Pack specific directories with compression:

- name: Pack repository with Repomix  uses: yamadashy/repomix/.github/actions/repomix@main  with:    directories: src tests    include: "**/*.ts,**/*.md"    ignore: "**/*.test.ts"    output: repomix-output.txt    compress: true

Upload the output file as an artifact:

- name: Pack repository with Repomix  uses: yamadashy/repomix/.github/actions/repomix@main  with:    directories: src    output: repomix-output.txt    compress: true
- name: Upload Repomix output  uses: actions/upload-artifact@v7  with:    name: repomix-output    path: repomix-output.txt

Complete workflow example:

name: Pack repository with Repomix
on:  workflow_dispatch:  push:    branches: [ main ]  pull_request:    branches: [ main ]
jobs:  pack-repo:    runs-on: ubuntu-latest    steps:      - name: Checkout code        uses: actions/checkout@v7
      - name: Pack repository with Repomix        uses: yamadashy/repomix/.github/actions/repomix@main        with:          output: repomix-output.xml
      - name: Upload Repomix output        uses: actions/upload-artifact@v7        with:          name: repomix-output.xml          path: repomix-output.xml          retention-days: 30

See the complete workflow example here.

Action Inputs

Action Outputs

📚 Using Repomix as a Library

In addition to using Repomix as a CLI tool, you can also use it as a library in your Node.js applications.

Installation

npm install repomix

Basic Usage

import { runCli, type CliOptions } from 'repomix';
// Process current directory with custom optionsasync function packProject() {  const options = {    output: 'output.xml',    style: 'xml',    compress: true,    quiet: true  } as CliOptions;    const result = await runCli(['.'], process.cwd(), options);  return result.packResult;}

Process Remote Repository

import { runCli, type CliOptions } from 'repomix';
// Clone and process a GitHub repoasync function processRemoteRepo(repoUrl) {  const options = {    remote: repoUrl,    output: 'output.xml',    compress: true  } as CliOptions;    return await runCli(['.'], process.cwd(), options);}

Using Core Components

If you need more control, you can use the low-level APIs:

import { searchFiles, collectFiles, processFiles, TokenCounter } from 'repomix';
async function analyzeFiles(directory) {  // Find and collect files  const { filePaths } = await searchFiles(directory, { /* config */ });  const rawFiles = await collectFiles(filePaths, directory);  const processedFiles = await processFiles(rawFiles, { /* config */ });    // Count tokens  const tokenCounter = new TokenCounter('o200k_base');    // Return analysis results  return processedFiles.map(file => ({    path: file.path,    tokens: tokenCounter.countTokens(file.content)  }));}

For more examples, check the source code at website/server/src/remoteRepo.ts which demonstrates how repomix.com uses the library.

Bundling

When bundling repomix with tools like Rolldown or esbuild, some dependencies must remain external and WASM files need to be copied:

External dependencies (cannot be bundled):

• tinypool - Spawns worker threads using file paths

WASM files to copy:

• web-tree-sitter.wasm → Same directory as bundled JS (required for code compression feature)
• Tree-sitter language files → Directory specified by REPOMIX_WASM_DIR environment variable

For a working example, see website/server/scripts/bundle.mjs.

🌍 Community Projects

Discover amazing projects built by the Repomix community!

• Repomix Runner - VSCode extension for bundling files into a single output for AI processing
• Repomix Desktop - GUI desktop application for Repomix built with Python and CustomTkinter
• Python Repomix - Python implementation with AST-based compression
• Rulefy - Transform GitHub repos into custom Cursor AI rules using Claude AI
• Codebase MCP - MCP server that uses Repomix for AI-powered codebase analysis
• vibe-tools - CLI toolset for AI agents with web search, repo analysis, and browser automation

For more details, visit our Community Projects page.

🤝 Contribution

We welcome contributions from the community! To get started, please refer to our Contributing Guide.

Contributors

🔒 Privacy Policy

See our Privacy Policy.

📜 License

This project is licensed under the MIT License.

    Back To Top