Repomix MCP server for AI-powered codebase analysis. Pack local/remote repositories, search outputs, and read files with built-in security scanning. Foundation plugin that enables all Repomix features in Claude Code.
You can install this plugin from any of these themed marketplaces. Choose one, add it as a marketplace, then install the plugin.
Installation
Choose your preferred installation method below
A marketplace is a collection of plugins. Every plugin gets an auto-generated marketplace JSON for individual installation, plus inclusion in category and themed collections. Add a marketplace once (step 1), then install any plugin from it (step 2).
From All Plugins
Recommended
One-time setup for access to all plugins
When to use: If you plan to install multiple plugins now or later
📦 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.
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 files and .git/info/exclude.
Security-Focused: Incorporates Secretlint for robust security checks to detect and prevent inclusion of sensitive information.
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 npm
npm install -g repomix
# Alternatively using yarn
yarn global add repomix
# Alternatively using bun
bun add -g repomix
# Alternatively using Homebrew (macOS/Linux)
brew install repomix
# Then run in any project directory
repomix
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.
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.
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.
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.
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 URL
repomix --remote https://github.com/yamadashy/repomix/tree/main
# Commit's URL is also supported
repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
To pack files from a file list (pipe via stdin):
# Using find command
find src -name "*.ts" -type f | repomix --stdin
# Using git to get tracked files
git ls-files "*.ts" | repomix --stdin
# Using grep to find files containing specific content
grep -l "TODO" **/*.ts | repomix --stdin
# Using ripgrep to find files with specific content
rg -l "TODO|FIXME" --type ts | repomix --stdin
# Using ripgrep (rg) to find files
rg --files --type ts | repomix --stdin
# Using sharkdp/fd to find files
fd -e ts | repomix --stdin
# Using fzf to select from all files
fzf -m | repomix --stdin
# Interactive file selection with fzf
find . -name "*.ts" -type f | fzf -m | repomix --stdin
# Using ls with glob patterns
ls src/**/*.ts | repomix --stdin
# From a file containing file paths
cat file-list.txt | repomix --stdin
# Direct input with echo
echo -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 count
repomix --include-logs --include-logs-count 10
# Combine with diffs for comprehensive git context
repomix --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.
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.ts
index.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>
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 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 paths
cat repomix-output.json | jq -r '.files | keys[]'
# Count total number of files
cat repomix-output.json | jq '.files | keys | length'
# Extract specific file content
cat repomix-output.json | jq -r '.files["README.md"]'
cat repomix-output.json | jq -r '.files["src/index.js"]'
# Find files by extension
cat repomix-output.json | jq -r '.files | keys[] | select(endswith(".ts"))'
# Get files containing specific text
cat repomix-output.json | jq -r '.files | to_entries[] | select(.value | contains("function")) | .key'
# Extract directory structure
cat repomix-output.json | jq -r '.directoryStructure'
# Get file summary information
cat 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 sizes
cat 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`)
--remote <url>: Clone and pack a remote repository (GitHub URL or user/repo format)
--remote-branch <name>: Specific branch, tag, or commit to use (default: repository's default branch)
Configuration Options
-c, --config <path>: Use custom config file instead of repomix.config.json
--init: Create a new repomix.config.json file with defaults
--global: With --init, create config in home directory instead of current directory
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)
MCP
--mcp: Run as Model Context Protocol server for AI tool integration
Examples
# Basic usage
repomix
# Custom output
repomix -o output.xml --style xml
# Output to stdout
repomix --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 compression
repomix --compress
# Process specific files
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# Remote repository with branch
repomix --remote https://github.com/user/repo/tree/main
# Remote repository with commit
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# Remote repository with shorthand
repomix --remote user/repo
Updating Repomix
To update a globally installed Repomix:
# Using npm
npm update -g repomix
# Using yarn
yarn global upgrade repomix
# Using bun
bun 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:
You can specify the branch name, tag, or commit hash:
# Using --remote-branch option
repomix --remote https://github.com/yamadashy/repomix --remote-branch main
# Using branch's URL
repomix --remote https://github.com/yamadashy/repomix/tree/main
Or use a specific commit hash:
# Using --remote-branch option
repomix --remote https://github.com/yamadashy/repomix --remote-branch 935b695
# Using commit's URL
repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
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 interface
interface 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
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:
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
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
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:
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:
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 and built-in exclusions.
topFilesLength: (Optional, default: 10) Number of largest files by size to display in the metrics summary for codebase analysis.
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 secure access to existing packed outputs without requiring re-processing
Useful for working with previously generated packed repositories
pack_remote_repository: Fetch, clone, and package a GitHub repository into a consolidated XML file for AI analysis
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 and built-in exclusions.
topFilesLength: (Optional, default: 10) Number of largest files by size to display in the metrics summary for codebase analysis.
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 secure access to packed codebase without requiring file system access
Supports partial reading for large files
grep_repomix_output: Search for patterns in a Repomix output file using grep-like functionality with JavaScript RegExp syntax
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
file_system_read_file: Read a file from the local file system using an absolute path. Includes built-in security validation to detect and prevent access to files containing sensitive information.
Prevents access to files containing sensitive information (API keys, passwords, secrets)
Validates absolute paths to prevent directory traversal attacks
file_system_read_directory: List the contents of a directory using an absolute path. Returns a formatted list showing files and subdirectories with clear indicators.
Parameters:
path: Absolute path to the directory to list
Features:
Shows files and directories with clear indicators ([FILE] or [DIR])
Provides safe directory traversal with proper error handling
Validates paths and ensures they are absolute
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.
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
Search through packed outputs
Read files with built-in security scanning (Secretlint)
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-local
Pack this project as markdown with compression
/repomix-commands:pack-remote yamadashy/repomix
Pack only TypeScript files from the yamadashy/repomix repository
Note: The repomix-mcp plugin is recommended as a foundation, and repomix-commands extends it with convenient slash commands. While you can install them independently, using both 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.
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
Security Built-in: Automatic Secretlint scanning prevents sensitive data exposure
Token Optimization: Tree-sitter compression for large codebases
For more details, see the plugin documentation in the .claude/plugins/ directory.
⚙️ 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:
JavaScript configuration files work the same as TypeScript, supporting defineConfig and dynamic values.
Configuration Options
Here's an explanation of the configuration options:
Option
Description
Default
input.maxFileSize
Maximum file size in bytes to process. Files larger than this will be skipped
50000000
output.filePath
The name of the output file
"repomix-output.xml"
output.style
The style of the output (xml, markdown, json, plain)
"xml"
output.parsableStyle
Whether to escape the output based on the chosen style schema. Note that this can increase token count.
false
output.compress
Whether to perform intelligent code extraction to reduce token count
false
output.headerText
Custom text to include in the file header
null
output.instructionFilePath
Path to a file containing detailed custom instructions
null
output.fileSummary
Whether to include a summary section at the beginning of the output
true
output.directoryStructure
Whether to include the directory structure in the output
true
output.files
Whether to include file contents in the output
true
output.removeComments
Whether to remove comments from supported file types
false
output.removeEmptyLines
Whether to remove empty lines from the output
false
output.showLineNumbers
Whether to add line numbers to each line in the output
false
output.truncateBase64
Whether to truncate long base64 data strings (e.g., images) to reduce token count
false
output.copyToClipboard
Whether to copy the output to system clipboard in addition to saving the file
false
output.topFilesLength
Number of top files to display in the summary. If set to 0, no summary will be displayed
5
output.tokenCountTree
Whether to display file tree with token count summaries. Can be boolean or number (minimum token count threshold)
false
output.includeEmptyDirectories
Whether to include empty directories in the repository structure
false
output.includeFullDirectoryStructure
When using include patterns, whether to display the complete directory tree (respecting ignore patterns) while still processing only the included files. Provides full repository context for AI analysis
false
output.git.sortByChanges
Whether to sort files by git change count (files with more changes appear at the bottom)
true
output.git.sortByChangesMaxCommits
Maximum number of commits to analyze for git changes
100
output.git.includeDiffs
Whether to include git diffs in the output (includes both work tree and staged changes separately)
false
output.git.includeLogs
Whether to include git logs in the output (includes commit history with dates, messages, and file paths)
Token count encoding used by OpenAI's tiktoken tokenizer (e.g., o200k_base for GPT-4o, cl100k_base for GPT-4/3.5). See tiktoken model.py for encoding details.
"o200k_base"
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:
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.
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):
Custom patterns ignore.customPatterns
.repomixignore
.gitignore and .git/info/exclude (if ignore.useGitignore is true and --no-gitignore is not used)
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:
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
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.
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.
Note: The comment removal process is conservative to avoid accidentally removing code. In complex cases, some comments
might be retained.
🔍 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.txt
2. 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.
🤖 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:
Space-separated list of directories to process (e.g., src tests docs)
.
include
Comma-separated glob patterns to include files (e.g., **/*.ts,**/*.md)
""
ignore
Comma-separated glob patterns to ignore files (e.g., **/*.test.ts,**/node_modules/**)
""
output
Relative path for the packed file (extension determines format: .txt, .md, .xml)
repomix-output.xml
compress
Enable smart compression to reduce output size by pruning implementation details
true
style
Output style (xml, markdown, json, plain)
xml
additional-args
Extra raw arguments for the repomix CLI (e.g., --no-file-summary --no-security-check)
""
repomix-version
Version of the npm package to install (supports semver ranges, tags, or specific versions like 0.2.25)
latest
Action Outputs
Name
Description
output_file
Path to the generated output file. Can be used in subsequent steps for artifact upload, LLM processing, or other operations. The file contains a formatted representation of your codebase based on the specified options.
📚 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 options
async 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 repo
async 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:
Data Collection: The Repomix website uses Google Analytics to collect usage data, such as page views and user interactions. This helps us understand how the website is used and improve the user experience.
File Processing: When uploading ZIP files or folders, your files are temporarily stored on our servers for processing. All uploaded files and processed data are automatically deleted immediately after processing is complete.
Repomix Browser Extension
Data Collection: The Repomix browser extension does not collect, transmit, or store any user data, telemetry, or repository information.
Permissions: The extension only requires minimal permissions necessary to add the Repomix button to GitHub repository pages. It does not access or modify repository data.
Liability Disclaimer
Repomix (the CLI tool, website, and browser extension) is provided "as is" without any warranties or guarantees.
We do not take responsibility for how the generated output is used, including but not limited to its accuracy, legality, or any potential consequences arising from its use.
