// File contents here

 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:

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

 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:

#### Plain Text Format

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

### Command Line Options

#### Basic Options

 

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

#### CLI Input/Output Options

 Option Description 
 `--verbose` Enable detailed debug logging (shows file processing, token counts, and configuration details) 
 `--quiet` Suppress all console output except errors (useful for scripting) 
 `--stdout` Write packed output directly to stdout instead of a file (suppresses all logging) 
 `--stdin` Read file paths from stdin, one per line (specified files are processed directly) 
 `--copy` Copy the generated output to system clipboard after processing 
 `--token-count-tree [threshold]` Show file tree with token counts; optional threshold to show only files with ≥N tokens (e.g., `--token-count-tree 100`) 
 `--top-files-len <number>` Number of largest files to show in summary (default: `5`) 
 

#### Repomix Output Options

 Option Description 
 `-o, --output <file>` Output file path (default: `repomix-output.xml`, use `"-"` for stdout) 
 `--style <style>` Output format: `xml`, `markdown`, `json`, or `plain` (default: `xml`) 
 `--output-file-path-style <style>` How file paths are shown in output: `target-relative` or `cwd-relative` (default: `target-relative`) 
 `--parsable-style` Escape special characters to ensure valid XML/Markdown (needed when output contains code that breaks formatting) 
 `--compress` Extract essential code structure (classes, functions, interfaces) using Tree-sitter parsing 
 `--output-show-line-numbers` Prefix each line with its line number in the output 
 `--no-file-summary` Omit the file summary section from output 
 `--no-directory-structure` Omit the directory tree visualization from output 
 `--no-files` Generate metadata only without file contents (useful for repository analysis) 
 `--remove-comments` Strip all code comments before packing 
 `--remove-empty-lines` Remove blank lines from all files 
 `--truncate-base64` Truncate long base64 data strings to reduce output size 
 `--header-text <text>` Custom text to include at the beginning of the output 
 `--instruction-file-path <path>` Path to file containing custom instructions to include in output 
 `--split-output <size>` Split output into multiple numbered files (e.g., `repomix-output.1.xml`); size like `500kb`, `2mb`, or `1.5mb` 
 `--include-empty-directories` Include folders with no files in directory structure 
 `--include-full-directory-structure` Show complete directory tree in output, including files not matched by `--include` patterns 
 `--no-git-sort-by-changes` Don't sort files by git change frequency (default: most changed files first) 
 `--include-diffs` Add git diff section showing working tree and staged changes 
 `--include-logs` Add git commit history with messages and changed files 
 `--include-logs-count <count>` Number of recent commits to include with `--include-logs` (default: `50`) 
 

#### File Selection Options

 Option Description 
 `--include <patterns>` Include only files matching these glob patterns (comma-separated, e.g., `"src/**/*.js,*.md"`) 
 `-i, --ignore <patterns>` Additional patterns to exclude (comma-separated, e.g., `"*.test.js,docs/**"`) 
 `--no-gitignore` Don't use `.gitignore` rules for filtering files 
 `--no-dot-ignore` Don't use `.ignore` rules for filtering files 
 `--no-default-patterns` Don't apply built-in ignore patterns (`node_modules`, `.git`, build dirs, etc.) 
 

#### Remote Repository Options

 Option Description 
 `--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) 
 `--remote-trust-config` Trust and load config files from remote repositories (disabled by default for security) 
 

#### Configuration Options

 Option Description 
 `-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) 

- `--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 

#### Agent Skills Generation

 Option Description 
 `--skill-generate [name]` Generate Claude Agent Skills format output to `.claude/skills/<name>/` directory (name auto-generated if omitted) 
 `--skill-project-name <name>` Override the project name used in generated Skills descriptions 
 `--skill-output <path>` Specify skill output directory path directly (skips location prompt) 
 `-f, --force` Skip all confirmation prompts (e.g., skill directory overwrite) 
 

#### 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

### Updating Repomix

 To update a globally installed 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 also use GitHub's shorthand format:

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

 Or use a specific commit hash:

 
 [!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`.

 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](https://github.com/tree-sitter/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.

 For example, this code:

 Will be compressed to:

 
 [!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:

 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:

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

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

 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:

 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)](https://modelcontextprotocol.io), 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.

#### 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:

 

- **Using the Install Badge:** 

 

 

- **Using the Command Line:** 

 For VS Code Insiders:

 **For Cline (VS Code extension):**

 Edit the `cline_mcp_settings.json` file:

 **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](https://docs.anthropic.com/en/docs/claude-code/overview), use the following command:

 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:

 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, .ignore, 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 

 

- Parameters:
 

- `remote`: GitHub repository URL or user/repo format (e.g., "yamadashy/repomix", "[https://github.com/user/repo](https://github.com/user/repo)", or "[https://github.com/user/repo/tree/branch](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. 

- `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 

 

- 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 

 

 

- **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. 

 

- Parameters:
 

- `path`: Absolute path to the file to read 

 

- Security features:
 

- Implements security validation using [Secretlint](https://github.com/secretlint/secretlint) 

- 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](https://docs.anthropic.com/en/docs/claude-code/overview) that integrate seamlessly with the AI-powered development environment.

#### Installation

 **1. Add the Repomix plugin marketplace:**

 **2. Install plugins:**

 **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:**

 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 

- Search through packed outputs 

- Read files with built-in security scanning (Secretlint) 

- 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:**

 **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:**

 The agent automatically:

 

- Runs `npx repomix@latest` to pack the repository 

- Uses Grep and Read tools to efficiently search the output 

- 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 

- **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.

### Agent Skills Generation

 Repomix can generate [Claude Agent Skills](https://docs.anthropic.com/en/docs/claude-code/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

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

 

- **Personal Skills** (`~/.claude/skills/`) - Available across all projects on your machine 

- **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`:

#### Generated Structure

 The Skills are generated with the following structure:

#### 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:

#### Integration with Repomix Features

 Skills generation respects all standard Repomix options:

### 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:

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

 To target a specific assistant, pass `--agent`:

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

#### What It Does

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

 Analyze remote repositories:

 Explore local codebases:

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

npx repomix@latest

# 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

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

repomix

repomix path/to/directory

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

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

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

# 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

# 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

repomix --compress

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

repomix --init

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

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

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

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

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.

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.

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.

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.

This file is a merged representation of the entire codebase, combining all repository files into a single document.

 
 (Metadata and usage AI instructions)
 

 
src/
cli/
cliOutput.ts
index.ts

(...remaining directories)
 

 
 
 // File contents here
 

(...remaining files)
 

 
(Custom instructions from `output.instructionFilePath`)
 

repomix --style markdown

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

(...remaining directories)

# Repository Files

## ⚙️ 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:

 

- **TypeScript** (`repomix.config.ts`, `repomix.config.mts`, `repomix.config.cts`) 

- **JavaScript/ES Module** (`repomix.config.js`, `repomix.config.mjs`, `repomix.config.cjs`) 

- **JSON** (`repomix.config.json5`, `repomix.config.jsonc`, `repomix.config.json`) 

#### JSON Configuration

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

 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:

 **Example:**

 **Benefits:**

 

- ✅ Full TypeScript type checking in your IDE 

- ✅ Excellent IDE autocomplete and IntelliSense 

- ✅ Use dynamic values (timestamps, environment variables, etc.) 

 **Dynamic Values Example:**

#### 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:

 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.filePathStyle` How file paths are shown in output (`target-relative` keeps paths relative to each target root, `cwd-relative` keeps paths relative to the current working directory) `"target-relative"` 
 `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.patterns` Per-file inclusion levels. An ordered array of `{ pattern, compress?, directoryStructureOnly? }` entries; the first matching glob wins and overrides the global `output.compress` for that file. See Per-file Inclusion Levels Not set 
 `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.splitOutput` Split output into multiple numbered files by maximum size per part (e.g., `1000000` for ~1MB). Keeps each file under the limit and avoids splitting files across parts Not set 
 `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.tokenBudget` Fail with a non-zero exit code when the packed output exceeds this many tokens. Acts as a guard for CI/agent context limits; the output is still generated Not set 
 `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) `false` 
 `output.git.includeLogsCount` Number of git log commits to include `50` 
 `include` Patterns of files to include (using [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax)) `[]` 
 `ignore.useGitignore` Whether to use patterns from the project's `.gitignore` file `true` 
 `ignore.useDotIgnore` Whether to use patterns from the project's `.ignore` file `true` 
 `ignore.useDefaultPatterns` Whether to use default ignore patterns `true` 
 `ignore.customPatterns` Additional patterns to ignore (using [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax)) `[]` 
 `security.enableSecurityCheck` Whether to perform security checks on files `true` 
 `tokenCount.encoding` Token count encoding for OpenAI-compatible tokenization (e.g., `o200k_base` for GPT-4o, `cl100k_base` for GPT-4/3.5). Powered by [gpt-tokenizer](https://github.com/nicolo-ribaudo/gpt-tokenizer). `"o200k_base"` 
 

 The configuration file supports [JSON5](https://json5.org/) 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:

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

### Example Configuration

 Example configuration:

### Global Configuration

 To create a global configuration file:

 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](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax). 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](https://github.com/yamadashy/repomix/blob/main/src/config/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`) 

- 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 

 

- 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: 

 

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

 When Repomix generates the outpu