Please enter a valid GitHub repository URL (e.g., yamadashy/repomix)
// Analytics event categories
export const AnalyticsCategory = {
REPOSITORY: 'repository',
FORMAT: 'format',
OPTIONS: 'options',
OUTPUT: 'output',
} as const;
// Analytics event actions
export const AnalyticsAction = {
// Repository events
PACK_START: 'pack_start',
PACK_SUCCESS: 'pack_success',
PACK_SUCCESS_FILES: 'pack_success_files',
PACK_SUCCESS_CHARS: 'pack_success_chars',
PACK_ERROR: 'pack_error',
// Format events
FORMAT_CHANGE: 'format_change',
// Options events
TOGGLE_REMOVE_COMMENTS: 'toggle_remove_comments',
TOGGLE_REMOVE_EMPTY_LINES: 'toggle_remove_empty_lines',
TOGGLE_LINE_NUMBERS: 'toggle_line_numbers',
TOGGLE_FILE_SUMMARY: 'toggle_file_summary',
TOGGLE_DIRECTORY_STRUCTURE: 'toggle_directory_structure',
TOGGLE_OUTPUT_PARSABLE: 'toggle_output_parsable', // Added this action
UPDATE_INCLUDE_PATTERNS: 'update_include_patterns',
UPDATE_IGNORE_PATTERNS: 'update_ignore_patterns',
// Output events
COPY_OUTPUT: 'copy_output',
DOWNLOAD_OUTPUT: 'download_output',
} as const;
export type AnalyticsCategoryType = (typeof AnalyticsCategory)[keyof typeof AnalyticsCategory];
export type AnalyticsActionType = (typeof AnalyticsAction)[keyof typeof AnalyticsAction];
// Google Analytics event tracking interface
interface GAEventParams {
category: AnalyticsCategoryType;
action: AnalyticsActionType;
label?: string;
value?: number;
}
// Track an event using gtag
export function trackEvent({ category, action, label, value }: GAEventParams): void {
if (typeof window === 'undefined' || !window.gtag) {
return;
}
window.gtag('event', action, {
event_category: category,
event_label: label,
value: value,
});
}
// Analytics utility functions for specific events
export const analyticsUtils = {
// Repository events
trackPackStart(repoUrl: string): void {
trackEvent({
category: AnalyticsCategory.REPOSITORY,
action: AnalyticsAction.PACK_START,
label: repoUrl,
});
},
trackPackSuccess(repoUrl: string, totalFiles: number, totalChars: number): void {
trackEvent({
category: AnalyticsCategory.REPOSITORY,
action: AnalyticsAction.PACK_SUCCESS_FILES,
label: `${repoUrl}_files`,
value: totalFiles,
});
trackEvent({
category: AnalyticsCategory.REPOSITORY,
action: AnalyticsAction.PACK_SUCCESS_CHARS,
label: `${repoUrl}_chars`,
value: totalChars,
});
},
trackPackError(repoUrl: string, error: string): void {
trackEvent({
category: AnalyticsCategory.REPOSITORY,
action: AnalyticsAction.PACK_ERROR,
label: `${repoUrl} - ${error}`,
});
},
// Options events
trackOptionToggle(action: AnalyticsActionType, enabled: boolean): void {
trackEvent({
category: AnalyticsCategory.OPTIONS,
action: action,
label: enabled ? 'enabled' : 'disabled',
});
},
// Output events
trackCopyOutput(format: string): void {
trackEvent({
category: AnalyticsCategory.OUTPUT,
action: AnalyticsAction.COPY_OUTPUT,
label: format,
});
},
trackDownloadOutput(format: string): void {
trackEvent({
category: AnalyticsCategory.OUTPUT,
action: AnalyticsAction.DOWNLOAD_OUTPUT,
label: format,
});
},
};
// Type definitions for window.gtag
declare global {
interface Window {
gtag: (
command: 'event',
action: string,
params: {
event_category: string;
event_label?: string;
value?: number;
},
) => void;
}
}
import type { PackOptions, PackRequest, PackResult } from '../api/client';
import { packRepository } from '../api/client';
import { type AnalyticsActionType, analyticsUtils } from './analytics';
interface RequestHandlerOptions {
onSuccess?: (result: PackResult) => void;
onError?: (error: string) => void;
signal?: AbortSignal;
file?: File;
}
/**
* Handle repository packing request
*/
export async function handlePackRequest(
url: string,
format: 'xml' | 'markdown' | 'plain',
options: PackOptions,
handlerOptions: RequestHandlerOptions = {},
): Promise {
const { onSuccess, onError, signal, file } = handlerOptions;
const processedUrl = url.trim();
// Track pack start
analyticsUtils.trackPackStart(processedUrl);
try {
const request: PackRequest = {
url: processedUrl,
format,
options,
signal,
file,
};
const response = await packRepository(request);
// Track successful pack
if (response.metadata.summary) {
analyticsUtils.trackPackSuccess(
processedUrl,
response.metadata.summary.totalFiles,
response.metadata.summary.totalCharacters,
);
}
onSuccess?.(response);
} catch (err) {
const errorMessage = err instanceof Error ? err.message : 'An unexpected error occurred';
if (errorMessage === 'AbortError') {
onError?.('Request was cancelled');
return;
}
analyticsUtils.trackPackError(processedUrl, errorMessage);
console.error('Error processing repository:', err);
onError?.(errorMessage);
}
}
/**
* Handle form input changes with analytics tracking
*/
export function handleOptionChange(value: boolean | string, analyticsAction: AnalyticsActionType): void {
if (typeof value === 'boolean') {
analyticsUtils.trackOptionToggle(analyticsAction, value);
} else {
analyticsUtils.trackOptionToggle(analyticsAction, Boolean(value));
}
}
import type { Ace } from 'ace-builds';
import type { PackResult } from '../api/client';
import { analyticsUtils } from './analytics';
/**
* Format timestamp to locale string
*/
export function formatTimestamp(timestamp: string): string {
return new Date(timestamp).toLocaleString();
}
/**
* Handle clipboard copy with analytics tracking
*/
export async function copyToClipboard(content: string, format: string): Promise {
try {
await navigator.clipboard.writeText(content);
analyticsUtils.trackCopyOutput(format);
return true;
} catch (err) {
console.error('Failed to copy:', err);
return false;
}
}
/**
* Convert repository name to format suitable for filename
*/
function formatRepositoryName(repository: string): string {
// Extract owner and repo from GitHub URL format or use as is
const match = repository.match(/(?:https:\/\/github\.com\/)?([^/]+)\/([^/]+)(?:\.git)?$/);
if (match) {
const [, owner, repo] = match;
return `${owner}-${repo}`;
}
// For non-GitHub repositories or local files, clean up the name
return repository.replace(/[\/\\]/g, '-').replace(/\.git$/, '');
}
/**
* Handle file download with analytics tracking
*/
export function downloadResult(content: string, format: string, result: PackResult): void {
const blob = new Blob([content], { type: 'text/plain' });
const url = window.URL.createObjectURL(blob);
const a = document.createElement('a');
const extension = format === 'markdown' ? 'md' : format === 'xml' ? 'xml' : 'txt';
const repoName = formatRepositoryName(result.metadata.repository);
a.href = url;
a.download = `repomix-output-${repoName}.${extension}`;
document.body.appendChild(a);
a.click();
analyticsUtils.trackDownloadOutput(format);
window.URL.revokeObjectURL(url);
document.body.removeChild(a);
}
/**
* Get Ace editor options
*/
export function getEditorOptions(): Partial {
return {
readOnly: true,
wrap: false,
showPrintMargin: false,
fontSize: '13px',
useWorker: false,
highlightActiveLine: false,
};
}
/**
* Validates a GitHub repository URL or shorthand format
* TODO: Share this validation logic with repomix core (src/cli/actions/remoteAction.ts)
*/
export function isValidRemoteValue(remoteValue: string): boolean {
// Check the short form of the GitHub URL. e.g. yamadashy/repomix
const namePattern = '[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?';
const shortFormRegex = new RegExp(`^${namePattern}/${namePattern}$`);
if (shortFormRegex.test(remoteValue)) {
return true;
}
// Check the direct form of the GitHub URL. e.g. https://github.com/yamadashy/repomix or https://gist.github.com/yamadashy/1234567890abcdef
try {
new URL(remoteValue);
return true;
} catch (error) {
return false;
}
}
# Zu Repomix beitragen
## Schnellstart
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
npm install
```
## Entwicklungsbefehle
```bash
# CLI ausführen
npm run repomix
# Tests ausführen
npm run test
npm run test-coverage
# Code linting
npm run lint
```
## Code-Stil
- [Biome](https://biomejs.dev/) für Linting und Formatierung verwenden
- Dependency Injection für Testbarkeit
- Dateien unter 250 Zeilen halten
- Tests für neue Funktionen hinzufügen
## Pull-Request-Richtlinien
1. Alle Tests ausführen
2. Linting-Prüfungen bestehen
3. Dokumentation aktualisieren
4. Bestehenden Code-Stil befolgen
## Hilfe benötigt?
- [Issue erstellen](https://github.com/yamadashy/repomix/issues)
- [Discord beitreten](https://discord.gg/wNYzTwZFku)
# Entwicklungsumgebung einrichten
## Voraussetzungen
- Node.js ≥ 18.0.0
- Git
- npm
- pnpm (empfohlen)
## Lokale Entwicklung
### Repository klonen
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
```
### Abhängigkeiten installieren
Mit pnpm (empfohlen):
```bash
pnpm install
```
Mit npm:
```bash
npm install
```
### Entwicklungsserver starten
```bash
# CLI ausführen
pnpm run repomix
# Entwicklungsserver für die Website starten
pnpm run website:dev
```
## Docker-Entwicklung
```bash
# Image erstellen
docker build -t repomix .
# Container ausführen
docker run -v ./:/app -it --rm repomix
```
## Projektstruktur
```text
.
├── src/ # Quellcode
│ ├── cli/ # CLI-Implementierung
│ ├── config/ # Konfigurationshandling
│ ├── core/ # Kernfunktionalität
│ └── shared/ # Gemeinsame Hilfsprogramme
├── tests/ # Testdateien
├── website/ # Dokumentationswebsite
└── package.json # Projektabhängigkeiten
```
## Tests
```bash
# Alle Tests ausführen
pnpm run test
# Tests mit Abdeckungsbericht
pnpm run test:coverage
# Bestimmte Tests ausführen
pnpm run test -- tests/cli
```
## Code-Qualität
```bash
# Linting ausführen
pnpm run lint-biome
pnpm run lint-ts
pnpm run lint-secretlint
# Linting mit automatischer Korrektur
pnpm run lint:fix
# Typenprüfung
pnpm run typecheck
```
## Dokumentation
Die Dokumentation befindet sich im Verzeichnis `website/`. Um die Dokumentationswebsite lokal zu entwickeln:
```bash
# Entwicklungsserver starten
pnpm run website:dev
# Produktions-Build erstellen
pnpm run website:build
```
## Release-Prozess
1. Version aktualisieren
```bash
pnpm version patch # oder minor/major
```
2. Tests und Build ausführen
```bash
pnpm run test:coverage
pnpm run build
```
3. Veröffentlichen
```bash
pnpm publish
```
## Fehlerbehebung
### Häufige Probleme
1. **Node.js Version**
- Stellen Sie sicher, dass Sie Node.js ≥ 18.0.0 verwenden
- Überprüfen Sie mit `node --version`
2. **Abhängigkeitsprobleme**
- Löschen Sie `node_modules` und den Lock-File
- Führen Sie `pnpm install` erneut aus
3. **Build-Fehler**
- Führen Sie `pnpm run clean` aus
- Bauen Sie das Projekt neu mit `pnpm run build`
### Support
Bei Problemen:
- Öffnen Sie ein [GitHub Issue](https://github.com/yamadashy/repomix/issues)
- Treten Sie unserem [Discord-Server](https://discord.gg/wNYzTwZFku) bei
# Best Practices für KI-unterstützte Entwicklung: Aus meiner Erfahrung
Obwohl ich noch kein großes Projekt mit KI erfolgreich abgeschlossen habe, möchte ich meine bisherigen Erfahrungen in der Entwicklung mit KI teilen.
## Grundlegender Entwicklungsansatz
Bei der Arbeit mit KI kann der Versuch, alle Funktionen auf einmal zu implementieren, zu unerwarteten Problemen und Projektstillstand führen. Deshalb ist es effektiver, mit der Kernfunktionalität zu beginnen und jede Funktion einzeln aufzubauen, wobei eine solide Implementierung sichergestellt wird, bevor man weitermacht.
### Die Kraft des bestehenden Codes
Dieser Ansatz ist effektiv, weil die Implementierung der Kernfunktionalität es Ihnen ermöglicht, Ihr ideales Design und Ihren Codierungsstil durch tatsächlichen Code zu materialisieren. Der effektivste Weg, Ihre Projektvision zu kommunizieren, ist durch Code, der Ihre Standards und Präferenzen widerspiegelt.
Indem Sie mit Kernfunktionen beginnen und sicherstellen, dass jede Komponente richtig funktioniert, bevor Sie weitergehen, behält das gesamte Projekt seine Konsistenz, was es der KI erleichtert, angemesseneren Code zu generieren.
## Der modulare
Ansatz
Code in kleinere Module aufzuteilen ist entscheidend. Nach meiner Erfahrung macht es die Begrenzung von Dateien auf etwa 250 Codezeilen einfacher, der KI klare Anweisungen zu geben und den Versuch-und-Irrtum-Prozess effizienter zu gestalten. Während die Token-Anzahl ein genaueres Maß wäre, ist die Zeilenanzahl für menschliche Entwickler praktischer, daher verwenden wir diese als Richtlinie.
Diese Modularisierung beschränkt sich nicht nur auf die Trennung von Frontend, Backend und Datenbankkomponenten - es geht darum, die Funktionalität auf einer viel feineren Ebene aufzuteilen. Zum Beispiel könnten Sie innerhalb einer einzelnen Funktion die Validierung, Fehlerbehandlung und andere spezifische Funktionalitäten in separate Module aufteilen.
## Qualitätssicherung durch Tests
Ich halte Tests für entscheidend in der KI-unterstützten Entwicklung. Tests dienen nicht nur als Qualitätssicherungsmaßnahmen, sondern auch als Dokumentation, die die Codeabsichten klar demonstriert. Wenn Sie die KI bitten, neue Funktionen zu implementieren, fungiert der bestehende Testcode effektiv als Spezifikationsdokument.
Tests sind auch ein ausgezeichnetes Werkzeug zur Validierung der Korrektheit von KI-generiertem Code. Wenn Sie beispielsweise die KI neue Funktionalität für ein Modul implementieren lassen, ermöglicht das vorherige Schreiben von Testfällen eine objektive Bewertung, ob der generierte Code wie erwartet funktioniert.
## Balance zwischen Planung und Implementierung
Bevor Sie umfangreiche Funktionen implementieren, empfehle ich, zunächst den Plan mit der KI zu besprechen. Die Organisation von Anforderungen und die Berücksichtigung der Architektur führen zu einer reibungsloseren Implementierung. Eine gute Praxis ist es, zuerst die Anforderungen zusammenzustellen und dann zu einer separaten Chat-Sitzung für die Implementierungsarbeit überzugehen.
## Fazit
Durch die Befolgung dieser Praktiken können Sie die Stärken der KI nutzen und gleichzeitig eine konsistente, hochwertige Codebasis aufbauen. Selbst wenn Ihr Projekt wächst, bleibt jede Komponente gut definiert und handhabbar.
# Kommentarentfernung
Repomix kann beim Generieren der Ausgabedatei automatisch Kommentare aus Ihrer Codebasis entfernen. Dies kann helfen, Störungen zu reduzieren und sich auf den eigentlichen Code zu konzentrieren.
## Verwendung
Um die Kommentarentfernung zu aktivieren, setzen Sie die Option `removeComments` in Ihrer `repomix.config.json` auf `true`:
```json
{
"output": {
"removeComments": true
}
}
```
## Unterstützte Sprachen
Repomix unterstützt die Kommentarentfernung für eine Vielzahl von Programmiersprachen, einschließlich:
- JavaScript/TypeScript (`//`, `/* */`)
- Python (`#`, `"""`, `'''`)
- Java (`//`, `/* */`)
- C/C++ (`//`, `/* */`)
- HTML (``)
- CSS (`/* */`)
- Und viele mehr...
## Beispiel
Gegeben sei der folgende JavaScript-Code:
```javascript
// Dies ist ein einzeiliger Kommentar
function test() {
/* Dies ist ein
mehrzeiliger Kommentar */
return true;
}
```
Mit aktivierter Kommentarentfernung wird die Ausgabe wie folgt aussehen:
```javascript
function test() {
return true;
}
```
## Hinweise
- Die Kommentarentfernung wird vor anderen Verarbeitungsschritten durchgeführt, wie z.B. der Zeilennummerierung.
- Einige Kommentare, wie JSDoc-Kommentare, können je nach Sprache und Kontext erhalten bleiben.
# Benutzerdefinierte Anweisungen
Repomix ermöglicht es Ihnen, benutzerdefinierte Anweisungen bereitzustellen, die in die Ausgabedatei aufgenommen werden. Dies kann nützlich sein, um Kontext oder spezifische Richtlinien für KI-Systeme hinzuzufügen, die das Repository verarbeiten.
## Verwendung
Um eine benutzerdefinierte Anweisung einzufügen, erstellen Sie eine Markdown-Datei (z.B. `repomix-instruction.md`) im Stammverzeichnis Ihres Repositories. Geben Sie dann den Pfad zu dieser Datei in Ihrer `repomix.config.json` an:
```json
{
"output": {
"instructionFilePath": "repomix-instruction.md"
}
}
```
Der Inhalt dieser Datei wird in der Ausgabe unter dem Abschnitt "Instruction" aufgenommen.
## Beispiel
```markdown
# Repository-Anweisungen
Dieses Repository enthält den Quellcode für das Repomix-Tool. Bitte beachten Sie diese Richtlinien bei der Analyse des Codes:
1. Konzentrieren Sie sich auf die Kernfunktionalität im Verzeichnis `src/core`.
2. Achten Sie besonders auf die Sicherheitsprüfungen in `src/core/security`.
3. Ignorieren Sie alle Dateien im Verzeichnis `tests`.
```
Dies führt zu folgendem Abschnitt in der Ausgabe:
```xml
# Repository-Anweisungen
Dieses Repository enthält den Quellcode für das Repomix-Tool. Bitte beachten Sie diese Richtlinien bei der Analyse des Codes:
1. Konzentrieren Sie sich auf die Kernfunktionalität im Verzeichnis `src/core`.
2. Achten Sie besonders auf die Sicherheitsprüfungen in `src/core/security`.
3. Ignorieren Sie alle Dateien im Verzeichnis `tests`.
```
# Installation
## Verwendung von npx (Keine Installation erforderlich)
```bash
npx repomix
```
## Globale Installation
### npm
```bash
npm install -g repomix
```
### Yarn
```bash
yarn global add repomix
```
### Homebrew (macOS/Linux)
```bash
brew install repomix
```
## Docker Installation
Docker-Image herunterladen und ausführen:
```bash
# Aktuelles Verzeichnis
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
# Bestimmtes Verzeichnis
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
# Remote-Repository
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote yamadashy/repomix
```
## VSCode-Erweiterung
Führen Sie Repomix direkt in VSCode mit der von der Community gepflegten [Repomix Runner](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner) Erweiterung aus.
Funktionen:
- Packen Sie jeden Ordner mit wenigen Klicks
- Wählen Sie zwischen Datei- oder Inhaltsmodus zum Kopieren
- Automatische Bereinigung von Ausgabedateien
- Funktioniert mit repomix.config.json
Installieren Sie sie vom [VSCode Marketplace](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner).
## Systemanforderungen
- Node.js: ≥ 18.0.0
- Git: Erforderlich für die Verarbeitung von Remote-Repositories
## Überprüfung
Überprüfen Sie nach der Installation, ob Repomix funktioniert:
```bash
repomix --version
repomix --help
```
# Prompt-Beispiele
## Code-Review
### Architektur-Review
```
Analysieren Sie die Architektur dieser Codebasis:
1. Bewerten Sie die Gesamtstruktur und Muster
2. Identifizieren Sie potenzielle Architekturprobleme
3. Schlagen Sie Verbesserungen für die Skalierbarkeit vor
4. Notieren Sie Bereiche, die Best Practices folgen
Konzentrieren Sie sich auf Wartbarkeit und Modularität.
```
### Sicherheits-Review
```
Führen Sie eine Sicherheitsüberprüfung dieser Codebasis durch:
1. Identifizieren Sie potenzielle Sicherheitslücken
2. Prüfen Sie auf häufige Sicherheits-Anti-Patterns
3. Überprüfen Sie die Fehlerbehandlung und Eingabevalidierung
4. Bewerten Sie die Abhängigkeitssicherheit
Geben Sie konkrete Beispiele und Behebungsschritte an.
```
### Performance-Review
```
Überprüfen Sie die Codebasis auf Leistung:
1. Identifizieren Sie Leistungsengpässe
2. Überprüfen Sie die Ressourcennutzung
3. Überprüfen Sie die algorithmische Effizienz
4. Bewerten Sie Caching-Strategien
Fügen Sie spezifische Optimierungsempfehlungen hinzu.
```
## Dokumentationsgenerierung
### API-Dokumentation
```
Generieren Sie eine umfassende API-Dokumentation:
1. Listen und beschreiben Sie alle öffentlichen Endpunkte
2. Dokumentieren Sie Anfrage-/Antwortformate
3. Fügen Sie Verwendungsbeispiele hinzu
4. Notieren Sie eventuelle Einschränkungen
```
### Entwicklerhandbuch
```
Erstellen Sie ein Entwicklerhandbuch, das Folgendes umfasst:
1. Einrichtungsanweisungen
2. Projektstrukturübersicht
3. Entwicklungsworkflow
4. Testansatz
5. Häufige Fehlerbehebungsschritte
```
### Architektur-Dokumentation
```
Dokumentieren Sie die Systemarchitektur:
1. Überblick auf hoher Ebene
2. Komponenteninteraktionen
3. Datenflussdiagramme
4. Designentscheidungen und Begründung
5. Systembeschränkungen und -grenzen
```
## Analyse und Verbesserung
### Abhängigkeitsanalyse
```
Analysieren Sie die Projektabhängigkeiten:
1. Identifizieren Sie veraltete Pakete
2. Prüfen Sie auf Sicherheitslücken
3. Schlagen Sie alternative Pakete vor
4. Überprüfen Sie Abhängigkeitsnutzungsmuster
Fügen Sie spezifische Upgrade-Empfehlungen hinzu.
```
### Testabdeckung
```
Überprüfen Sie die Testabdeckung:
1. Identifizieren Sie ungetestete Komponenten
2. Schlagen Sie zusätzliche Testfälle vor
3. Überprüfen Sie die Testqualität
4. Empfehlen Sie Teststrategien
```
### Codequalität
```
Bewerten Sie die Codequalität und schlagen Sie Verbesserungen vor:
1. Überprüfen Sie Namenskonventionen
2. Prüfen Sie die Codeorganisation
3. Bewerten Sie die Fehlerbehandlung
4. Überprüfen Sie Kommentierungspraktiken
Geben Sie konkrete Beispiele für gute und problematische Muster an.
```
## Tipps für bessere Ergebnisse
1. **Seien Sie spezifisch**: Formulieren Sie klare Ziele und Bewertungskriterien
2. **Setzen Sie Kontext**: Geben Sie Ihre Rolle und das benötigte Expertiseniveau an
3. **Antwortformat**: Definieren Sie, wie die Antwort strukturiert sein soll
4. **Priorisieren**: Geben Sie an, welche Aspekte am wichtigsten sind
## Modellspezifische Hinweise
### Claude
- Verwenden Sie das XML-Ausgabeformat
- Platzieren Sie wichtige Anweisungen am Ende
- Spezifizieren Sie die Antwortstruktur
### ChatGPT
- Verwenden Sie das Markdown-Format
- Teilen Sie große Codebasen in Abschnitte auf
- Verwenden Sie System-Rollen-Prompts
### Gemini
- Funktioniert mit allen Formaten
- Konzentrieren Sie sich pro Anfrage auf bestimmte Bereiche
- Verwenden Sie schrittweise Analyse
# Remote-Repository-Verarbeitung
## Grundlegende Verwendung
Öffentliche Repositories verarbeiten:
```bash
# Mit vollständiger URL
repomix --remote https://github.com/user/repo
# Mit GitHub-Kurzform
repomix --remote user/repo
```
## Branch- und Commit-Auswahl
```bash
# Bestimmter Branch
repomix --remote user/repo --remote-branch main
# Tag
repomix --remote user/repo --remote-branch v1.0.0
# Commit-Hash
repomix --remote user/repo --remote-branch 935b695
```
## Voraussetzungen
- Git muss installiert sein
- Internetverbindung
- Lesezugriff auf das Repository
## Ausgabekontrolle
```bash
# Benutzerdefinierter Ausgabeort
repomix --remote user/repo -o custom-output.xml
# Mit XML-Format
repomix --remote user/repo --style xml
# Kommentare entfernen
repomix --remote user/repo --remove-comments
```
## Docker-Verwendung
```bash
# Verarbeitung und Ausgabe in das aktuelle Verzeichnis
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
# Ausgabe in bestimmtes Verzeichnis
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
```
## Häufige Probleme
### Zugriffsprobleme
- Stellen Sie sicher, dass das Repository öffentlich ist
- Überprüfen Sie die Git-Installation
- Überprüfen Sie die Internetverbindung
### Große Repositories
- Verwenden Sie `--include`, um bestimmte Pfade auszuwählen
- Aktivieren Sie `--remove-comments`
- Verarbeiten Sie Branches separat
# Sicherheit
## Sicherheitsprüfungsfunktion
Repomix verwendet [Secretlint](https://github.com/secretlint/secretlint) zur Erkennung sensibler Informationen in Ihren Dateien:
- API-Schlüssel
- Zugangstoken
- Anmeldedaten
- Private Schlüssel
- Umgebungsvariablen
## Konfiguration
Sicherheitsprüfungen sind standardmäßig aktiviert.
Deaktivierung über CLI:
```bash
repomix --no-security-check
```
Oder in `repomix.config.json`:
```json
{
"security": {
"enableSecurityCheck": false
}
}
```
## Sicherheitsmaßnahmen
1. **Ausschluss von Binärdateien**: Binärdateien werden nicht in die Ausgabe aufgenommen
2. **Git-bewusst**: Berücksichtigt `.gitignore`-Muster
3. **Automatische Erkennung**: Sucht nach häufigen Sicherheitsproblemen:
- AWS-Anmeldedaten
- Datenbankverbindungszeichenfolgen
- Authentifizierungstoken
- Private Schlüssel
## Wenn die Sicherheitsprüfung Probleme findet
Beispielausgabe:
```bash
🔍 Sicherheitsprüfung:
──────────────────
2 verdächtige Datei(en) erkannt und ausgeschlossen:
1. config/credentials.json
- AWS-Zugriffsschlüssel gefunden
2. .env.local
- Datenbank-Passwort gefunden
```
## Best Practices
1. Überprüfen Sie die Ausgabe immer vor dem Teilen
2. Verwenden Sie `.repomixignore` für sensible Pfade
3. Lassen Sie Sicherheitsprüfungen aktiviert
4. Entfernen Sie sensible Dateien aus dem Repository
## Melden von Sicherheitsproblemen
Haben Sie eine Sicherheitslücke gefunden? Bitte:
1. Öffnen Sie kein öffentliches Issue
2. E-Mail: koukun0120@gmail.com
3. Oder nutzen Sie [GitHub Security Advisories](https://github.com/yamadashy/repomix/security/advisories/new)
---
layout: home
title: Repomix
titleTemplate: Packen Sie Ihren Codebase in KI-freundliche Formate
aside: false
editLink: false
features:
- icon: 🤖
title: KI-Optimiert
details: Formatiert Ihren Codebase so, dass er für KI leicht zu verstehen und zu verarbeiten ist.
- icon: ⚙️
title: Git-Bewusst
details: Berücksichtigt automatisch Ihre .gitignore-Dateien.
- icon: 🛡️
title: Sicherheitsorientiert
details: Integriert Secretlint für robuste Sicherheitsprüfungen zur Erkennung und Verhinderung der Aufnahme sensibler Informationen.
- icon: 📊
title: Token-Zählung
details: Bietet Token-Zählungen für jede Datei und das gesamte Repository, nützlich für LLM-Kontextgrenzen.
---
## Schnellstart
Sobald Sie mit Repomix eine gepackte Datei (`repomix-output.txt`) erstellt haben, können Sie diese mit einer Aufforderung wie dieser an einen KI-Assistenten senden:
```
Diese Datei enthält alle Dateien im Repository in einer Datei zusammengefasst.
Ich möchte den Code refaktorieren, bitte überprüfen Sie ihn zuerst.
```
Die KI wird Ihren gesamten Codebase analysieren und umfassende Einblicke geben:
Bei der Diskussion spezifischer Änderungen kann die KI bei der Code-Generierung helfen. Mit Funktionen wie Claudes Artifacts können Sie sogar mehrere voneinander abhängige Dateien erhalten:
Viel Spaß beim Programmieren! 🚀
## Leitfaden für fortgeschrittene Benutzer
Für fortgeschrittene Benutzer, die mehr Kontrolle benötigen, bietet Repomix umfangreiche Anpassungsmöglichkeiten über seine CLI-Schnittstelle.
### Schnellstart
Sie können Repomix sofort in Ihrem Projektverzeichnis ohne Installation ausprobieren:
```bash
npx repomix
```
Oder installieren Sie es global für wiederholte Verwendung:
```bash
# Installation mit npm
npm install -g repomix
# Alternativ mit yarn
yarn global add repomix
# Alternativ mit Homebrew (macOS/Linux)
brew install repomix
# Dann in einem beliebigen Projektverzeichnis ausführen
repomix
```
Das war's! Repomix generiert eine `repomix-output.txt` Datei in Ihrem aktuellen Verzeichnis, die Ihr gesamtes Repository in einem KI-freundlichen Format enthält.
### Verwendung
Um Ihr gesamtes Repository zu packen:
```bash
repomix
```
Um ein bestimmtes Verzeichnis zu packen:
```bash
repomix path/to/directory
```
Um bestimmte Dateien oder Verzeichnisse mit [Glob-Mustern](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax) zu packen:
```bash
repomix --include "src/**/*.ts,**/*.md"
```
Um bestimmte Dateien oder Verzeichnisse auszuschließen:
```bash
repomix --ignore "**/*.log,tmp/"
```
Um ein Remote-Repository zu packen:
```bash
# Kurzform verwenden
npx repomix --remote yamadashy/repomix
# Vollständige URL verwenden (unterstützt Branches und spezifische Pfade)
npx repomix --remote https://github.com/yamadashy/repomix
npx repomix --remote https://github.com/yamadashy/repomix/tree/main
# Commit-URL verwenden
npx repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
```
Um eine neue Konfigurationsdatei (`repomix.config.json`) zu initialisieren:
```bash
repomix --init
```
Sobald Sie die gepackte Datei erstellt haben, können Sie sie mit generativen KI-Tools wie Claude, ChatGPT und Gemini verwenden.
#### Docker-Verwendung
Sie können Repomix auch mit Docker ausführen 🐳
Dies ist nützlich, wenn Sie Repomix in einer isolierten Umgebung ausführen oder Container bevorzugen.
Grundlegende Verwendung (aktuelles Verzeichnis):
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
Um ein bestimmtes Verzeichnis zu packen:
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
```
Ein Remote-Repository verarbeiten und in ein `output`-Verzeichnis ausgeben:
```bash
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix
```
### Ausgabeformate
Wählen Sie Ihr bevorzugtes Ausgabeformat:
```bash
# XML-Format (Standard)
repomix --style xml
# Markdown-Format
repomix --style markdown
# Klartext-Format
repomix --style plain
```
### Anpassung
Erstellen Sie eine `repomix.config.json` für dauerhafte Einstellungen:
```json
{
"output": {
"style": "markdown",
"filePath": "custom-output.md",
"removeComments": true,
"showLineNumbers": true,
"topFilesLength": 10
},
"ignore": {
"customPatterns": ["*.test.ts", "docs/**"]
}
}
```
### Weitere Beispiele
::: tip
💡 Besuchen Sie unser [GitHub-Repository](https://github.com/yamadashy/repomix) für vollständige Dokumentation und weitere Beispiele!
:::
# Contributing to Repomix
## Quick Start
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
npm install
```
## Development Commands
```bash
# Run CLI
npm run repomix
# Run tests
npm run test
npm run test-coverage
# Lint code
npm run lint
```
## Code Style
- Use [Biome](https://biomejs.dev/) for linting and formatting
- Dependency injection for testability
- Keep files under 250 lines
- Add tests for new features
## Pull Request Guidelines
1. Run all tests
2. Pass linting checks
3. Update documentation
4. Follow existing code style
## Need Help?
- [Open an issue](https://github.com/yamadashy/repomix/issues)
- [Join Discord](https://discord.gg/wNYzTwZFku)
# Development Setup
## Prerequisites
- Node.js ≥ 18.0.0
- Git
- npm
## Local Development
```bash
# Clone repository
git clone https://github.com/yamadashy/repomix.git
cd repomix
# Install dependencies
npm install
# Run CLI
npm run repomix
```
## Docker Development
```bash
# Build image
docker build -t repomix .
# Run container
docker run -v ./:/app -it --rm repomix
```
## Project Structure
```
src/
├── cli/ # CLI implementation
├── config/ # Configuration handling
├── core/ # Core functionality
└── shared/ # Shared utilities
```
## Testing
```bash
# Run tests
npm run test
# Test coverage
npm run test-coverage
# Linting
npm run lint-biome
npm run lint-ts
npm run lint-secretlint
```
## Release Process
1. Update version
```bash
npm version patch # or minor/major
```
2. Run tests and build
```bash
npm run test-coverage
npm run build
```
3. Publish
```bash
npm publish
```
# AI-Assisted Development Best Practices: From My Experience
While I haven't successfully completed a large-scale project using AI yet, I'd like to share what I've learned so far from my experience working with AI in development.
## Basic Development Approach
When working with AI, attempting to implement all features at once can lead to unexpected issues and project stagnation. That's why it's more effective to start with core functionality and build each feature one at a time, ensuring solid implementation before moving forward.
### The Power of Existing Code
This approach is effective because implementing core functionality allows you to materialize your ideal design and coding style through actual code. The most effective way to communicate your project vision is through code that reflects your standards and preferences.
By starting with core features and ensuring each component works properly before moving on, the entire project maintains consistency, making it easier for AI to generate more appropriate code.
## The Modular Approach
Breaking code into smaller modules is crucial. In my experience, keeping files around 250 lines of code makes it easier to give clear instructions to AI and makes the trial-and-error process more efficient. While token count would be a more accurate metric, line count is more practical for human developers to work with, so we use that as a guideline.
This modularization isn't just about separating frontend, backend, and database components - it's about breaking down functionality at a much finer level. For example, within a single feature, you might separate validation, error handling, and other specific functionalities into distinct modules. Of course, high-level separation is also important, and implementing this modular approach gradually helps maintain clear instructions and enables AI to generate more appropriate code. This approach is effective not just for AI but for human developers as well.
## Ensuring Quality Through Testing
I consider testing to be crucial in AI-assisted development. Tests serve not only as quality assurance measures but also as documentation that clearly demonstrates code intentions. When asking AI to implement new features, existing test code effectively acts as a specification document.
Tests are also an excellent tool for validating the correctness of AI-generated code. For instance, when having AI implement new functionality for a module, writing test cases beforehand allows you to objectively evaluate whether the generated code behaves as expected. This aligns well with Test-Driven Development (TDD) principles and is particularly effective when collaborating with AI.
## Balancing Planning and Implementation
Before implementing large-scale features, I recommend first discussing the plan with AI. Organizing requirements and considering architecture leads to smoother implementation. A good practice is to compile requirements first, then move to a separate chat session for implementation work.
It's essential to have human review of AI output and make adjustments as needed. While the quality of AI-generated code is generally moderate, it still accelerates development compared to writing everything from scratch.
## Conclusion
By following these practices, you can leverage AI's strengths while building a consistent, high-quality codebase. Even as your project grows in size, each component remains well-defined and manageable.
# Comment Removal
Repomix can automatically remove comments from your codebase when generating the output file. This can help reduce noise and focus on the actual code.
## Usage
To enable comment removal, set the `removeComments` option to `true` in your `repomix.config.json`:
```json
{
"output": {
"removeComments": true
}
}
```
## Supported Languages
Repomix supports comment removal for a wide range of programming languages, including:
- JavaScript/TypeScript (`//`, `/* */`)
- Python (`#`, `"""`, `'''`)
- Java (`//`, `/* */`)
- C/C++ (`//`, `/* */`)
- HTML (``)
- CSS (`/* */`)
- And many more...
## Example
Given the following JavaScript code:
```javascript
// This is a single-line comment
function test() {
/* This is a
multi-line comment */
return true;
}
```
With comment removal enabled, the output will be:
```javascript
function test() {
return true;
}
```
## Notes
- Comment removal is performed before other processing steps, such as line number addition.
- Some comments, such as JSDoc comments, may be preserved depending on the language and context.
# Custom Instructions
Repomix allows you to provide custom instructions that will be included in the output file. This can be useful for adding context or specific guidelines for AI systems processing the repository.
## Usage
To include a custom instruction, create a markdown file (e.g., `repomix-instruction.md`) in the root of your repository. Then, specify the path to this file in your `repomix.config.json`:
```json
{
"output": {
"instructionFilePath": "repomix-instruction.md"
}
}
```
The content of this file will be included in the output under the "Instruction" section.
## Example
```markdown
# Repository Instructions
This repository contains the source code for the Repomix tool. Please follow these guidelines when analyzing the code:
1. Focus on the core functionality in the `src/core` directory.
2. Pay special attention to the security checks in `src/core/security`.
3. Ignore any files in the `tests` directory.
```
This will result in the following section in the output:
```xml
# Repository Instructions
This repository contains the source code for the Repomix tool. Please follow these guidelines when analyzing the code:
1. Focus on the core functionality in the `src/core` directory.
2. Pay special attention to the security checks in `src/core/security`.
3. Ignore any files in the `tests` directory.
```
# Installation
## Using npx (No Installation Required)
```bash
npx repomix
```
## Global Installation
### npm
```bash
npm install -g repomix
```
### Yarn
```bash
yarn global add repomix
```
### Homebrew (macOS/Linux)
```bash
brew install repomix
```
## Docker Installation
Pull and run the Docker image:
```bash
# Current directory
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
# Specific directory
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
# Remote repository
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote yamadashy/repomix
```
## VSCode Extension
Run Repomix directly in VSCode with the community-maintained [Repomix Runner](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner) extension.
Features:
- Pack any folder with just a few clicks
- Choose between file or content mode for copying
- Automatic cleanup of output files
- Works with repomix.config.json
Install it from the [VSCode Marketplace](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner).
## System Requirements
- Node.js: ≥ 18.0.0
- Git: Required for remote repository processing
## Verification
After installation, verify that Repomix is working:
```bash
repomix --version
repomix --help
```
# Prompt Examples
## Code Review
### Architecture Review
```
Analyze this codebase's architecture:
1. Evaluate the overall structure and patterns
2. Identify potential architectural issues
3. Suggest improvements for scalability
4. Note areas that follow best practices
Focus on maintainability and modularity.
```
### Security Review
```
Perform a security review of this codebase:
1. Identify potential security vulnerabilities
2. Check for common security anti-patterns
3. Review error handling and input validation
4. Assess dependency security
Provide specific examples and remediation steps.
```
### Performance Review
```
Review the codebase for performance:
1. Identify performance bottlenecks
2. Check resource utilization
3. Review algorithmic efficiency
4. Assess caching strategies
Include specific optimization recommendations.
```
## Documentation Generation
### API Documentation
```
Generate comprehensive API documentation:
1. List and describe all public endpoints
2. Document request/response formats
3. Include usage examples
4. Note any limitations or constraints
```
### Developer Guide
```
Create a developer guide covering:
1. Setup instructions
2. Project structure overview
3. Development workflow
4. Testing approach
5. Common troubleshooting steps
```
### Architecture Documentation
```
Document the system architecture:
1. High-level overview
2. Component interactions
3. Data flow diagrams
4. Design decisions and rationale
5. System constraints and limitations
```
## Analysis and Improvement
### Dependency Analysis
```
Analyze the project dependencies:
1. Identify outdated packages
2. Check for security vulnerabilities
3. Suggest alternative packages
4. Review dependency usage patterns
Include specific upgrade recommendations.
```
### Test Coverage
```
Review the test coverage:
1. Identify untested components
2. Suggest additional test cases
3. Review test quality
4. Recommend testing strategies
```
### Code Quality
```
Assess code quality and suggest improvements:
1. Review naming conventions
2. Check code organization
3. Evaluate error handling
4. Review commenting practices
Provide specific examples of good and problematic patterns.
```
## Tips for Better Results
1. **Be Specific**: Include clear objectives and evaluation criteria
2. **Set Context**: Specify your role and expertise level needed
3. **Request Format**: Define how you want the response structured
4. **Prioritize**: Indicate which aspects are most important
## Model-Specific Notes
### Claude
- Use XML output format
- Place important instructions at the end
- Specify response structure
### ChatGPT
- Use Markdown format
- Break large codebases into sections
- Include system role prompts
### Gemini
- Works with all formats
- Focus on specific areas per request
- Use step-by-step analysis
# Remote Repository Processing
## Basic Usage
Process public repositories:
```bash
# Using full URL
repomix --remote https://github.com/user/repo
# Using GitHub shorthand
repomix --remote user/repo
```
## Branch and Commit Selection
```bash
# Specific branch
repomix --remote user/repo --remote-branch main
# Tag
repomix --remote user/repo --remote-branch v1.0.0
# Commit hash
repomix --remote user/repo --remote-branch 935b695
```
## Requirements
- Git must be installed
- Internet connection
- Read access to repository
## Output Control
```bash
# Custom output location
repomix --remote user/repo -o custom-output.xml
# With XML format
repomix --remote user/repo --style xml
# Remove comments
repomix --remote user/repo --remove-comments
```
## Docker Usage
```bash
# Process and output to current directory
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
# Output to specific directory
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
```
## Common Issues
### Access Issues
- Ensure repository is public
- Check Git installation
- Verify internet connection
### Large Repositories
- Use `--include` to select specific paths
- Enable `--remove-comments`
- Process branches separately
# Security
## Security Check Feature
Repomix uses [Secretlint](https://github.com/secretlint/secretlint) to detect sensitive information in your files:
- API keys
- Access tokens
- Credentials
- Private keys
- Environment variables
## Configuration
Security checks are enabled by default.
Disable via CLI:
```bash
repomix --no-security-check
```
Or in `repomix.config.json`:
```json
{
"security": {
"enableSecurityCheck": false
}
}
```
## Security Measures
1. **Binary File Exclusion**: Binary files are not included in output
2. **Git-Aware**: Respects `.gitignore` patterns
3. **Automated Detection**: Scans for common security issues:
- AWS credentials
- Database connection strings
- Authentication tokens
- Private keys
## When Security Check Finds Issues
Example output:
```bash
🔍 Security Check:
──────────────────
2 suspicious file(s) detected and excluded:
1. config/credentials.json
- Found AWS access key
2. .env.local
- Found database password
```
## Best Practices
1. Always review output before sharing
2. Use `.repomixignore` for sensitive paths
3. Keep security checks enabled
4. Remove sensitive files from repository
## Reporting Security Issues
Found a security vulnerability? Please:
1. Do not open a public issue
2. Email: koukun0120@gmail.com
3. Or use [GitHub Security Advisories](https://github.com/yamadashy/repomix/security/advisories/new)
---
layout: home
title: Repomix
titleTemplate: Pack your codebase into AI-friendly formats
aside: false
editLink: false
features:
- icon: 🤖
title: AI-Optimized
details: Formats your codebase in a way that's easy for AI to understand and process.
- icon: ⚙️
title: Git-Aware
details: Automatically respects your .gitignore files.
- icon: 🛡️
title: Security-Focused
details: Incorporates Secretlint for robust security checks to detect and prevent inclusion of sensitive information.
- icon: 📊
title: Token Counting
details: Provides token counts for each file and the entire repository, useful for LLM context limits.
---
## Quick Start
Once you've generated a packed file (`repomix-output.txt`) using Repomix, you can send it 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.
```
The AI will analyze your entire codebase and provide comprehensive insights:
When discussing specific changes, the AI can help generate code. With features like Claude's Artifacts, you can even receive multiple interdependent files:
Happy coding! 🚀
## Power User Guide
For advanced users who need more control, Repomix offers extensive customization options through its CLI interface.
### Quick Start
You can try Repomix instantly in your project directory without installation:
```bash
npx repomix
```
Or install globally for repeated use:
```bash
# Install using npm
npm install -g repomix
# Alternatively using yarn
yarn global add 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.txt` file in your current directory, containing your entire repository in an AI-friendly format.
### Usage
To pack your entire repository:
```bash
repomix
```
To pack a specific directory:
```bash
repomix path/to/directory
```
To pack specific files or directories using [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
To exclude specific files or directories:
```bash
repomix --ignore "**/*.log,tmp/"
```
To pack a remote repository:
```bash
# Using shorthand format
npx repomix --remote yamadashy/repomix
# Using full URL (supports branches and specific paths)
npx repomix --remote https://github.com/yamadashy/repomix
npx repomix --remote https://github.com/yamadashy/repomix/tree/main
# Using commit's URL
npx repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
```
To initialize a new configuration file (`repomix.config.json`):
```bash
repomix --init
```
Once you have generated the packed file, you can use it with Generative AI tools like Claude, ChatGPT, and Gemini.
#### 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):
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
To pack a specific directory:
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
```
Process a remote repository and output to a `output` directory:
```bash
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix
```
### Output Formats
Choose your preferred output format:
```bash
# XML format (default)
repomix --style xml
# Markdown format
repomix --style markdown
# Plain text format
repomix --style plain
```
### Customization
Create a `repomix.config.json` for persistent settings:
```json
{
"output": {
"style": "markdown",
"filePath": "custom-output.md",
"removeComments": true,
"showLineNumbers": true,
"topFilesLength": 10
},
"ignore": {
"customPatterns": ["*.test.ts", "docs/**"]
}
}
```
### More Examples
::: tip
💡 Check out our [GitHub repository](https://github.com/yamadashy/repomix) for complete documentation and more examples!
:::
# Contribuir a Repomix
## Inicio rápido
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
npm install
```
## Comandos de desarrollo
```bash
# Ejecutar CLI
npm run repomix
# Ejecutar pruebas
npm run test
npm run test-coverage
# Linting de código
npm run lint
```
## Estilo de código
- Usa [Biome](https://biomejs.dev/) para linting y formateo
- Inyección de dependencias para la testabilidad
- Mantén los archivos por debajo de las 250 líneas
- Agrega pruebas para las nuevas funciones
## Pautas para Pull Requests
1. Ejecuta todas las pruebas
2. Pasa las comprobaciones de linting
3. Actualiza la documentación
4. Sigue el estilo de código existente
## ¿Necesitas ayuda?
- [Abre un issue](https://github.com/yamadashy/repomix/issues)
- [Únete a Discord](https://discord.gg/wNYzTwZFku)
# Configuración del entorno de desarrollo
## Requisitos previos
- Node.js ≥ 18.0.0
- Git
- npm
## Desarrollo local
```bash
# Clonar el repositorio
git clone https://github.com/yamadashy/repomix.git
cd repomix
# Instalar dependencias
npm install
# Ejecutar CLI
npm run repomix
```
## Desarrollo con Docker
```bash
# Construir la imagen
docker build -t repomix .
# Ejecutar el contenedor
docker run -v ./:/app -it --rm repomix
```
## Estructura del proyecto
```
src/
├── cli/ # Implementación de la CLI
├── config/ # Manejo de la configuración
├── core/ # Funcionalidad principal
└── shared/ # Utilidades compartidas
```
## Pruebas
```bash
# Ejecutar pruebas
npm run test
# Cobertura de pruebas
npm run test-coverage
# Linting
npm run lint-biome
npm run lint-ts
npm run lint-secretlint
```
## Proceso de lanzamiento
1. Actualizar la versión
```bash
npm version patch # o minor/major
```
2. Ejecutar pruebas y construir
```bash
npm run test-coverage
npm run build
```
3. Publicar
```bash
npm publish
# Mejores prácticas para el desarrollo asistido por IA: Desde mi experiencia
Aunque todavía no he completado con éxito un proyecto a gran escala utilizando IA, me gustaría compartir lo que he aprendido hasta ahora de mi experiencia trabajando con IA en el desarrollo.
## Enfoque de desarrollo básico
Cuando se trabaja con IA, intentar implementar todas las funciones a la vez puede llevar a problemas inesperados y al estancamiento del proyecto. Por eso es más efectivo comenzar con la funcionalidad principal y construir cada función una por una, asegurando una implementación sólida antes de seguir adelante.
### El poder del código existente
Este enfoque es efectivo porque implementar la funcionalidad principal te permite materializar tu diseño ideal y estilo de codificación a través de código real. La forma más efectiva de comunicar la visión de tu proyecto es a través de código que refleje tus estándares y preferencias.
Al comenzar con las funciones principales y asegurar que cada componente funcione correctamente antes de continuar, todo el proyecto mantiene la consistencia, lo que facilita que la IA genere código más apropiado.
## El enfoque modular
Dividir el código en módulos más pequeños es crucial. En mi experiencia, mantener los archivos alrededor de 250 líneas de código facilita dar instrucciones claras a la IA y hace que el proceso de prueba y error sea más eficiente. Si bien el recuento de tokens sería una métrica más precisa, el recuento de líneas es más práctico para los desarrolladores humanos, por lo que lo usamos como una guía.
Esta modularización no se trata solo de separar los componentes de frontend, backend y base de datos, sino de desglosar la funcionalidad a un nivel mucho más fino. Por ejemplo, dentro de una sola función, podrías separar la validación, el manejo de errores y otras funcionalidades específicas en módulos distintos. Por supuesto, la separación de alto nivel también es importante, e implementar este enfoque modular gradualmente ayuda a mantener instrucciones claras y permite que la IA genere código más apropiado. Este enfoque es efectivo no solo para la IA sino también para los desarrolladores humanos.
## Asegurar la calidad a través de las pruebas
Considero que las pruebas son cruciales en el desarrollo asistido por IA. Las pruebas no solo sirven como medidas de garantía de calidad, sino también como documentación que demuestra claramente las intenciones del código. Al pedirle a la IA que implemente nuevas funciones, el código de prueba existente actúa efectivamente como un documento de especificación.
Las pruebas también son una excelente herramienta para validar la corrección del código generado por IA. Por ejemplo, al hacer que la IA implemente una nueva funcionalidad para un módulo, escribir casos de prueba de antemano te permite evaluar objetivamente si el código generado se comporta como se espera. Esto se alinea bien con los principios de desarrollo basado en pruebas (TDD) y es particularmente efectivo cuando se colabora con la IA.
## Equilibrar la planificación y la implementación
Antes de implementar funciones a gran escala, recomiendo discutir primero el plan con la IA. Organizar los requisitos y considerar la arquitectura conduce a una implementación más fluida. Una buena práctica es compilar primero los requisitos y luego pasar a una sesión de chat separada para el trabajo de implementación.
Es esencial que un humano revise el resultado de la IA y haga los ajustes necesarios. Si bien la calidad del código generado por IA es generalmente moderada, aún acelera el desarrollo en comparación con escribir todo desde cero.
## Conclusión
Siguiendo estas prácticas, puedes aprovechar las fortalezas de la IA mientras construyes una base de código consistente y de alta calidad. Incluso a medida que tu proyecto crece en tamaño, cada componente permanece bien definido y manejable.
# Eliminación de comentarios
Repomix puede eliminar automáticamente los comentarios de tu código al generar el archivo de salida. Esto puede ayudar a reducir el ruido y centrarse en el código real.
## Uso
Para habilitar la eliminación de comentarios, establece la opción `removeComments` a `true` en tu archivo `repomix.config.json`:
```json
{
"output": {
"removeComments": true
}
}
```
## Lenguajes soportados
Repomix soporta la eliminación de comentarios para una amplia gama de lenguajes de programación, incluyendo:
- JavaScript/TypeScript (`//`, `/* */`)
- Python (`#`, `"""`, `'''`)
- Java (`//`, `/* */`)
- C/C++ (`//`, `/* */`)
- HTML (``)
- CSS (`/* */`)
- Y muchos más...
## Ejemplo
Dado el siguiente código JavaScript:
```javascript
// Este es un comentario de una sola línea
function test() {
/* Este es un
comentario multilínea */
return true;
}
```
Con la eliminación de comentarios habilitada, la salida será:
```javascript
function test() {
return true;
}
```
## Notas
- La eliminación de comentarios se realiza antes que otros pasos de procesamiento, como la adición de números de línea.
- Algunos comentarios, como los comentarios JSDoc, pueden conservarse dependiendo del lenguaje y el contexto.
# Instrucciones Personalizadas
Repomix te permite proporcionar instrucciones personalizadas que se incluirán en el archivo de salida. Esto puede ser útil para agregar contexto o pautas específicas para los sistemas de IA que procesan el repositorio.
## Uso
Para incluir una instrucción personalizada, crea un archivo markdown (por ejemplo, `repomix-instruction.md`) en la raíz de tu repositorio. Luego, especifica la ruta a este archivo en tu `repomix.config.json`:
```json
{
"output": {
"instructionFilePath": "repomix-instruction.md"
}
}
```
El contenido de este archivo se incluirá en la salida bajo la sección "Instruction".
## Ejemplo
```markdown
# Instrucciones del Repositorio
Este repositorio contiene el código fuente de la herramienta Repomix. Por favor, sigue estas pautas al analizar el código:
1. Concéntrate en la funcionalidad principal en el directorio `src/core`.
2. Presta especial atención a las verificaciones de seguridad en `src/core/security`.
3. Ignora cualquier archivo en el directorio `tests`.
```
Esto resultará en la siguiente sección en la salida:
```xml
# Instrucciones del Repositorio
Este repositorio contiene el código fuente de la herramienta Repomix. Por favor, sigue estas pautas al analizar el código:
1. Concéntrate en la funcionalidad principal en el directorio `src/core`.
2. Presta especial atención a las verificaciones de seguridad en `src/core/security`.
3. Ignora cualquier archivo en el directorio `tests`.
# Instalación
## Usando npx (no requiere instalación)
```bash
npx repomix
```
## Instalación global
### npm
```bash
npm install -g repomix
```
### Yarn
```bash
yarn global add repomix
```
### Homebrew (macOS/Linux)
```bash
brew install repomix
```
## Instalación con Docker
Extrae y ejecuta la imagen de Docker:
```bash
# Directorio actual
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
# Directorio específico
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix ruta/al/directorio
# Repositorio remoto
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote yamadashy/repomix
```
## Extensión de VSCode
Ejecuta Repomix directamente en VSCode con la extensión [Repomix Runner](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner) mantenida por la comunidad.
Características:
- Empaqueta cualquier carpeta con unos pocos clics
- Elige entre modo archivo o contenido para copiar
- Limpieza automática de archivos de salida
- Compatible con repomix.config.json
Instálala desde el [VSCode Marketplace](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner).
## Requisitos del sistema
- Node.js: ≥ 18.0.0
- Git: Requerido para el procesamiento de repositorios remotos
## Verificación
Después de la instalación, verifica que Repomix esté funcionando:
```bash
repomix --version
repomix --help
# Ejemplos de prompts
## Revisión de código
### Revisión de arquitectura
```
Analiza la arquitectura de esta base de código:
1. Evalúa la estructura general y los patrones
2. Identifica posibles problemas de arquitectura
3. Sugiere mejoras para la escalabilidad
4. Señala las áreas que siguen las mejores prácticas
Concéntrate en la mantenibilidad y la modularidad.
```
### Revisión de seguridad
```
Realiza una revisión de seguridad de esta base de código:
1. Identifica posibles vulnerabilidades de seguridad
2. Busca antipatrones de seguridad comunes
3. Revisa el manejo de errores y la validación de entradas
4. Evalúa la seguridad de las dependencias
Proporciona ejemplos específicos y pasos de remediación.
```
### Revisión de rendimiento
```
Revisa el rendimiento de la base de código:
1. Identifica cuellos de botella de rendimiento
2. Comprueba la utilización de recursos
3. Revisa la eficiencia algorítmica
4. Evalúa las estrategias de almacenamiento en caché
Incluye recomendaciones de optimización específicas.
```
## Generación de documentación
### Documentación de API
```
Genera documentación de API completa:
1. Enumera y describe todos los endpoints públicos
2. Documenta los formatos de solicitud/respuesta
3. Incluye ejemplos de uso
4. Señala cualquier limitación o restricción
```
### Guía para desarrolladores
```
Crea una guía para desarrolladores que cubra:
1. Instrucciones de configuración
2. Descripción general de la estructura del proyecto
3. Flujo de trabajo de desarrollo
4. Enfoque de pruebas
5. Pasos comunes para la solución de problemas
```
### Documentación de arquitectura
```
Documenta la arquitectura del sistema:
1. Descripción general de alto nivel
2. Interacciones entre componentes
3. Diagramas de flujo de datos
4. Decisiones de diseño y justificación
5. Restricciones y limitaciones del sistema
```
## Análisis y mejora
### Análisis de dependencias
```
Analiza las dependencias del proyecto:
1. Identifica paquetes obsoletos
2. Busca vulnerabilidades de seguridad
3. Sugiere paquetes alternativos
4. Revisa los patrones de uso de dependencias
Incluye recomendaciones de actualización específicas.
```
### Cobertura de pruebas
```
Revisa la cobertura de pruebas:
1. Identifica componentes no probados
2. Sugiere casos de prueba adicionales
3. Revisa la calidad de las pruebas
4. Recomienda estrategias de prueba
```
### Calidad del código
```
Evalúa la calidad del código y sugiere mejoras:
1. Revisa las convenciones de nomenclatura
2. Comprueba la organización del código
3. Evalúa el manejo de errores
4. Revisa las prácticas de comentarios
Proporciona ejemplos específicos de patrones buenos y problemáticos.
```
## Consejos para obtener mejores resultados
1. **Sé específico**: Incluye objetivos claros y criterios de evaluación
2. **Establece el contexto**: Especifica tu rol y el nivel de experiencia necesario
3. **Solicita un formato**: Define cómo quieres que se estructure la respuesta
4. **Prioriza**: Indica qué aspectos son más importantes
## Notas específicas del modelo
### Claude
- Usa el formato de salida XML
- Coloca las instrucciones importantes al final
- Especifica la estructura de la respuesta
### ChatGPT
- Usa el formato Markdown
- Divide las bases de código grandes en secciones
- Incluye prompts de rol del sistema
### Gemini
- Funciona con todos los formatos
- Concéntrate en áreas específicas por solicitud
- Usa un análisis paso a paso
# Procesamiento de repositorios remotos
## Uso básico
Procesar repositorios públicos:
```bash
# Usando URL completo
repomix --remote https://github.com/usuario/repositorio
# Usando la abreviatura de GitHub
repomix --remote usuario/repositorio
```
## Selección de rama y commit
```bash
# Rama específica
repomix --remote usuario/repositorio --remote-branch main
# Etiqueta
repomix --remote usuario/repositorio --remote-branch v1.0.0
# Hash de commit
repomix --remote usuario/repositorio --remote-branch 935b695
```
## Requisitos
- Git debe estar instalado
- Conexión a Internet
- Acceso de lectura al repositorio
## Control de salida
```bash
# Ubicación de salida personalizada
repomix --remote usuario/repositorio -o salida-personalizada.xml
# Con formato XML
repomix --remote usuario/repositorio --style xml
# Eliminar comentarios
repomix --remote usuario/repositorio --remove-comments
```
## Uso de Docker
```bash
# Procesar y generar la salida en el directorio actual
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix \
--remote usuario/repositorio
# Generar la salida en un directorio específico
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix \
--remote usuario/repositorio
```
## Problemas comunes
### Problemas de acceso
- Asegúrate de que el repositorio sea público
- Comprueba la instalación de Git
- Verifica la conexión a Internet
### Repositorios grandes
- Usa `--include` para seleccionar rutas específicas
- Habilita `--remove-comments`
- Procesa las ramas por separado
# Seguridad
## Función de verificación de seguridad
Repomix utiliza [Secretlint](https://github.com/secretlint/secretlint) para detectar información sensible en tus archivos:
- Claves de API
- Tokens de acceso
- Credenciales
- Claves privadas
- Variables de entorno
## Configuración
Las verificaciones de seguridad están habilitadas de forma predeterminada.
Deshabilitar a través de CLI:
```bash
repomix --no-security-check
```
O en `repomix.config.json`:
```json
{
"security": {
"enableSecurityCheck": false
}
}
```
## Medidas de seguridad
1. **Exclusión de archivos binarios**: Los archivos binarios no se incluyen en la salida
2. **Compatible con Git**: Respeta los patrones de `.gitignore`
3. **Detección automatizada**: Busca problemas de seguridad comunes:
- Credenciales de AWS
- Cadenas de conexión de bases de datos
- Tokens de autenticación
- Claves privadas
## Cuando la verificación de seguridad encuentra problemas
Ejemplo de salida:
```bash
🔍 Verificación de seguridad:
──────────────────
2 archivo(s) sospechoso(s) detectado(s) y excluido(s):
1. config/credentials.json
- Se encontró la clave de acceso de AWS
2. .env.local
- Se encontró la contraseña de la base de datos
```
## Mejores prácticas
1. Siempre revisa la salida antes de compartirla
2. Usa `.repomixignore` para rutas sensibles
3. Mantén las verificaciones de seguridad habilitadas
4. Elimina los archivos sensibles del repositorio
## Reportar problemas de seguridad
¿Encontraste una vulnerabilidad de seguridad? Por favor:
1. No abras un issue público
2. Envía un correo electrónico a: koukun0120@gmail.com
3. O usa [GitHub Security Advisories](https://github.com/yamadashy/repomix/security/advisories/new)
---
layout: home
title: Repomix
titleTemplate: Empaqueta tu código en formatos amigables para la IA
aside: false
editLink: false
features:
- icon: 🤖
title: Optimizado para IA
details: Formatea tu código de una manera que sea fácil de entender y procesar para la IA.
- icon: ⚙️
title: Compatible con Git
details: Respeta automáticamente tus archivos .gitignore.
- icon: 🛡️
title: Enfocado en la seguridad
details: Incorpora Secretlint para realizar robustas comprobaciones de seguridad que detectan y previenen la inclusión de información sensible.
- icon: 📊
title: Conteo de tokens
details: Proporciona recuentos de tokens para cada archivo y para todo el repositorio, útil para los límites de contexto de los LLM.
---
## Inicio rápido
Una vez que hayas generado un archivo empaquetado (`repomix-output.txt`) usando Repomix, puedes enviarlo a un asistente de IA con un prompt como:
```
Este archivo contiene todos los archivos del repositorio combinados en uno.
Quiero refactorizar el código, así que por favor revísalo primero.
```
La IA analizará todo tu código y proporcionará información completa:
Al discutir cambios específicos, la IA puede ayudar a generar código. Con funciones como los Artefactos de Claude, incluso puedes recibir múltiples archivos interdependientes:
¡Feliz programación! 🚀
## Guía para usuarios avanzados
Para los usuarios avanzados que necesitan más control, Repomix ofrece amplias opciones de personalización a través de su interfaz de línea de comandos.
### Inicio rápido
Puedes probar Repomix instantáneamente en el directorio de tu proyecto sin necesidad de instalación:
```bash
npx repomix
```
O instalarlo globalmente para uso repetido:
```bash
# Instalar usando npm
npm install -g repomix
# Alternativamente usando yarn
yarn global add repomix
# Alternativamente usando Homebrew (macOS/Linux)
brew install repomix
# Luego ejecutar en cualquier directorio de proyecto
repomix
```
¡Eso es todo! Repomix generará un archivo `repomix-output.txt` en tu directorio actual, que contendrá todo tu repositorio en un formato amigable para la IA.
### Uso
Para empaquetar todo tu repositorio:
```bash
repomix
```
Para empaquetar un directorio específico:
```bash
repomix ruta/al/directorio
```
Para empaquetar archivos o directorios específicos usando [patrones glob](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
Para excluir archivos o directorios específicos:
```bash
repomix --ignore "**/*.log,tmp/"
```
Para empaquetar un repositorio remoto:
```bash
# Usando formato abreviado
npx repomix --remote yamadashy/repomix
# Usando URL completa (soporta ramas y rutas específicas)
npx repomix --remote https://github.com/yamadashy/repomix
npx repomix --remote https://github.com/yamadashy/repomix/tree/main
# Usando URL de confirmación
npx repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
```
Para inicializar un nuevo archivo de configuración (`repomix.config.json`):
```bash
repomix --init
```
Una vez que hayas generado el archivo empaquetado, puedes usarlo con herramientas de IA generativa como Claude, ChatGPT y Gemini.
#### Uso de Docker
También puedes ejecutar Repomix usando Docker 🐳
Esto es útil si deseas ejecutar Repomix en un entorno aislado o prefieres usar contenedores.
Uso básico (directorio actual):
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
Para empaquetar un directorio específico:
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix ruta/al/directorio
```
Procesar un repositorio remoto y generar la salida en un directorio `output`:
```bash
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix
```
### Formatos de salida
Elige tu formato de salida preferido:
```bash
# Formato XML (predeterminado)
repomix --style xml
# Formato Markdown
repomix --style markdown
# Formato de texto plano
repomix --style plain
```
### Personalización
Crea un archivo `repomix.config.json` para configuraciones persistentes:
```json
{
"output": {
"style": "markdown",
"filePath": "custom-output.md",
"removeComments": true,
"showLineNumbers": true,
"topFilesLength": 10
},
"ignore": {
"customPatterns": ["*.test.ts", "docs/**"]
}
}
```
### Más ejemplos
::: tip
💡 ¡Consulta nuestro [repositorio de GitHub](https://github.com/yamadashy/repomix) para obtener la documentación completa y más ejemplos!
:::
# Repomix에 기여하기
## 빠른 시작
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
npm install
```
## 개발 명령어
```bash
# CLI 실행
npm run repomix
# 테스트 실행
npm run test
npm run test-coverage
# 코드 린트
npm run lint
```
## 코드 스타일
- 린트 및 포맷팅에 [Biome](https://biomejs.dev/)을 사용합니다.
- 테스트 용이성을 위해 의존성 주입을 사용합니다.
- 파일 길이를 250줄 미만으로 유지합니다.
- 새로운 기능에 대한 테스트를 추가합니다.
## Pull Request 가이드라인
1. 모든 테스트를 실행합니다.
2. 린트 검사를 통과합니다.
3. 문서를 업데이트합니다.
4. 기존 코드 스타일을 따릅니다.
## 도움이 필요하신가요?
- [이슈 열기](https://github.com/yamadashy/repomix/issues)
- [Discord 참여](https://discord.gg/wNYzTwZFku)
# 개발 환경 설정
## 필수 구성 요소
- Node.js ≥ 18.0.0
- Git
- npm
## 로컬 개발
```bash
# 저장소 복제
git clone https://github.com/yamadashy/repomix.git
cd repomix
# 의존성 설치
npm install
# CLI 실행
npm run repomix
```
## Docker 개발
```bash
# 이미지 빌드
docker build -t repomix .
# 컨테이너 실행
docker run -v ./:/app -it --rm repomix
```
## 프로젝트 구조
```
src/
├── cli/ # CLI 구현
├── config/ # 구성 처리
├── core/ # 핵심 기능
└── shared/ # 공유 유틸리티
```
## 테스트
```bash
# 테스트 실행
npm run test
# 테스트 커버리지
npm run test-coverage
# 린트
npm run lint-biome
npm run lint-ts
npm run lint-secretlint
```
## 릴리스 프로세스
1. 버전 업데이트
```bash
npm version patch # 또는 minor/major
```
2. 테스트 및 빌드 실행
```bash
npm run test-coverage
npm run build
```
3. 게시
```bash
npm publish
# AI 지원 개발 모범 사례: 나의 경험으로부터
저는 아직 AI를 사용하여 대규모 프로젝트를 성공적으로 완료하지는 못했지만, 지금까지 개발 과정에서 AI와 함께 작업하면서 배운 점을 공유하고자 합니다.
## 기본 개발 접근 방식
AI와 함께 작업할 때, 모든 기능을 한 번에 구현하려고 하면 예상치 못한 문제와 프로젝트 정체로 이어질 수 있습니다. 그렇기 때문에 핵심 기능부터 시작하여 각 기능을 하나씩 구축하고, 다음 단계로 넘어가기 전에 견고한 구현을 보장하는 것이 더 효과적입니다.
### 기존 코드의 힘
이 접근 방식이 효과적인 이유는 핵심 기능을 구현하면 실제 코드를 통해 이상적인 설계와 코딩 스타일을 구체화할 수 있기 때문입니다. 프로젝트 비전을 전달하는 가장 효과적인 방법은 표준과 선호도를 반영하는 코드를 작성하는 것입니다.
핵심 기능부터 시작하여 각 구성 요소가 제대로 작동하는지 확인한 후 다음 단계로 진행하면 전체 프로젝트의 일관성이 유지되므로 AI가 더 적절한 코드를 생성하기 쉬워집니다.
## 모듈식 접근 방식
코드를 더 작은 모듈로 나누는 것이 중요합니다. 제 경험상, 파일을 약 250줄 정도로 유지하면 AI에게 명확한 지침을 제공하기 쉽고 시행착오 프로세스가 더 효율적입니다. 토큰 수가 더 정확한 지표가 될 수 있지만, 줄 수는 개발자가 작업하기에 더 실용적이므로 이를 지침으로 사용합니다.
이러한 모듈화는 단순히 프런트엔드, 백엔드, 데이터베이스 구성 요소를 분리하는 것뿐만 아니라 훨씬 더 세분화된 수준에서 기능을 분리하는 것입니다. 예를 들어, 단일 기능 내에서 유효성 검사, 오류 처리 및 기타 특정 기능을 별개의 모듈로 분리할 수 있습니다. 물론, 높은 수준의 분리도 중요하며, 이러한 모듈식 접근 방식을 점진적으로 구현하면 명확한 지침을 유지하고 AI가 더 적절한 코드를 생성할 수 있습니다. 이 접근 방식은 AI뿐만 아니라 사람 개발자에게도 효과적입니다.
## 테스트를 통한 품질 보장
저는 AI 지원 개발에서 테스트가 매우 중요하다고 생각합니다. 테스트는 품질 보장 수단일 뿐만 아니라 코드 의도를 명확하게 보여주는 문서 역할도 합니다. AI에게 새로운 기능 구현을 요청할 때, 기존 테스트 코드는 사실상 사양 문서 역할을 합니다.
테스트는 또한 AI가 생성한 코드의 정확성을 검증하는 훌륭한 도구입니다. 예를 들어, AI에게 모듈에 대한 새로운 기능 구현을 요청할 때, 테스트 케이스를 미리 작성하면 생성된 코드가 예상대로 작동하는지 객관적으로 평가할 수 있습니다. 이는 테스트 주도 개발(TDD) 원칙과 잘 부합하며 AI와 협업할 때 특히 효과적입니다.
## 계획과 구현의 균형
대규모 기능을 구현하기 전에 먼저 AI와 계획에 대해 논의하는 것이 좋습니다. 요구 사항을 정리하고 아키텍처를 고려하면 구현이 더 원활해집니다. 좋은 방법은 먼저 요구 사항을 정리한 다음 별도의 대화 세션으로 이동하여 구현 작업을 수행하는 것입니다.
AI의 출력을 사람이 검토하고 필요에 따라 조정하는 것이 중요합니다. AI가 생성한 코드의 품질은 일반적으로 보통 수준이지만, 모든 것을 처음부터 작성하는 것보다 개발 속도를 높여줍니다.
## 결론
이러한 관행을 따르면 AI의 강점을 활용하면서 일관성 있고 고품질의 코드베이스를 구축할 수 있습니다. 프로젝트 규모가 커지더라도 각 구성 요소는 잘 정의되고 관리하기 쉬운 상태로 유지됩니다.
# 주석 제거
Repomix는 출력 파일을 생성할 때 코드베이스에서 주석을 자동으로 제거할 수 있습니다. 이를 통해 노이즈를 줄이고 실제 코드에 집중할 수 있습니다.
## 사용법
주석 제거를 활성화하려면 `repomix.config.json`에서 `removeComments` 옵션을 `true`로 설정합니다.
```json
{
"output": {
"removeComments": true
}
}
```
## 지원되는 언어
Repomix는 다음을 포함한 광범위한 프로그래밍 언어에 대한 주석 제거를 지원합니다.
- JavaScript/TypeScript (`//`, `/* */`)
- Python (`#`, `"""`, `'''`)
- Java (`//`, `/* */`)
- C/C++ (`//`, `/* */`)
- HTML (``)
- CSS (`/* */`)
- 그리고 더 많은 언어들...
## 예시
다음 JavaScript 코드가 주어졌을 때:
```javascript
// 이것은 한 줄 주석입니다
function test() {
/* 이것은
여러 줄 주석입니다 */
return true;
}
```
주석 제거를 활성화하면 출력은 다음과 같습니다.
```javascript
function test() {
return true;
}
```
## 참고
- 주석 제거는 행 번호 추가와 같은 다른 처리 단계 전에 수행됩니다.
- JSDoc 주석과 같은 일부 주석은 언어 및 컨텍스트에 따라 보존될 수 있습니다.
# 사용자 정의 지시사항
Repomix는 출력 파일에 포함될 사용자 정의 지시사항을 제공할 수 있게 해줍니다. 이는 AI 시스템이 프로젝트의 특정 맥락이나 요구 사항을 이해하는 데 도움이 됩니다.
## 사용법
사용자 정의 지시사항을 포함하려면 저장소의 루트에 마크다운 파일(예: `repomix-instruction.md`)을 생성하고, `repomix.config.json`에서 해당 파일의 경로를 지정하세요:
```json
{
"output": {
"instructionFilePath": "repomix-instruction.md"
}
}
```
이 파일의 내용은 출력의 "Instruction" 섹션에 포함됩니다.
## 사용 예시
```markdown
# 코딩 지침
- Airbnb JavaScript 스타일 가이드를 따르세요.
- 필요한 경우 파일을 더 작은 단위로 분할하세요.
- 불분명한 로직에는 주석을 추가하세요. 모든 텍스트는 영어로 작성하세요.
- 모든 새로운 기능에 대해 해당 단위 테스트를 작성하세요.
## 생성된 콘텐츠에 대하여
- 특별한 지정이 없는 한, 모든 콘텐츠를 생략 없이 포함하세요.
- 대규모 코드베이스를 처리할 때도 출력 품질을 유지하세요.
```
이는 출력 파일에서 다음과 같이 표시됩니다:
```xml
# 코딩 가이드라인
- Airbnb JavaScript 스타일 가이드를 따릅니다
- 필요한 경우 파일을 작은 단위로 분할합니다
- 명확하지 않은 로직에는 주석을 추가합니다. 모든 텍스트는 영어로 작성합니다
- 모든 새로운 기능에는 해당하는 단위 테스트를 작성합니다
## 생성 내용에 대해
- 특별한 지정이 없는 한, 모든 내용은 축약하지 않고 포함합니다
- 대규모 코드베이스를 처리하면서도 출력의 품질을 유지합니다
```
## 모범 사례
1. **간결하고 명확하게**: 지시사항은 간결하되, 필요한 세부 사항은 모두 포함해야 합니다.
2. **구체적인 예시 제공**: 적절한 경우 코드 예시를 사용하여 설명을 보완합니다.
3. **우선순위 설정**: 가장 중요한 지시사항을 문서 앞부분에 배치하여 강조합니다.
4. **맥락 포함**: 프로젝트의 배경과 중요한 고려사항을 제공하여 AI가 작업을 더 잘 이해하도록 돕습니다.
5. **구조화된 콘텐츠**: 제목과 목록을 사용하여 지시사항을 체계적으로 구성하고 가독성을 높입니다.
## 주의 사항
- 지시사항에 민감한 정보를 포함하지 마세요
- 프로젝트의 변화를 반영하여 정기적으로 지시사항을 업데이트하세요
- 지시사항이 프로젝트의 다른 문서와 일관성을 유지하도록 하세요
- 명확한 계층 구조를 사용하여 콘텐츠를 구성하세요
# 설치
## npx 사용 (설치 불필요)
```bash
npx repomix
```
## 전역 설치
### npm
```bash
npm install -g repomix
```
### Yarn
```bash
yarn global add repomix
```
### Homebrew (macOS/Linux)
```bash
brew install repomix
```
## Docker 설치
Docker를 사용하면 환경 설정 문제를 피할 수 있어 가장 편리한 방법 중 하나입니다. 아래와 같이 실행하세요:
```bash
# 현재 디렉토리 처리
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 yamadashy/repomix
```
## VSCode 확장 프로그램
커뮤니티에서 관리하는 [Repomix Runner](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner) 확장 프로그램을 통해 VSCode에서 직접 Repomix를 실행할 수 있습니다.
기능:
- 몇 번의 클릭으로 폴더 패키징
- 파일 또는 콘텐츠 모드로 복사
- 출력 파일 자동 정리
- repomix.config.json 지원
[VSCode 마켓플레이스](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner)에서 설치하세요.
## 시스템 요구 사항
- Node.js: 18.0.0 이상
- Git: 원격 저장소 처리 시 필요
## 설치 확인
설치가 완료된 후, 다음 명령어로 Repomix가 정상적으로 작동하는지 확인하세요:
```bash
repomix --version
repomix --help
```
# 프롬프트 예시
## 코드 리뷰
### 아키텍처 리뷰
```
이 코드베이스의 아키텍처를 분석하세요:
1. 전체 구조와 패턴을 평가
2. 잠재적인 아키텍처 문제 식별
3. 확장성을 위한 개선 사항 제안
4. 모범 사례를 따르는 영역 기록
유지보수성과 모듈성에 중점을 두세요.
```
### 보안 리뷰
```
이 코드베이스의 보안 검토를 수행하세요:
1. 잠재적인 보안 취약점 식별
2. 일반적인 보안 안티패턴 확인
3. 오류 처리 및 입력 유효성 검사 검토
4. 의존성 보안 평가
구체적인 예시와 해결 단계를 제공하세요.
```
### 성능 리뷰
```
코드베이스의 성능을 검토하세요:
1. 성능 병목 현상 식별
2. 리소스 사용량 확인
3. 알고리즘 효율성 검토
4. 캐싱 전략 평가
구체적인 최적화 권장 사항을 포함하세요.
```
## 문서 생성
### API 문서
```
포괄적인 API 문서를 생성하세요:
1. 모든 공개 엔드포인트 나열 및 설명
2. 요청/응답 형식 문서화
3. 사용 예시 포함
4. 제한 사항 기록
```
### 개발자 가이드
```
다음 내용을 포함하는 개발자 가이드를 작성하세요:
1. 설정 지침
2. 프로젝트 구조 개요
3. 개발 워크플로우
4. 테스트 접근 방식
5. 일반적인 문제 해결 단계
```
### 아키텍처 문서
```
시스템 아키텍처를 문서화하세요:
1. 상위 수준 개요
2. 컴포넌트 상호 작용
3. 데이터 흐름 다이어그램
4. 설계 결정 및 근거
5. 시스템 제약 사항 및 한계
```
## 분석 및 개선
### 의존성 분석
```
프로젝트 의존성을 분석하세요:
1. 오래된 패키지 식별
2. 보안 취약점 확인
3. 대체 패키지 제안
4. 의존성 사용 패턴 검토
구체적인 업그레이드 권장 사항을 포함하세요.
```
### 테스트 커버리지
```
테스트 커버리지를 검토하세요:
1. 테스트되지 않은 컴포넌트 식별
2. 추가 테스트 케이스 제안
3. 테스트 품질 검토
4. 테스트 전략 권장
```
### 코드 품질
```
코드 품질을 평가하고 개선 사항을 제안하세요:
1. 명명 규칙 검토
2. 코드 구성 확인
3. 오류 처리 평가
4. 주석 작성 관행 검토
좋은 패턴과 문제가 있는 패턴의 구체적인 예시를 제공하세요.
```
## 더 나은 결과를 위한 팁
1. **구체적으로 작성**: 명확한 목표와 평가 기준을 포함하세요
2. **컨텍스트 설정**: 귀하의 역할과 필요한 전문성 수준을 지정하세요
3. **응답 형식**: 원하는 응답 구조를 정의하세요
4. **우선순위 지정**: 가장 중요한 측면을 표시하세요
## 모델별 참고 사항
### Claude
- XML 출력 형식 사용
- 중요한 지시사항을 마지막에 배치
- 응답 구조 지정
### ChatGPT
- 마크다운 형식 사용
- 큰 코드베이스를 섹션으로 분할
- 시스템 역할 프롬프트 사용
### Gemini
- 모든 형식과 호환
- 요청당 특정 영역에 집중
- 단계별 분석 사용
# 원격 저장소 처리
## 기본 사용법
공개 저장소 처리:
```bash
# 전체 URL 사용
repomix --remote https://github.com/user/repo
# GitHub 단축형 사용
repomix --remote user/repo
```
## 브랜치 및 커밋 선택
```bash
# 특정 브랜치
repomix --remote user/repo --remote-branch main
# 태그
repomix --remote user/repo --remote-branch v1.0.0
# 커밋 해시
repomix --remote user/repo --remote-branch 935b695
```
## 요구 사항
- Git이 설치되어 있어야 함
- 인터넷 연결
- 저장소에 대한 읽기 권한
## 출력 제어
```bash
# 사용자 지정 출력 위치
repomix --remote user/repo -o custom-output.xml
# XML 형식 사용
repomix --remote user/repo --style xml
# 주석 제거
repomix --remote user/repo --remove-comments
```
## Docker 사용
```bash
# 현재 디렉토리에서 처리 및 출력
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
# 특정 디렉토리에 출력
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
```
## 일반적인 문제
### 접근 문제
- 저장소가 공개되어 있는지 확인
- Git 설치 확인
- 인터넷 연결 확인
### 대용량 저장소
- `--include`를 사용하여 특정 경로 선택
- `--remove-comments` 활성화
- 브랜치별로 개별 처리
# 보안
## 보안 검사 기능
Repomix는 [Secretlint](https://github.com/secretlint/secretlint)를 사용하여 파일 내의 민감한 정보를 감지합니다:
- API 키
- 액세스 토큰
- 인증 정보
- 개인 키
- 환경 변수
## 설정
보안 검사는 기본적으로 활성화되어 있습니다.
명령행에서 비활성화:
```bash
repomix --no-security-check
```
또는 `repomix.config.json`에서 설정:
```json
{
"security": {
"enableSecurityCheck": false
}
}
```
## 보안 조치
1. **바이너리 파일 제외**: 출력에 바이너리 파일이 포함되지 않음
2. **Git 인식**: `.gitignore` 패턴을 준수
3. **자동 감지**: 다음과 같은 일반적인 보안 문제를 스캔:
- AWS 자격 증명
- 데이터베이스 연결 문자열
- 인증 토큰
- 개인 키
## 보안 검사에서 문제가 발견된 경우
출력 예시:
```bash
🔍 Security Check:
──────────────────
2 suspicious file(s) detected and excluded:
1. config/credentials.json
- Found AWS access key
2. .env.local
- Found database password
```
## 모범 사례
1. 공유하기 전에 반드시 출력 내용 검토
2. `.repomixignore`를 사용하여 민감한 경로 제외
3. 보안 검사 기능 활성화 유지
4. 저장소에서 민감한 파일 제거
## 보안 문제 보고
보안 취약점을 발견하셨다면:
1. 공개 이슈를 생성하지 마세요
2. 이메일: koukun0120@gmail.com
3. 또는 [GitHub 보안 권고](https://github.com/yamadashy/repomix/security/advisories/new) 사용
---
layout: home
title: Repomix
titleTemplate: 코드베이스를 AI 친화적인 형식으로 패키징
aside: false
editLink: false
features:
- icon: 🤖
title: AI 최적화
details: 코드베이스를 AI가 이해하고 처리하기 쉬운 형식으로 변환합니다.
- icon: ⚙️
title: Git 인식
details: .gitignore 파일을 자동으로 인식하고 처리합니다.
- icon: 🛡️
title: 보안 중심
details: Secretlint를 통합하여 민감한 정보를 감지하고 보호합니다.
- icon: 📊
title: 토큰 카운팅
details: LLM 컨텍스트 제한을 위한 파일별 및 전체 토큰 수를 제공합니다.
---
## 빠른 시작
Repomix를 사용하여 패키지 파일(`repomix-output.txt`)을 생성한 후, 다음과 같은 프롬프트와 함께 AI 어시스턴트에게 전송할 수 있습니다:
```
이 파일은 저장소의 모든 파일을 하나로 통합한 것입니다.
코드를 리팩터링하고 싶으니 먼저 검토해 주세요.
```
AI는 전체 코드베이스를 분석하고 포괄적인 인사이트를 제공할 것입니다:
구체적인 변경 사항을 논의할 때는 AI가 코드 생성을 도와줍니다. Claude의 Artifacts와 같은 기능을 사용하면 상호 의존적인 여러 파일도 한 번에 받을 수 있습니다:
즐거운 코딩 되세요! 🚀
## 파워 유저 가이드
고급 사용자를 위해 Repomix는 CLI 인터페이스를 통해 다양한 사용자 정의 옵션을 제공합니다.
### 빠른 시작
프로젝트 디렉토리에서 설치 없이 바로 Repomix를 시작할 수 있습니다:
```bash
npx repomix
```
또는 반복 사용을 위해 전역 설치:
```bash
# npm으로 설치
npm install -g repomix
# 또는 yarn으로 설치
yarn global add repomix
# 또는 Homebrew로 설치 (macOS/Linux)
brew install repomix
# 그런 다음 아무 프로젝트 디렉토리에서 실행
repomix
```
이게 전부입니다! Repomix가 현재 디렉토리에 `repomix-output.txt` 파일을 생성하며, 이 파일에는 AI 친화적인 형식으로 정리된 전체 코드베이스가 포함됩니다.
### 사용법
전체 저장소를 패키징:
```bash
repomix
```
특정 디렉토리를 패키징:
```bash
repomix path/to/directory
```
[glob 패턴](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax)을 사용하여 특정 파일이나 디렉토리를 지정:
```bash
repomix --include "src/**/*.ts,**/*.md"
```
특정 파일이나 디렉토리 제외:
```bash
repomix --ignore "**/*.log,tmp/"
```
원격 저장소 처리:
```bash
# 단축형 사용
npx repomix --remote yamadashy/repomix
# 전체 URL 사용 (브랜치 및 특정 경로 지원)
npx repomix --remote https://github.com/yamadashy/repomix
npx repomix --remote https://github.com/yamadashy/repomix/tree/main
# 커밋 URL 사용
npx repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
```
새 설정 파일(`repomix.config.json`) 초기화:
```bash
repomix --init
```
생성된 파일은 Claude, ChatGPT, Gemini와 같은 생성형 AI 도구와 함께 사용할 수 있습니다.
#### Docker 사용법
Docker를 사용하여 Repomix를 실행할 수도 있습니다 🐳
격리된 환경에서 Repomix를 실행하거나 컨테이너를 선호하는 경우에 유용합니다.
기본 사용법(현재 디렉토리):
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
특정 디렉토리를 처리:
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
```
원격 저장소를 처리하고 `output` 디렉토리에 출력:
```bash
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix
```
### 출력 형식
선호하는 출력 형식을 선택하세요:
```bash
# XML 형식(기본값)
repomix --style xml
# Markdown 형식
repomix --style markdown
# 일반 텍스트 형식
repomix --style plain
```
### 사용자 정의
`repomix.config.json`을 생성하여 지속적인 설정을 관리할 수 있습니다:
```json
{
"output": {
"style": "markdown",
"filePath": "custom-output.md",
"removeComments": true,
"showLineNumbers": true,
"topFilesLength": 10
},
"ignore": {
"customPatterns": ["*.test.ts", "docs/**"]
}
}
```
### 더 많은 예제
::: tip
💡 전체 문서와 더 많은 예제는 [GitHub 저장소](https://github.com/yamadashy/repomix)를 참조하세요!
:::
# Contribuindo para o Repomix
## Início Rápido
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
npm install
```
## Comandos de Desenvolvimento
```bash
# Executar CLI
npm run repomix
# Executar testes
npm run test
npm run test-coverage
# Lintar código
npm run lint
```
## Estilo de Código
- Use [Biome](https://biomejs.dev/) para lintar e formatar
- Injeção de dependência para testabilidade
- Mantenha os arquivos com menos de 250 linhas
- Adicione testes para novos recursos
## Diretrizes para Pull Requests
1. Execute todos os testes
2. Passe nas verificações de lint
3. Atualize a documentação
4. Siga o estilo de código existente
## Precisa de Ajuda?
- [Abra uma issue](https://github.com/yamadashy/repomix/issues)
- [Junte-se ao Discord](https://discord.gg/wNYzTwZFku)
# Configuração de Desenvolvimento
## Pré-requisitos
- Node.js ≥ 18.0.0
- Git
- npm
## Desenvolvimento Local
```bash
# Clonar repositório
git clone https://github.com/yamadashy/repomix.git
cd repomix
# Instalar dependências
npm install
# Executar CLI
npm run repomix
```
## Desenvolvimento com Docker
```bash
# Construir imagem
docker build -t repomix .
# Executar container
docker run -v ./:/app -it --rm repomix
```
## Estrutura do Projeto
```
src/
├── cli/ # Implementação da CLI
├── config/ # Manipulação de configuração
├── core/ # Funcionalidade principal
└── shared/ # Utilitários compartilhados
```
## Testando
```bash
# Executar testes
npm run test
# Cobertura de teste
npm run test-coverage
# Linting
npm run lint-biome
npm run lint-ts
npm run lint-secretlint
```
## Processo de Release
1. Atualizar versão
```bash
npm version patch # ou minor/major
```
2. Executar testes e construir
```bash
npm run test-coverage
npm run build
```
3. Publicar
```bash
npm publish
# Melhores Práticas para Desenvolvimento com IA: Da Minha Experiência
Embora eu ainda não tenha concluído um grande projeto com IA, gostaria de compartilhar minhas experiências até agora no desenvolvimento com IA.
## Abordagem Básica de Desenvolvimento
Ao trabalhar com IA, tentar implementar todas as funcionalidades de uma vez pode levar a problemas inesperados e estagnação do projeto. Portanto, é mais eficaz começar com a funcionalidade principal e construir cada recurso individualmente, garantindo uma implementação sólida antes de prosseguir.
### O Poder do Código Existente
Essa abordagem é eficaz porque a implementação da funcionalidade principal permite materializar seu design ideal e estilo de codificação através de código real. A maneira mais eficaz de comunicar sua visão do projeto é através de código que reflita seus padrões e preferências.
Começando com funcionalidades principais e garantindo que cada componente funcione corretamente antes de avançar, o projeto inteiro mantém sua consistência, tornando mais fácil para a IA gerar código mais apropriado.
## Abordagem Modular
Dividir o código em módulos menores é crucial. Com base em minha experiência, limitar os arquivos a cerca de 250 linhas de código torna mais fácil dar instruções claras à IA e tornar o processo de tentativa e erro mais eficiente. Embora a contagem de tokens seria uma medida mais precisa, a contagem de linhas é mais prática para desenvolvedores humanos, então usamos isso como diretriz.
Essa modularização não se limita apenas à separação de componentes frontend, backend e banco de dados - trata-se de dividir a funcionalidade em um nível muito mais fino. Por exemplo, dentro de uma única função, você pode separar a validação, tratamento de erros e outras funcionalidades específicas em módulos separados.
## Garantia de Qualidade através de Testes
Considero os testes cruciais no desenvolvimento assistido por IA. Os testes servem não apenas como medidas de garantia de qualidade, mas também como documentação que demonstra claramente as intenções do código. Quando você pede à IA para implementar novos recursos, o código de teste existente serve efetivamente como um documento de especificação.
Os testes também são uma excelente ferramenta para validar a correção do código gerado pela IA. Por exemplo, se você fizer a IA implementar nova funcionalidade para um módulo, escrever casos de teste antecipadamente permite uma avaliação objetiva se o código gerado funciona conforme esperado.
## Equilíbrio entre Planejamento e Implementação
Antes de implementar recursos extensos, recomendo discutir primeiro o plano com a IA. Organizar os requisitos e considerar a arquitetura leva a uma implementação mais suave. Uma boa prática é primeiro compilar os requisitos e depois mudar para uma sessão de chat separada para o trabalho de implementação.
## Conclusão
Seguindo essas práticas, você pode aproveitar os pontos fortes da IA enquanto mantém uma base de código consistente e de alta qualidade. Mesmo à medida que seu projeto cresce, cada componente permanece bem definido e gerenciável.
# Remoção de Comentários
O Repomix pode remover automaticamente os comentários do seu código ao gerar o arquivo de saída. Isso pode ajudar a reduzir o ruído e focar no código real.
## Uso
Para habilitar a remoção de comentários, defina a opção `removeComments` como `true` no seu `repomix.config.json`:
```json
{
"output": {
"removeComments": true
}
}
```
## Linguagens Suportadas
O Repomix suporta a remoção de comentários para uma ampla gama de linguagens de programação, incluindo:
- JavaScript/TypeScript (`//`, `/* */`)
- Python (`#`, `"""`, `'''`)
- Java (`//`, `/* */`)
- C/C++ (`//`, `/* */`)
- HTML (``)
- CSS (`/* */`)
- E muitas outras...
## Exemplo
Dado o seguinte código JavaScript:
```javascript
// Este é um comentário de linha única
function test() {
/* Este é um
comentário de várias linhas */
return true;
}
```
Com a remoção de comentários habilitada, a saída será:
```javascript
function test() {
return true;
}
```
## Notas
- A remoção de comentários é realizada antes de outras etapas de processamento, como a adição de números de linha.
- Alguns comentários, como os comentários JSDoc, podem ser preservados dependendo da linguagem e do contexto.
# Instruções Personalizadas
O Repomix permite que você forneça instruções personalizadas que serão incluídas no arquivo de saída. Isso pode ser útil para adicionar contexto ou diretrizes específicas para sistemas de IA que processam o repositório.
## Uso
Para incluir uma instrução personalizada, crie um arquivo markdown (por exemplo, `repomix-instruction.md`) na raiz do seu repositório. Em seguida, especifique o caminho para este arquivo no seu `repomix.config.json`:
```json
{
"output": {
"instructionFilePath": "repomix-instruction.md"
}
}
```
O conteúdo deste arquivo será incluído na saída sob a seção "Instruction".
## Exemplo
```markdown
# Instruções do Repositório
Este repositório contém o código-fonte da ferramenta Repomix. Por favor, siga estas diretrizes ao analisar o código:
1. Concentre-se na funcionalidade principal no diretório `src/core`.
2. Preste atenção especial às verificações de segurança em `src/core/security`.
3. Ignore quaisquer arquivos no diretório `tests`.
```
Isso resultará na seguinte seção na saída:
```xml
# Instruções do Repositório
Este repositório contém o código-fonte da ferramenta Repomix. Por favor, siga estas diretrizes ao analisar o código:
1. Concentre-se na funcionalidade principal no diretório `src/core`.
2. Preste atenção especial às verificações de segurança em `src/core/security`.
3. Ignore quaisquer arquivos no diretório `tests`.
# Instalação
## Usando npx (Nenhuma Instalação Necessária)
```bash
npx repomix
```
## Instalação Global
### npm
```bash
npm install -g repomix
```
### Yarn
```bash
yarn global add repomix
```
### Homebrew (macOS/Linux)
```bash
brew install repomix
```
## Instalação via Docker
Baixe e execute a imagem Docker:
```bash
# Diretório atual
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
# Diretório específico
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
# Repositório remoto
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote yamadashy/repomix
```
## Extensão VSCode
Execute o Repomix diretamente no VSCode com a extensão [Repomix Runner](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner) mantida pela comunidade.
Recursos:
- Empacote qualquer pasta com apenas alguns cliques
- Escolha entre modo arquivo ou conteúdo para copiar
- Limpeza automática de arquivos de saída
- Funciona com repomix.config.json
Instale através do [VSCode Marketplace](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner).
## Requisitos de Sistema
- Node.js: ≥ 18.0.0
- Git: Necessário para processamento de repositório remoto
## Verificação
Após a instalação, verifique se o Repomix está funcionando:
```bash
repomix --version
repomix --help
```
# Exemplos de Prompts
## Revisão de Código
### Revisão de Arquitetura
```
Analise a arquitetura desta base de código:
1. Avalie a estrutura geral e os padrões
2. Identifique possíveis problemas de arquitetura
3. Sugira melhorias para escalabilidade
4. Observe áreas que seguem as melhores práticas
Concentre-se na manutenibilidade e modularidade.
```
### Revisão de Segurança
```
Realize uma revisão de segurança desta base de código:
1. Identifique possíveis vulnerabilidades de segurança
2. Verifique se há antipadrões de segurança comuns
3. Revise o tratamento de erros e a validação de entrada
4. Avalie a segurança das dependências
Forneça exemplos específicos e etapas de correção.
```
### Revisão de Desempenho
```
Revise a base de código para desempenho:
1. Identifique gargalos de desempenho
2. Verifique a utilização de recursos
3. Revise a eficiência algorítmica
4. Avalie as estratégias de cache
Inclua recomendações específicas de otimização.
```
## Geração de Documentação
### Documentação de API
```
Gere documentação abrangente da API:
1. Liste e descreva todos os endpoints públicos
2. Documente os formatos de solicitação/resposta
3. Inclua exemplos de uso
4. Observe quaisquer limitações ou restrições
```
### Guia do Desenvolvedor
```
Crie um guia do desenvolvedor cobrindo:
1. Instruções de configuração
2. Visão geral da estrutura do projeto
3. Fluxo de trabalho de desenvolvimento
4. Abordagem de teste
5. Etapas comuns de solução de problemas
```
### Documentação de Arquitetura
```
Documente a arquitetura do sistema:
1. Visão geral de alto nível
2. Interações de componentes
3. Diagramas de fluxo de dados
4. Decisões de design e justificativa
5. Restrições e limitações do sistema
```
## Análise e Melhoria
### Análise de Dependências
```
Analise as dependências do projeto:
1. Identifique pacotes desatualizados
2. Verifique se há vulnerabilidades de segurança
3. Sugira pacotes alternativos
4. Revise os padrões de uso de dependências
Inclua recomendações específicas de atualização.
```
### Cobertura de Testes
```
Revise a cobertura de testes:
1. Identifique componentes não testados
2. Sugira casos de teste adicionais
3. Revise a qualidade do teste
4. Recomende estratégias de teste
```
### Qualidade do Código
```
Avalie a qualidade do código e sugira melhorias:
1. Revise as convenções de nomenclatura
2. Verifique a organização do código
3. Avalie o tratamento de erros
4. Revise as práticas de comentários
Forneça exemplos específicos de padrões bons e problemáticos.
```
## Dicas para Obter Melhores Resultados
1. **Seja Específico**: Inclua objetivos claros e critérios de avaliação
2. **Defina o Contexto**: Especifique sua função e o nível de especialização necessário
3. **Formato da Solicitação**: Defina como você deseja que a resposta seja estruturada
4. **Priorize**: Indique quais aspectos são mais importantes
## Notas Específicas do Modelo
### Claude
- Use o formato de saída XML
- Coloque instruções importantes no final
- Especifique a estrutura da resposta
### ChatGPT
- Use o formato Markdown
- Divida grandes bases de código em seções
- Inclua prompts de função do sistema
### Gemini
- Funciona com todos os formatos
- Concentre-se em áreas específicas por solicitação
- Use análise passo a passo
# Processamento de Repositório Remoto
## Uso Básico
Processar repositórios públicos:
```bash
# Usando URL completo
repomix --remote https://github.com/user/repo
# Usando atalho do GitHub
repomix --remote user/repo
```
## Seleção de Branch e Commit
```bash
# Branch específico
repomix --remote user/repo --remote-branch main
# Tag
repomix --remote user/repo --remote-branch v1.0.0
# Hash do commit
repomix --remote user/repo --remote-branch 935b695
```
## Requisitos
- Git deve estar instalado
- Conexão com a internet
- Acesso de leitura ao repositório
## Controle de Saída
```bash
# Local de saída personalizado
repomix --remote user/repo -o custom-output.xml
# Com formato XML
repomix --remote user/repo --style xml
# Remover comentários
repomix --remote user/repo --remove-comments
```
## Uso com Docker
```bash
# Processar e enviar para o diretório atual
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
# Enviar para um diretório específico
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
```
## Problemas Comuns
### Problemas de Acesso
- Certifique-se de que o repositório é público
- Verifique a instalação do Git
- Verifique a conexão com a internet
### Repositórios Grandes
- Use `--include` para selecionar caminhos específicos
- Habilite `--remove-comments`
- Processe branches separadamente
# Segurança
## Recurso de Verificação de Segurança
O Repomix usa o [Secretlint](https://github.com/secretlint/secretlint) para detectar informações confidenciais em seus arquivos:
- Chaves de API
- Tokens de acesso
- Credenciais
- Chaves privadas
- Variáveis de ambiente
## Configuração
As verificações de segurança são habilitadas por padrão.
Desativar via CLI:
```bash
repomix --no-security-check
```
Ou em `repomix.config.json`:
```json
{
"security": {
"enableSecurityCheck": false
}
}
```
## Medidas de Segurança
1. **Exclusão de Arquivos Binários**: Arquivos binários não são incluídos na saída
2. **Compatível com Git**: Respeita os padrões do `.gitignore`
3. **Detecção Automatizada**: Verifica problemas de segurança comuns:
- Credenciais da AWS
- Strings de conexão de banco de dados
- Tokens de autenticação
- Chaves privadas
## Quando a Verificação de Segurança Encontra Problemas
Exemplo de saída:
```bash
🔍 Verificação de Segurança:
──────────────────
2 arquivo(s) suspeito(s) detectados e excluídos:
1. config/credentials.json
- Chave de acesso da AWS encontrada
2. .env.local
- Senha do banco de dados encontrada
```
## Melhores Práticas
1. Sempre revise a saída antes de compartilhar
2. Use `.repomixignore` para caminhos confidenciais
3. Mantenha as verificações de segurança habilitadas
4. Remova arquivos confidenciais do repositório
## Reportando Problemas de Segurança
Encontrou uma vulnerabilidade de segurança? Por favor:
1. Não abra uma issue pública
2. Envie um e-mail para: koukun0120@gmail.com
3. Ou use [Avisos de Segurança do GitHub](https://github.com/yamadashy/repomix/security/advisories/new)
---
layout: home
title: Repomix
titleTemplate: Compacte seu código-fonte em formatos amigáveis para IA
aside: false
editLink: false
features:
- icon: 🤖
title: Otimizado para IA
details: Formata seu código-fonte de uma maneira fácil para a IA entender e processar.
- icon: ⚙️
title: Consciente do Git
details: Respeita automaticamente seus arquivos .gitignore.
- icon: 🛡️
title: Focado na Segurança
details: Incorpora o Secretlint para verificações de segurança robustas para detectar e prevenir a inclusão de informações confidenciais.
- icon: 📊
title: Contagem de Tokens
details: Fornece contagens de tokens para cada arquivo e para todo o repositório, útil para limites de contexto de LLM.
---
## Início Rápido
Depois de gerar um arquivo compactado (`repomix-output.txt`) usando o Repomix, você pode enviá-lo para um assistente de IA com um prompt como:
```
Este arquivo contém todos os arquivos do repositório combinados em um.
Eu quero refatorar o código, então, por favor, revise-o primeiro.
```
A IA analisará todo o seu código-fonte e fornecerá insights abrangentes:
Ao discutir mudanças específicas, a IA pode ajudar a gerar código. Com recursos como o Artifacts do Claude, você pode até receber vários arquivos interdependentes:
Feliz codificação! 🚀
## Guia do Usuário Avançado
Para usuários avançados que precisam de mais controle, o Repomix oferece extensas opções de personalização através de sua interface CLI.
### Início Rápido
Você pode experimentar o Repomix instantaneamente no diretório do seu projeto sem instalação:
```bash
npx repomix
```
Ou instale globalmente para uso repetido:
```bash
# Instalar usando npm
npm install -g repomix
# Alternativamente usando yarn
yarn global add repomix
# Alternativamente usando Homebrew (macOS/Linux)
brew install repomix
# Então execute em qualquer diretório de projeto
repomix
```
É isso! O Repomix irá gerar um arquivo `repomix-output.txt` no seu diretório atual, contendo todo o seu repositório em um formato amigável para IA.
### Uso
Para compactar todo o seu repositório:
```bash
repomix
```
Para compactar um diretório específico:
```bash
repomix path/to/directory
```
Para compactar arquivos ou diretórios específicos usando [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
Para excluir arquivos ou diretórios específicos:
```bash
repomix --ignore "**/*.log,tmp/"
```
Para compactar um repositório remoto:
```bash
# Usando formato abreviado
npx repomix --remote yamadashy/repomix
# Usando URL completa (suporta branches e caminhos específicos)
npx repomix --remote https://github.com/yamadashy/repomix
npx repomix --remote https://github.com/yamadashy/repomix/tree/main
# Usando URL do commit
npx repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
```
Para inicializar um novo arquivo de configuração (`repomix.config.json`):
```bash
repomix --init
```
Depois de gerar o arquivo compactado, você pode usá-lo com ferramentas de IA Generativa como Claude, ChatGPT e Gemini.
#### Uso do Docker
Você também pode executar o Repomix usando o Docker 🐳
Isso é útil se você quiser executar o Repomix em um ambiente isolado ou preferir usar contêineres.
Uso básico (diretório atual):
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
Para compactar um diretório específico:
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
```
Processar um repositório remoto e enviar para um diretório `output`:
```bash
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix
```
### Formatos de Saída
Escolha seu formato de saída preferido:
```bash
# Formato XML (padrão)
repomix --style xml
# Formato Markdown
repomix --style markdown
# Formato de texto simples
repomix --style plain
```
### Customização
Crie um `repomix.config.json` para configurações persistentes:
```json
{
"output": {
"style": "markdown",
"filePath": "custom-output.md",
"removeComments": true,
"showLineNumbers": true,
"topFilesLength": 10
},
"ignore": {
"customPatterns": ["*.test.ts", "docs/**"]
}
}
```
### Mais Exemplos
::: tip
💡 Confira nosso [repositório GitHub](https://github.com/yamadashy/repomix) para documentação completa e mais exemplos!
:::
# Code-Komprimierung
Die Code-Komprimierung ist eine leistungsstarke Funktion, die wichtige Code-Strukturen intelligent extrahiert und dabei Implementierungsdetails entfernt. Dies ist besonders nützlich, um die Token-Anzahl zu reduzieren und gleichzeitig wichtige strukturelle Informationen über Ihre Codebasis beizubehalten.
> [!NOTE]
> Dies ist eine experimentelle Funktion, die wir basierend auf Benutzerfeedback und praktischer Nutzung aktiv verbessern werden.
## Grundlegende Verwendung
Aktivieren Sie die Code-Komprimierung mit der Option `--compress`:
```bash
repomix --compress
```
Sie können sie auch mit Remote-Repositories verwenden:
```bash
repomix --remote user/repo --compress
```
## Funktionsweise
Der Komprimierungsalgorithmus verarbeitet Code mithilfe von Tree-Sitter-Parsing, um wesentliche strukturelle Elemente zu extrahieren und zu bewahren, während Implementierungsdetails entfernt werden.
Die Komprimierung bewahrt:
- Funktions- und Methodensignaturen
- Schnittstellen- und Typdefinitionen
- Klassenstrukturen und Eigenschaften
- Wichtige strukturelle Elemente
Während sie entfernt:
- Funktions- und Methodenimplementierungen
- Details zu Schleifen- und Bedingungslogik
- Interne Variablendeklarationen
- Implementierungsspezifischen Code
### Beispiel
Ursprünglicher TypeScript-Code:
```typescript
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;
}
```
Nach der Komprimierung:
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## Konfiguration
Sie können die Komprimierung in Ihrer Konfigurationsdatei aktivieren:
```json
{
"output": {
"compress": true
}
}
```
## Anwendungsfälle
Die Code-Komprimierung ist besonders nützlich wenn:
- Code-Struktur und Architektur analysiert werden
- Token-Anzahl für LLM-Verarbeitung reduziert werden soll
- Hochrangige Dokumentation erstellt wird
- Code-Muster und Signaturen verstanden werden sollen
- API- und Schnittstellendesigns geteilt werden
## Verwandte Optionen
Sie können die Komprimierung mit anderen Optionen kombinieren:
- `--remove-comments`: Code-Kommentare entfernen
- `--remove-empty-lines`: Leere Zeilen entfernen
- `--output-show-line-numbers`: Zeilennummern zur Ausgabe hinzufügen
# Erste Schritte mit Repomix
Repomix ist ein Tool, das Ihr gesamtes Repository in eine einzige, KI-freundliche Datei verpackt. Es wurde entwickelt, um Ihren Codebase an große Sprachmodelle (LLMs) wie ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok und mehr zu übergeben.
## Schnellstart
Führen Sie diesen Befehl in Ihrem Projektverzeichnis aus:
```bash
npx repomix
```
Das war's! Sie finden eine `repomix-output.txt` Datei, die Ihr gesamtes Repository in einem KI-freundlichen Format enthält.
Sie können diese Datei dann mit einem Prompt wie diesem an einen KI-Assistenten senden:
```
Diese Datei enthält alle Dateien im Repository in einer Datei zusammengefasst.
Ich möchte den Code refaktorieren, bitte überprüfen Sie ihn zuerst.
```
Die KI wird Ihren gesamten Codebase analysieren und umfassende Einblicke geben:
Bei der Diskussion spezifischer Änderungen kann die KI bei der Code-Generierung helfen. Mit Funktionen wie Claudes Artifacts können Sie sogar mehrere voneinander abhängige Dateien erhalten:
Viel Spaß beim Programmieren! 🚀
## Kernfunktionen
- **KI-optimierte Ausgabe**: Formatiert Ihren Codebase für einfache KI-Verarbeitung
- **Token-Zählung**: Verfolgt Token-Nutzung für LLM-Kontextgrenzen
- **Git-bewusst**: Berücksichtigt Ihre `.gitignore`-Dateien und `.git/info/exclude`-Dateien
- **Sicherheitsorientiert**: Erkennt sensible Informationen
- **Mehrere Ausgabeformate**: Wählen Sie zwischen Klartext, XML oder Markdown
## Was kommt als Nächstes?
- [Installationsanleitung](installation.md): Verschiedene Möglichkeiten, Repomix zu installieren
- [Verwendungsleitfaden](usage.md): Lernen Sie grundlegende und erweiterte Funktionen kennen
- [Konfiguration](configuration.md): Passen Sie Repomix an Ihre Bedürfnisse an
- [Sicherheitsfunktionen](security.md): Erfahren Sie mehr über Sicherheitsprüfungen
## Community
Treten Sie unserer [Discord-Community](https://discord.gg/wNYzTwZFku) bei für:
- Hilfe mit Repomix
- Teilen Sie Ihre Erfahrungen
- Vorschlagen neuer Funktionen
- Verbindung mit anderen Benutzern
## Unterstützung
Haben Sie einen Fehler gefunden oder brauchen Sie Hilfe?
- [Öffnen Sie ein Issue auf GitHub](https://github.com/yamadashy/repomix/issues)
- Treten Sie unserem Discord-Server bei
- Lesen Sie die [Dokumentation](https://repomix.com)
# Ausgabeformate
Repomix unterstützt drei Ausgabeformate:
- XML (Standard)
- Markdown
- Klartext
## XML-Format
```bash
repomix --style xml
```
Das XML-Format ist für die KI-Verarbeitung optimiert:
::: tip Warum XML?
XML-Tags helfen KI-Modellen wie Claude, Inhalte genauer zu analysieren. Die [Claude-Dokumentation](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags) empfiehlt die Verwendung von XML-Tags für strukturierte Prompts.
:::
```xml
Diese Datei ist eine zusammengeführte Darstellung der gesamten Codebasis...
(Metadaten und KI-Anweisungen)
src/
index.ts
utils/
helper.ts
// Dateiinhalt hier
## Markdown-Format
```bash
repomix --style markdown
```
Markdown bietet lesbare Formatierung:
```markdown
Diese Datei ist eine zusammengeführte Darstellung der gesamten Codebasis...
# Dateizusammenfassung
(Metadaten und KI-Anweisungen)
# Verzeichnisstruktur
```text
src/
index.ts
utils/
helper.ts
```
# Dateien
## Datei: src/index.ts
```typescript
// Dateiinhalt hier
```
## Klartext-Format
```bash
repomix --style plain
```
Ausgabestruktur:
```text
Diese Datei ist eine zusammengeführte Darstellung der gesamten Codebasis...
================
Dateizusammenfassung
================
(Metadaten und KI-Anweisungen)
================
Verzeichnisstruktur
================
src/
index.ts
utils/
helper.ts
================
Dateien
================
================
Datei: src/index.ts
================
// Dateiinhalt hier
```
# Grundlegende Verwendung
## Schnellstart
Packen Sie Ihr gesamtes Repository:
```bash
repomix
```
## Häufige Anwendungsfälle
### Bestimmte Verzeichnisse packen
```bash
repomix path/to/directory
```
### Bestimmte Dateien einschließen
Verwenden Sie [Glob-Muster](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### Dateien ausschließen
```bash
repomix --ignore "**/*.log,tmp/"
```
### Remote-Repositories
```bash
# Mit GitHub-URL
repomix --remote https://github.com/user/repo
# Mit Kurzform
repomix --remote user/repo
# Bestimmter Branch/Tag/Commit
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
## Ausgabeformate
### XML (Standard)
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### Klartext
```bash
repomix --style plain
```
## Zusätzliche Optionen
### Kommentare entfernen
```bash
repomix --remove-comments
```
### Zeilennummern anzeigen
```bash
repomix --output-show-line-numbers
```
### In die Zwischenablage kopieren
```bash
repomix --copy
```
### Sicherheitsprüfung deaktivieren
```bash
repomix --no-security-check
```
## Konfiguration
Konfigurationsdatei initialisieren:
```bash
repomix --init
```
Siehe [Konfigurationsleitfaden](/de/guide/configuration) für detaillierte Optionen.
# Code Compression
Code compression is a powerful feature that intelligently extracts essential code structures while removing implementation details. This is particularly useful for reducing token count while maintaining important structural information about your codebase.
> [!NOTE]
> This is an experimental feature that we'll be actively improving based on user feedback and real-world usage
## Basic Usage
Enable code compression using the `--compress` flag:
```bash
repomix --compress
```
You can also use it with remote repositories:
```bash
repomix --remote user/repo --compress
```
## How It Works
The compression algorithm processes code using tree-sitter parsing to extract and preserve essential structural elements while removing implementation details.
The compression preserves:
- Function and method signatures
- Interface and type definitions
- Class structures and properties
- Important structural elements
While removing:
- Function and method implementations
- Loop and conditional logic details
- Internal variable declarations
- Implementation-specific code
### Example
Original TypeScript code:
```typescript
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;
}
```
After compression:
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## Configuration
You can enable compression in your configuration file:
```json
{
"output": {
"compress": true
}
}
```
## Use Cases
Code compression is particularly useful when:
- Analyzing code structure and architecture
- Reducing token count for LLM processing
- Creating high-level documentation
- Understanding code patterns and signatures
- Sharing API and interface designs
## Related Options
You can combine compression with other options:
- `--remove-comments`: Remove code comments
- `--remove-empty-lines`: Remove empty lines
- `--output-show-line-numbers`: Add line numbers to output
# Getting Started with Repomix
Repomix is a tool that packs your entire repository into a single, AI-friendly file. It's designed to help you feed your codebase to Large Language Models (LLMs) like ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok, and more.
## Quick Start
Run this command in your project directory:
```bash
npx repomix
```
That's it! You'll find a `repomix-output.txt` file 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.
```
The AI will analyze your entire codebase and provide comprehensive insights:
When discussing specific changes, the AI can help generate code. With features like Claude's Artifacts, you can even receive multiple interdependent files:
Happy coding! 🚀
## Core Features
- **AI-Optimized Output**: Formats your codebase for easy AI processing
- **Token Counting**: Tracks token usage for LLM context limits
- **Git-Aware**: Respects your `.gitignore` and `.git/info/exclude` files
- **Security-Focused**: Detects sensitive information
- **Multiple Output Formats**: Choose between plain text, XML, or Markdown
## What's Next?
- [Installation Guide](installation.md): Different ways to install Repomix
- [Usage Guide](usage.md): Learn about basic and advanced features
- [Configuration](configuration.md): Customize Repomix for your needs
- [Security Features](security.md): Learn about security checks
## Community
Join our [Discord community](https://discord.gg/wNYzTwZFku) for:
- Getting help with Repomix
- Sharing your experiences
- Suggesting new features
- Connecting with other users
## Support
Found a bug or need help?
- [Open an issue on GitHub](https://github.com/yamadashy/repomix/issues)
- Join our Discord server
- Check the [documentation](https://repomix.com)
# Output Formats
Repomix supports three output formats:
- XML (default)
- Markdown
- Plain Text
## XML Format
```bash
repomix --style xml
```
XML format is optimized for AI processing:
```xml
This file is a merged representation of the entire codebase...
(Metadata and AI instructions)
src/
index.ts
utils/
helper.ts
// File contents here
```
::: tip Why XML?
XML tags help AI models like Claude parse content more accurately. [Claude Documentation](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags) recommends using XML tags for structured prompts.
:::
## Markdown Format
```bash
repomix --style markdown
```
Markdown provides readable formatting:
```markdown
This file is a merged representation of the entire codebase...
# File Summary
(Metadata and AI instructions)
# Directory Structure
```
src/
index.ts
utils/
helper.ts
```
# Files
## File: src/index.ts
```typescript
// File contents here
```
```
## Usage with AI Models
Each format works well with AI models, but consider:
- Use XML for Claude (best parsing accuracy)
- Use Markdown for general readability
- Use Plain Text for simplicity and universal compatibility
## Customization
Set default format in `repomix.config.json`:
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
```
## Plain Text Format
```bash
repomix --style plain
```
Output structure:
```text
This file is a merged representation of the entire codebase...
================
File Summary
================
(Metadata and AI instructions)
================
Directory Structure
================
src/
index.ts
utils/
helper.ts
================
Files
================
================
File: src/index.ts
================
// File contents here
```
# Compresión de Código
La compresión de código es una función poderosa que extrae de manera inteligente las estructuras esenciales del código mientras elimina los detalles de implementación. Esto es particularmente útil para reducir el conteo de tokens mientras se mantiene la información estructural importante de tu base de código.
> [!NOTE]
> Esta es una función experimental que mejoraremos activamente según los comentarios de los usuarios y el uso en el mundo real.
## Uso Básico
Habilita la compresión de código usando la bandera `--compress`:
```bash
repomix --compress
```
También puedes usarlo con repositorios remotos:
```bash
repomix --remote user/repo --compress
```
## Cómo Funciona
El algoritmo de compresión procesa el código utilizando el análisis de Tree-sitter para extraer y preservar elementos estructurales esenciales mientras elimina los detalles de implementación.
La compresión preserva:
- Firmas de funciones y métodos
- Definiciones de interfaces y tipos
- Estructuras de clases y propiedades
- Elementos estructurales importantes
Mientras elimina:
- Implementaciones de funciones y métodos
- Detalles de lógica de bucles y condicionales
- Declaraciones de variables internas
- Código específico de implementación
### Ejemplo
Código TypeScript original:
```typescript
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;
}
```
Después de la compresión:
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## Configuración
Puedes habilitar la compresión en tu archivo de configuración:
```json
{
"output": {
"compress": true
}
}
```
## Casos de Uso
La compresión de código es particularmente útil cuando:
- Analizas la estructura y arquitectura del código
- Reduces el conteo de tokens para procesamiento con LLM
- Creas documentación de alto nivel
- Comprendes patrones y firmas de código
- Compartes diseños de API e interfaces
## Opciones Relacionadas
Puedes combinar la compresión con otras opciones:
- `--remove-comments`: Eliminar comentarios del código
- `--remove-empty-lines`: Eliminar líneas vacías
- `--output-show-line-numbers`: Agregar números de línea a la salida
# Primeros pasos con Repomix
Repomix es una herramienta que empaqueta todo tu repositorio en un solo archivo amigable para la IA. Está diseñado para ayudarte a alimentar tu código a modelos de lenguaje grandes (LLMs) como ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok y más.
## Inicio rápido
Ejecuta este comando en el directorio de tu proyecto:
```bash
npx repomix
```
¡Eso es todo! Encontrarás un archivo `repomix-output.txt` que contiene todo tu repositorio en un formato amigable para la IA.
Luego puedes enviar este archivo a un asistente de IA con un prompt como:
```
Este archivo contiene todos los archivos del repositorio combinados en uno.
Quiero refactorizar el código, así que por favor revísalo primero.
```
La IA analizará todo tu código y proporcionará información completa:
Al discutir cambios específicos, la IA puede ayudar a generar código. Con funciones como los Artefactos de Claude, incluso puedes recibir múltiples archivos interdependientes:
¡Feliz programación! 🚀
## Características principales
- **Salida optimizada para IA**: Formatea tu código para un fácil procesamiento por parte de la IA
- **Conteo de tokens**: Realiza un seguimiento del uso de tokens para los límites de contexto de los LLM
- **Compatible con Git**: Respeta tus archivos `.gitignore` y `.git/info/exclude`
- **Enfocado en la seguridad**: Detecta información sensible
- **Múltiples formatos de salida**: Elige entre texto plano, XML o Markdown
## ¿Qué sigue?
- [Guía de instalación](installation.md): Diferentes formas de instalar Repomix
- [Guía de uso](usage.md): Aprende sobre las funciones básicas y avanzadas
- [Configuración](configuration.md): Personaliza Repomix para tus necesidades
- [Funciones de seguridad](security.md): Aprende sobre las comprobaciones de seguridad
## Comunidad
Únete a nuestra [comunidad de Discord](https://discord.gg/wNYzTwZFku) para:
- Obtener ayuda con Repomix
- Compartir tus experiencias
- Sugerir nuevas funciones
- Conectarte con otros usuarios
## Soporte
¿Encontraste un error o necesitas ayuda?
- [Abre un issue en GitHub](https://github.com/yamadashy/repomix/issues)
- Únete a nuestro servidor de Discord
- Consulta la [documentación](https://repomix.com)
# Formatos de salida
Repomix admite tres formatos de salida:
- XML (predeterminado)
- Markdown
- Texto sin formato
## Formato XML
```bash
repomix --style xml
```
El formato XML está optimizado para el procesamiento de IA:
```xml
Este archivo es una representación fusionada de toda la base de código...
(Metadatos e instrucciones de IA)
src/
index.ts
utils/
helper.ts
// Contenido del archivo aquí
```
::: tip ¿Por qué XML?
Las etiquetas XML ayudan a los modelos de IA como Claude a analizar el contenido con mayor precisión. La [documentación de Claude](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags) recomienda usar etiquetas XML para prompts estructurados.
:::
## Formato Markdown
```bash
repomix --style markdown
```
Markdown proporciona un formato legible:
```markdown
Este archivo es una representación fusionada de toda la base de código...
# Resumen de archivos
(Metadatos e instrucciones de IA)
# Estructura de directorios
```
src/
index.ts
utils/
helper.ts
```
# Archivos
## Archivo: src/index.ts
```typescript
// Contenido del archivo aquí
```
```
## Uso con modelos de IA
Cada formato funciona bien con modelos de IA, pero considera:
- Usar XML para Claude (mejor precisión de análisis)
- Usar Markdown para legibilidad general
- Usar texto sin formato para simplicidad y compatibilidad universal
## Personalización
Establece el formato predeterminado en `repomix.config.json`:
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
## Formato de texto sin formato
```bash
repomix --style plain
```
Estructura de salida:
```text
Este archivo es una representación fusionada de toda la base de código...
================
Resumen de archivos
================
(Metadatos e instrucciones de IA)
================
Estructura de directorios
================
src/
index.ts
utils/
helper.ts
================
Archivos
================
================
Archivo: src/index.ts
================
// Contenido del archivo aquí
```
# Uso básico
## Inicio rápido
Empaqueta todo tu repositorio:
```bash
repomix
```
## Casos de uso comunes
### Empaquetar directorios específicos
```bash
repomix ruta/al/directorio
```
### Incluir archivos específicos
Usa [patrones glob](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### Excluir archivos
```bash
repomix --ignore "**/*.log,tmp/"
```
### Repositorios remotos
```bash
# Usando la URL de GitHub
repomix --remote https://github.com/usuario/repositorio
# Usando la abreviatura
repomix --remote usuario/repositorio
# Rama/etiqueta/commit específico
repomix --remote usuario/repositorio --remote-branch main
repomix --remote usuario/repositorio --remote-branch 935b695
```
## Formatos de salida
### XML (predeterminado)
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### Texto sin formato
```bash
repomix --style plain
```
## Opciones adicionales
### Eliminar comentarios
```bash
repomix --remove-comments
```
### Mostrar números de línea
```bash
repomix --output-show-line-numbers
```
### Copiar al portapapeles
```bash
repomix --copy
```
### Deshabilitar la verificación de seguridad
```bash
repomix --no-security-check
```
## Configuración
Inicializar el archivo de configuración:
```bash
repomix --init
```
Consulta la [Guía de configuración](/guide/configuration) para obtener opciones detalladas.
# Contribuer à Repomix
## Démarrage rapide
```bash
git clone https://github.com/yamadashy/repomix.git
cd repomix
npm install
```
## Commandes de développement
```bash
# Exécuter le CLI
npm run repomix
# Exécuter les tests
npm run test
npm run test-coverage
# Linter le code
npm run lint
```
## Style de code
- Utiliser [Biome](https://biomejs.dev/) pour le linting et le formatage
- Injection de dépendances pour la testabilité
- Maintenir les fichiers en dessous de 250 lignes
- Ajouter des tests pour les nouvelles fonctionnalités
## Directives pour les Pull Requests
1. Exécuter tous les tests
2. Passer les vérifications de linting
3. Mettre à jour la documentation
4. Suivre le style de code existant
## Besoin d'aide?
- [Ouvrir un ticket](https://github.com/yamadashy/repomix/issues)
- [Rejoindre Discord](https://discord.gg/wNYzTwZFku)
# Configuration de l'environnement de développement
## Prérequis
- Node.js ≥ 18.0.0
- Git
- npm
## Développement local
```bash
# Cloner le dépôt
git clone https://github.com/yamadashy/repomix.git
cd repomix
# Installer les dépendances
npm install
# Exécuter le CLI
npm run repomix
```
## Développement avec Docker
```bash
# Construire l'image
docker build -t repomix .
# Exécuter le conteneur
docker run -v ./:/app -it --rm repomix
```
## Structure du projet
```
src/
├── cli/ # Implémentation du CLI
├── config/ # Gestion de la configuration
├── core/ # Fonctionnalités principales
└── shared/ # Utilitaires partagés
```
## Tests
```bash
# Exécuter les tests
npm run test
# Couverture des tests
npm run test-coverage
# Linting
npm run lint-biome
npm run lint-ts
npm run lint-secretlint
```
## Processus de publication
1. Mettre à jour la version
```bash
npm version patch # ou minor/major
```
2. Exécuter les tests et construire
```bash
npm run test-coverage
npm run build
```
3. Publier
```bash
npm publish
```
# Meilleures pratiques de développement assisté par IA : De mon expérience
Bien que je n'aie pas encore réussi à mener à bien un projet à grande échelle en utilisant l'IA, je souhaite partager ce que j'ai appris jusqu'à présent de mon expérience de travail avec l'IA dans le développement.
## Approche de développement de base
Lorsque l'on travaille avec l'IA, tenter d'implémenter toutes les fonctionnalités en une fois peut conduire à des problèmes inattendus et à une stagnation du projet. C'est pourquoi il est plus efficace de commencer par les fonctionnalités principales et de construire chaque fonctionnalité une par une, en s'assurant d'une implémentation solide avant d'avancer.
### La puissance du code existant
Cette approche est efficace car l'implémentation des fonctionnalités principales vous permet de matérialiser votre design idéal et votre style de codage à travers du code réel. La manière la plus efficace de communiquer votre vision du projet est à travers du code qui reflète vos standards et préférences.
En commençant par les fonctionnalités principales et en s'assurant que chaque composant fonctionne correctement avant de passer à la suite, l'ensemble du projet maintient sa cohérence, rendant plus facile pour l'IA de générer du code plus approprié.
## L'approche modulaire
La décomposition du code en modules plus petits est cruciale. D'après mon expérience, maintenir les fichiers autour de 250 lignes de code rend plus facile de donner des instructions claires à l'IA et rend le processus d'essai-erreur plus efficace. Bien que le nombre de tokens serait une métrique plus précise, le nombre de lignes est plus pratique pour les développeurs humains, nous utilisons donc cela comme ligne directrice.
Cette modularisation ne consiste pas seulement à séparer les composants frontend, backend et base de données - il s'agit de décomposer les fonctionnalités à un niveau beaucoup plus fin. Par exemple, au sein d'une même fonctionnalité, vous pourriez séparer la validation, la gestion des erreurs et d'autres fonctionnalités spécifiques en modules distincts. Bien sûr, la séparation de haut niveau est également importante, et implémenter cette approche modulaire progressivement aide à maintenir des instructions claires et permet à l'IA de générer du code plus approprié. Cette approche est efficace non seulement pour l'IA mais aussi pour les développeurs humains.
## Assurer la qualité par les tests
Je considère que les tests sont cruciaux dans le développement assisté par IA. Les tests servent non seulement de mesures d'assurance qualité mais aussi de documentation qui démontre clairement les intentions du code. Lorsque vous demandez à l'IA d'implémenter de nouvelles fonctionnalités, le code de test existant agit efficacement comme un document de spécification.
Les tests sont également un excellent outil pour valider l'exactitude du code généré par l'IA. Par exemple, lorsque vous faites implémenter une nouvelle fonctionnalité pour un module par l'IA, écrire des cas de test au préalable vous permet d'évaluer objectivement si le code généré se comporte comme prévu. Cela s'aligne bien avec les principes du Développement Piloté par les Tests (TDD) et est particulièrement efficace lors de la collaboration avec l'IA.
## Équilibrer planification et implémentation
Avant d'implémenter des fonctionnalités à grande échelle, je recommande de d'abord discuter du plan avec l'IA. Organiser les exigences et réfléchir à l'architecture conduit à une implémentation plus fluide. Une bonne pratique consiste à compiler d'abord les exigences, puis passer à une session de chat séparée pour le travail d'implémentation.
Il est essentiel que les humains examinent la sortie de l'IA et fassent des ajustements si nécessaire. Bien que la qualité du code généré par l'IA soit généralement modérée, cela accélère tout de même le développement par rapport à l'écriture de tout à partir de zéro.
## Conclusion
En suivant ces pratiques, vous pouvez exploiter les points forts de l'IA tout en construisant une base de code cohérente et de haute qualité. Même lorsque votre projet grandit en taille, chaque composant reste bien défini et gérable.
# Compression de code
La compression de code est une fonctionnalité puissante qui extrait intelligemment les structures de code essentielles tout en supprimant les détails d'implémentation. C'est particulièrement utile pour réduire le nombre de tokens tout en conservant les informations structurelles importantes de votre base de code.
> [!NOTE]
> Il s'agit d'une fonctionnalité expérimentale que nous améliorerons activement en fonction des retours utilisateurs et de l'usage réel
## Utilisation de base
Activez la compression de code en utilisant l'option `--compress`:
```bash
repomix --compress
```
Vous pouvez également l'utiliser avec des dépôts distants:
```bash
repomix --remote user/repo --compress
```
## Fonctionnement
L'algorithme de compression traite le code en utilisant l'analyse tree-sitter pour extraire et préserver les éléments structurels essentiels tout en supprimant les détails d'implémentation.
La compression préserve:
- Les signatures de fonctions et de méthodes
- Les définitions d'interfaces et de types
- Les structures de classes et leurs propriétés
- Les éléments structurels importants
Tout en supprimant:
- Les implémentations de fonctions et de méthodes
- Les détails de logique des boucles et conditions
- Les déclarations de variables internes
- Le code spécifique à l'implémentation
### Exemple
Code TypeScript original:
```typescript
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;
}
```
Après compression:
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## Configuration
Vous pouvez activer la compression dans votre fichier de configuration:
```json
{
"output": {
"compress": true
}
}
```
## Cas d'utilisation
La compression de code est particulièrement utile pour:
- Analyser la structure et l'architecture du code
- Réduire le nombre de tokens pour le traitement par les LLM
- Créer une documentation de haut niveau
- Comprendre les motifs de code et les signatures
- Partager les conceptions d'API et d'interfaces
## Options associées
Vous pouvez combiner la compression avec d'autres options:
- `--remove-comments`: Supprimer les commentaires du code
- `--remove-empty-lines`: Supprimer les lignes vides
- `--output-show-line-numbers`: Ajouter les numéros de ligne à la sortie
# Options de ligne de commande
## Options de base
- `-v, --version`: Afficher la version de l'outil
## Options de sortie
- `-o, --output `: Nom du fichier de sortie (par défaut: `repomix-output.txt`)
- `--style `: Style de sortie (`plain`, `xml`, `markdown`) (par défaut: `plain`)
- `--parsable-style`: Activer une sortie analysable basée sur le schéma du style choisi (par défaut: `false`)
- `--compress`: Effectuer une extraction intelligente du code, en se concentrant sur les signatures essentielles de fonctions et de classes tout en supprimant les détails d'implémentation. Pour plus de détails et d'exemples, voir [Guide de compression de code](code-compress).
- `--output-show-line-numbers`: Ajouter les numéros de ligne (par défaut: `false`)
- `--copy`: Copier dans le presse-papiers (par défaut: `false`)
- `--no-file-summary`: Désactiver le résumé des fichiers (par défaut: `true`)
- `--no-directory-structure`: Désactiver la structure des répertoires (par défaut: `true`)
- `--remove-comments`: Supprimer les commentaires (par défaut: `false`)
- `--remove-empty-lines`: Supprimer les lignes vides (par défaut: `false`)
- `--header-text `: Texte personnalisé à inclure dans l'en-tête du fichier
- `--instruction-file-path `: Chemin vers un fichier contenant des instructions personnalisées détaillées
- `--include-empty-directories`: Inclure les répertoires vides dans la sortie (par défaut: `false`)
## Options de filtrage
- `--include `: Motifs d'inclusion (séparés par des virgules)
- `-i, --ignore `: Motifs d'exclusion (séparés par des virgules)
- `--no-gitignore`: Désactiver l'utilisation du fichier .gitignore
- `--no-default-patterns`: Désactiver les motifs par défaut
## Options de dépôt distant
- `--remote `: Traiter un dépôt distant
- `--remote-branch `: Spécifier le nom de la branche distante, le tag ou le hash de commit (par défaut: branche par défaut du dépôt)
## Options de configuration
- `-c, --config `: Chemin du fichier de configuration personnalisé
- `--init`: Créer un fichier de configuration
- `--global`: Utiliser la configuration globale
## Options de sécurité
- `--no-security-check`: Désactiver la vérification de sécurité (par défaut: `true`)
## Options de comptage de tokens
- `--token-count-encoding `: Spécifier l'encodage du comptage de tokens (par exemple, `o200k_base`, `cl100k_base`) (par défaut: `o200k_base`)
## Autres options
- `--top-files-len `: Nombre de fichiers principaux à afficher (par défaut: `5`)
- `--verbose`: Activer la journalisation détaillée
- `--quiet`: Désactiver toutes les sorties vers stdout
## Exemples
```bash
# Utilisation de base
repomix
# Sortie personnalisée
repomix -o output.xml --style xml
# Sortie personnalisée avec compression
repomix --compress
# Traiter des fichiers spécifiques
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# Dépôt distant avec branche
repomix --remote https://github.com/user/repo/tree/main
# Dépôt distant avec commit
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# Dépôt distant avec format abrégé
repomix --remote user/repo
```
# Suppression des commentaires
Repomix peut automatiquement supprimer les commentaires de votre base de code lors de la génération du fichier de sortie. Cela peut aider à réduire le bruit et à se concentrer sur le code réel.
## Utilisation
Pour activer la suppression des commentaires, définissez l'option `removeComments` sur `true` dans votre `repomix.config.json`:
```json
{
"output": {
"removeComments": true
}
}
```
## Langages pris en charge
Repomix prend en charge la suppression des commentaires pour une large gamme de langages de programmation, notamment:
- JavaScript/TypeScript (`//`, `/* */`)
- Python (`#`, `"""`, `'''`)
- Java (`//`, `/* */`)
- C/C++ (`//`, `/* */`)
- HTML (``)
- CSS (`/* */`)
- Et bien d'autres...
## Exemple
Considérons le code JavaScript suivant:
```javascript
// Ceci est un commentaire sur une ligne
function test() {
/* Ceci est un
commentaire sur
plusieurs lignes */
return true;
}
```
Avec la suppression des commentaires activée, la sortie sera:
```javascript
function test() {
return true;
}
```
## Remarques
- La suppression des commentaires est effectuée avant les autres étapes de traitement, comme l'ajout de numéros de ligne.
- Certains commentaires, comme les commentaires JSDoc, peuvent être préservés selon le langage et le contexte.
# Configuration
## Démarrage rapide
Créer un fichier de configuration:
```bash
repomix --init
```
## Fichier de configuration
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "Texte d'en-tête personnalisé",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## Configuration globale
Créer une configuration globale:
```bash
repomix --init --global
```
Emplacement:
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## Motifs d'exclusion
Priorité:
1. Options CLI (`--ignore`)
2. `.repomixignore`
3. `.gitignore` et `.git/info/exclude`
4. Motifs par défaut
Exemple de `.repomixignore`:
```text
# Répertoires de cache
.cache/
tmp/
# Sorties de build
dist/
build/
# Logs
*.log
```
## Motifs d'exclusion par défaut
Motifs communs inclus par défaut:
```text
node_modules/**
.git/**
coverage/**
dist/**
```
Liste complète: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## Exemples
### Compression de code
Lorsque `output.compress` est défini sur `true`, Repomix extraira intelligemment les structures de code essentielles tout en supprimant les détails d'implémentation. Cela aide à réduire le nombre de tokens tout en conservant les informations structurelles importantes.
Pour plus de détails et d'exemples, consultez le [Guide de compression de code](code-compress).
### Intégration Git
La configuration `output.git` vous permet de contrôler comment les fichiers sont triés en fonction de l'historique Git:
- `sortByChanges`: Lorsque défini sur `true`, les fichiers sont triés par nombre de changements Git (commits qui ont modifié le fichier). Les fichiers avec plus de changements apparaissent en bas de la sortie. Cela peut aider à prioriser les fichiers plus activement développés. Par défaut: `true`
- `sortByChangesMaxCommits`: Le nombre maximum de commits à analyser lors du comptage des modifications de fichiers. Par défaut: `100`
Exemple de configuration:
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### Suppression des commentaires
Lorsque `output.removeComments` est défini sur `true`, Repomix supprimera les commentaires des types de fichiers pris en charge pour réduire la taille de sortie et se concentrer sur le contenu essentiel du code.
Pour les langages pris en charge et des exemples détaillés, consultez le [Guide de suppression des commentaires](comment-removal).
# Instructions personnalisées
Repomix vous permet de fournir des instructions personnalisées qui seront incluses dans le fichier de sortie. Cela peut être utile pour ajouter du contexte ou des directives spécifiques pour les systèmes d'IA traitant le dépôt.
## Utilisation
Pour inclure une instruction personnalisée, créez un fichier markdown (par exemple, `repomix-instruction.md`) à la racine de votre dépôt. Ensuite, spécifiez le chemin vers ce fichier dans votre `repomix.config.json`:
```json
{
"output": {
"instructionFilePath": "repomix-instruction.md"
}
}
```
Le contenu de ce fichier sera inclus dans la sortie sous la section "Instruction".
## Exemple
```markdown
# Instructions du dépôt
Ce dépôt contient le code source de l'outil Repomix. Veuillez suivre ces directives lors de l'analyse du code:
1. Concentrez-vous sur les fonctionnalités principales dans le répertoire `src/core`.
2. Portez une attention particulière aux vérifications de sécurité dans `src/core/security`.
3. Ignorez tous les fichiers dans le répertoire `tests`.
```
Cela donnera la section suivante dans la sortie:
```xml
# Instructions du dépôt
Ce dépôt contient le code source de l'outil Repomix. Veuillez suivre ces directives lors de l'analyse du code:
1. Concentrez-vous sur les fonctionnalités principales dans le répertoire `src/core`.
2. Portez une attention particulière aux vérifications de sécurité dans `src/core/security`.
3. Ignorez tous les fichiers dans le répertoire `tests`.
```
# Commencer avec Repomix
Repomix est un outil qui regroupe l'ensemble de votre dépôt de code en un seul fichier adapté à l'IA. Il est conçu pour vous aider à fournir votre base de code aux Grands Modèles de Langage (LLMs) comme ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok, et plus encore.
## Démarrage rapide
Exécutez cette commande dans le répertoire de votre projet:
```bash
npx repomix
```
C'est tout! Vous trouverez un fichier `repomix-output.txt` contenant l'intégralité de votre dépôt dans un format adapté à l'IA.
Vous pouvez ensuite envoyer ce fichier à un assistant IA avec une instruction comme:
```
Ce fichier contient tous les fichiers du dépôt combinés en un seul.
Je souhaite refactoriser le code, veuillez donc d'abord l'examiner.
```
L'IA analysera votre base de code complète et fournira des informations détaillées:
Lors de la discussion de modifications spécifiques, l'IA peut vous aider à générer du code. Avec des fonctionnalités comme les Artefacts de Claude, vous pouvez même recevoir plusieurs fichiers interdépendants:
Bon codage! 🚀
## Fonctionnalités principales
- **Sortie optimisée pour l'IA**: Formate votre base de code pour un traitement facile par l'IA
- **Comptage de tokens**: Suit l'utilisation des tokens pour les limites de contexte des LLM
- **Compatible avec Git**: Respecte vos fichiers `.gitignore` et `.git/info/exclude`
- **Axé sur la sécurité**: Détecte les informations sensibles
- **Plusieurs formats de sortie**: Choisissez entre texte brut, XML ou Markdown
## Prochaines étapes
- [Guide d'installation](installation.md): Différentes façons d'installer Repomix
- [Guide d'utilisation](usage.md): Découvrez les fonctionnalités de base et avancées
- [Configuration](configuration.md): Personnalisez Repomix selon vos besoins
- [Fonctionnalités de sécurité](security.md): Découvrez les vérifications de sécurité
## Communauté
Rejoignez notre [communauté Discord](https://discord.gg/wNYzTwZFku) pour:
- Obtenir de l'aide avec Repomix
- Partager vos expériences
- Suggérer de nouvelles fonctionnalités
- Vous connecter avec d'autres utilisateurs
## Support
Vous avez trouvé un bug ou besoin d'aide?
- [Ouvrez un ticket sur GitHub](https://github.com/yamadashy/repomix/issues)
- Rejoignez notre serveur Discord
- Consultez la [documentation](https://repomix.com)
# Installation
## Utilisation avec npx (Sans installation requise)
```bash
npx repomix
```
## Installation globale
### npm
```bash
npm install -g repomix
```
### Yarn
```bash
yarn global add repomix
```
### Homebrew (macOS/Linux)
```bash
brew install repomix
```
## Installation avec Docker
Téléchargez et exécutez l'image Docker:
```bash
# Répertoire courant
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
# Répertoire spécifique
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
# Dépôt distant
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote yamadashy/repomix
```
## Extension VSCode
Exécutez Repomix directement dans VSCode avec l'extension communautaire [Repomix Runner](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner).
Fonctionnalités:
- Empaquetez n'importe quel dossier en quelques clics
- Choisissez entre le mode fichier ou contenu pour la copie
- Nettoyage automatique des fichiers de sortie
- Compatible avec repomix.config.json
Installez-la depuis le [Marketplace VSCode](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner).
## Configuration requise
- Node.js: ≥ 18.0.0
- Git: Requis pour le traitement des dépôts distants
## Vérification
Après l'installation, vérifiez que Repomix fonctionne:
```bash
repomix --version
repomix --help
```
# Serveur MCP
Repomix prend en charge le [Model Context Protocol (MCP)](https://modelcontextprotocol.io), permettant aux assistants IA d'interagir directement avec votre base de code. Lorsqu'il est exécuté en tant que serveur MCP, Repomix fournit des outils permettant aux assistants IA de packager des dépôts locaux ou distants pour analyse sans nécessiter de préparation manuelle des fichiers.
> [!NOTE]
> Il s'agit d'une fonctionnalité expérimentale que nous améliorerons activement en fonction des retours utilisateurs et de l'usage réel
## Exécuter Repomix comme serveur MCP
Pour exécuter Repomix en tant que serveur MCP, utilisez l'option `--mcp`:
```bash
repomix --mcp
```
Cela démarre Repomix en mode serveur MCP, le rendant disponible pour les assistants IA qui prennent en charge le Model Context Protocol.
## Outils MCP disponibles
En mode serveur MCP, Repomix fournit les outils suivants:
### pack_codebase
Cet outil package un répertoire de code local dans un fichier consolidé pour l'analyse par IA.
**Paramètres:**
- `directory`: (Requis) Chemin absolu vers le répertoire à packager
- `compress`: (Optionnel, par défaut: true) Effectuer ou non l'extraction intelligente de code pour réduire le nombre de tokens
- `includePatterns`: (Optionnel) Liste de motifs d'inclusion séparés par des virgules
- `ignorePatterns`: (Optionnel) Liste de motifs d'exclusion séparés par des virgules
**Exemple:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
Cet outil récupère, clone et package un dépôt GitHub dans un fichier consolidé pour l'analyse par IA.
**Paramètres:**
- `remote`: (Requis) URL du dépôt GitHub ou format utilisateur/dépôt (par exemple, yamadashy/repomix)
- `compress`: (Optionnel, par défaut: true) Effectuer ou non l'extraction intelligente de code pour réduire le nombre de tokens
- `includePatterns`: (Optionnel) Liste de motifs d'inclusion séparés par des virgules
- `ignorePatterns`: (Optionnel) Liste de motifs d'exclusion séparés par des virgules
**Exemple:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### file_system_read_file et file_system_read_directory
Le serveur MCP de Repomix fournit deux outils système de fichiers qui permettent aux assistants IA d'interagir en toute sécurité avec le système de fichiers local:
1. `file_system_read_file`
- Lit le contenu des fichiers en utilisant des chemins absolus
- Implémente la validation de sécurité avec [Secretlint](https://github.com/secretlint/secretlint)
- Empêche l'accès aux fichiers contenant des informations sensibles
- Renvoie du contenu formaté avec des messages d'erreur clairs pour les chemins invalides ou les problèmes de sécurité
2. `file_system_read_directory`
- Liste le contenu des répertoires en utilisant des chemins absolus
- Affiche les fichiers et répertoires avec des indicateurs clairs (`[FILE]` ou `[DIR]`)
- Fournit une traversée sécurisée des répertoires avec une gestion appropriée des erreurs
- Valide les chemins et s'assure qu'ils sont absolus
Les deux outils intègrent des mesures de sécurité robustes:
- Validation des chemins absolus pour prévenir les attaques par traversée de répertoire
- Vérifications des permissions pour assurer des droits d'accès appropriés
- Intégration avec Secretlint pour la détection d'informations sensibles
- Messages d'erreur clairs pour un meilleur débogage et une meilleure sensibilisation à la sécurité
**Exemple:**
```typescript
// Lecture d'un fichier
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// Liste du contenu d'un répertoire
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
Ces outils sont particulièrement utiles lorsque les assistants IA doivent:
- Analyser des fichiers spécifiques dans la base de code
- Naviguer dans les structures de répertoires
- Vérifier l'existence et l'accessibilité des fichiers
- Assurer des opérations sécurisées sur le système de fichiers
## Configuration des serveurs MCP
Pour utiliser Repomix comme serveur MCP avec des assistants IA comme Claude, vous devez configurer les paramètres MCP:
### Pour Cline (extension VS Code)
Modifiez le fichier `cline_mcp_settings.json`:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### Pour Claude Desktop
Modifiez le fichier `claude_desktop_config.json` avec une configuration similaire à celle de Cline.
## Avantages de l'utilisation de Repomix comme serveur MCP
L'utilisation de Repomix comme serveur MCP offre plusieurs avantages:
1. **Intégration directe**: Les assistants IA peuvent analyser directement votre base de code sans préparation manuelle des fichiers.
2. **Flux de travail efficace**: Simplifie le processus d'analyse du code en éliminant le besoin de générer et de télécharger manuellement des fichiers.
3. **Sortie cohérente**: Garantit que l'assistant IA reçoit la base de code dans un format cohérent et optimisé.
4. **Fonctionnalités avancées**: Exploite toutes les fonctionnalités de Repomix comme la compression de code, le comptage de tokens et les vérifications de sécurité.
Une fois configuré, votre assistant IA peut utiliser directement les capacités de Repomix pour analyser les bases de code, rendant les flux de travail d'analyse de code plus efficaces.
# Formats de sortie
Repomix prend en charge trois formats de sortie:
- XML (par défaut)
- Markdown
- Texte brut
## Format XML
```bash
repomix --style xml
```
Le format XML est optimisé pour le traitement par l'IA:
```xml
Ce fichier est une représentation fusionnée de toute la base de code...
(Métadonnées et instructions pour l'IA)
src/
index.ts
utils/
helper.ts
// Contenu du fichier ici
```
::: tip Pourquoi XML?
Les balises XML aident les modèles d'IA comme Claude à analyser le contenu plus précisément. La [Documentation de Claude](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags) recommande d'utiliser des balises XML pour les prompts structurés.
:::
## Format Markdown
```bash
repomix --style markdown
```
Le Markdown offre un formatage lisible:
```markdown
Ce fichier est une représentation fusionnée de toute la base de code...
# Résumé du fichier
(Métadonnées et instructions pour l'IA)
# Structure des répertoires
```
src/
index.ts
utils/
helper.ts
```
# Fichiers
## Fichier: src/index.ts
```typescript
// Contenu du fichier ici
```
```
## Utilisation avec les modèles d'IA
Chaque format fonctionne bien avec les modèles d'IA, mais considérez:
- Utilisez XML pour Claude (meilleure précision d'analyse)
- Utilisez Markdown pour une meilleure lisibilité générale
- Utilisez le texte brut pour la simplicité et une compatibilité universelle
## Personnalisation
Définissez le format par défaut dans `repomix.config.json`:
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
```
## Format texte brut
```bash
repomix --style plain
```
Structure de sortie:
```text
Ce fichier est une représentation fusionnée de toute la base de code...
================
Résumé du fichier
================
(Métadonnées et instructions pour l'IA)
================
Structure des répertoires
================
src/
index.ts
utils/
helper.ts
================
Fichiers
================
================
Fichier: src/index.ts
================
// Contenu du fichier ici
```
# Exemples de prompts
## Revue de code
### Revue d'architecture
```
Analysez l'architecture de cette base de code:
1. Évaluez la structure globale et les motifs de conception
2. Identifiez les problèmes architecturaux potentiels
3. Suggérez des améliorations pour la scalabilité
4. Notez les zones qui suivent les meilleures pratiques
Concentrez-vous sur la maintenabilité et la modularité.
```
### Revue de sécurité
```
Effectuez une revue de sécurité de cette base de code:
1. Identifiez les vulnérabilités potentielles
2. Vérifiez les anti-patterns courants de sécurité
3. Examinez la gestion des erreurs et la validation des entrées
4. Évaluez la sécurité des dépendances
Fournissez des exemples spécifiques et des étapes de correction.
```
### Revue de performance
```
Examinez la base de code pour les performances:
1. Identifiez les goulots d'étranglement
2. Vérifiez l'utilisation des ressources
3. Examinez l'efficacité algorithmique
4. Évaluez les stratégies de mise en cache
Incluez des recommandations d'optimisation spécifiques.
```
## Génération de documentation
### Documentation d'API
```
Générez une documentation complète de l'API:
1. Listez et décrivez tous les points d'accès publics
2. Documentez les formats de requête/réponse
3. Incluez des exemples d'utilisation
4. Notez les limitations ou contraintes
```
### Guide du développeur
```
Créez un guide du développeur couvrant:
1. Instructions de configuration
2. Aperçu de la structure du projet
3. Flux de travail de développement
4. Approche de test
5. Étapes courantes de dépannage
```
### Documentation d'architecture
```
Documentez l'architecture du système:
1. Vue d'ensemble de haut niveau
2. Interactions entre composants
3. Diagrammes de flux de données
4. Décisions de conception et justification
5. Contraintes et limitations du système
```
## Analyse et amélioration
### Analyse des dépendances
```
Analysez les dépendances du projet:
1. Identifiez les packages obsolètes
2. Vérifiez les vulnérabilités de sécurité
3. Suggérez des packages alternatifs
4. Examinez les modèles d'utilisation des dépendances
Incluez des recommandations spécifiques de mise à niveau.
```
### Couverture de tests
```
Examinez la couverture des tests:
1. Identifiez les composants non testés
2. Suggérez des cas de test supplémentaires
3. Examinez la qualité des tests
4. Recommandez des stratégies de test
```
### Qualité du code
```
Évaluez la qualité du code et suggérez des améliorations:
1. Examinez les conventions de nommage
2. Vérifiez l'organisation du code
3. Évaluez la gestion des erreurs
4. Examinez les pratiques de commentaires
Fournissez des exemples spécifiques de modèles bons et problématiques.
```
## Conseils pour de meilleurs résultats
1. **Soyez spécifique**: Incluez des objectifs clairs et des critères d'évaluation
2. **Établissez le contexte**: Spécifiez votre rôle et le niveau d'expertise requis
3. **Format de demande**: Définissez comment vous souhaitez structurer la réponse
4. **Priorisez**: Indiquez quels aspects sont les plus importants
## Notes spécifiques aux modèles
### Claude
- Utilisez le format de sortie XML
- Placez les instructions importantes à la fin
- Spécifiez la structure de réponse
### ChatGPT
- Utilisez le format Markdown
- Divisez les grandes bases de code en sections
- Incluez des prompts de rôle système
### Gemini
- Fonctionne avec tous les formats
- Concentrez-vous sur des domaines spécifiques par demande
- Utilisez une analyse étape par étape
# Traitement des dépôts distants
## Utilisation de base
Traiter des dépôts publics:
```bash
# En utilisant l'URL complète
repomix --remote https://github.com/user/repo
# En utilisant le format abrégé GitHub
repomix --remote user/repo
```
## Sélection de branche et de commit
```bash
# Branche spécifique
repomix --remote user/repo --remote-branch main
# Tag
repomix --remote user/repo --remote-branch v1.0.0
# Hash de commit
repomix --remote user/repo --remote-branch 935b695
```
## Prérequis
- Git doit être installé
- Connexion Internet
- Accès en lecture au dépôt
## Contrôle de la sortie
```bash
# Emplacement de sortie personnalisé
repomix --remote user/repo -o custom-output.xml
# Avec format XML
repomix --remote user/repo --style xml
# Supprimer les commentaires
repomix --remote user/repo --remove-comments
```
## Utilisation avec Docker
```bash
# Traiter et sortir dans le répertoire courant
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
# Sortie vers un répertoire spécifique
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix \
--remote user/repo
```
## Problèmes courants
### Problèmes d'accès
- Assurez-vous que le dépôt est public
- Vérifiez l'installation de Git
- Vérifiez la connexion Internet
### Dépôts volumineux
- Utilisez `--include` pour sélectionner des chemins spécifiques
- Activez `--remove-comments`
- Traitez les branches séparément
# Sécurité
## Fonctionnalité de vérification de sécurité
Repomix utilise [Secretlint](https://github.com/secretlint/secretlint) pour détecter les informations sensibles dans vos fichiers:
- Clés d'API
- Jetons d'accès
- Identifiants
- Clés privées
- Variables d'environnement
## Configuration
Les vérifications de sécurité sont activées par défaut.
Désactivation via CLI:
```bash
repomix --no-security-check
```
Ou dans `repomix.config.json`:
```json
{
"security": {
"enableSecurityCheck": false
}
}
```
## Mesures de sécurité
1. **Exclusion des fichiers binaires**: Les fichiers binaires ne sont pas inclus dans la sortie
2. **Compatible avec Git**: Respecte les motifs `.gitignore`
3. **Détection automatisée**: Analyse les problèmes de sécurité courants:
- Identifiants AWS
- Chaînes de connexion aux bases de données
- Jetons d'authentification
- Clés privées
## Lorsque la vérification de sécurité trouve des problèmes
Exemple de sortie:
```bash
🔍 Vérification de sécurité:
────────────────────────────
2 fichier(s) suspect(s) détecté(s) et exclu(s):
1. config/credentials.json
- Clé d'accès AWS trouvée
2. .env.local
- Mot de passe de base de données trouvé
```
## Meilleures pratiques
1. Toujours examiner la sortie avant de la partager
2. Utiliser `.repomixignore` pour les chemins sensibles
3. Garder les vérifications de sécurité activées
4. Supprimer les fichiers sensibles du dépôt
## Signalement des problèmes de sécurité
Vous avez trouvé une vulnérabilité de sécurité? Veuillez:
1. Ne pas ouvrir un ticket public
2. Envoyer un email à: koukun0120@gmail.com
3. Ou utiliser les [Avis de sécurité GitHub](https://github.com/yamadashy/repomix/security/advisories/new)
---
layout: home
title: Repomix
titleTemplate: Empaquetez votre code dans des formats adaptés à l'IA
aside: false
editLink: false
features:
- icon: 🤖
title: Optimisé pour l'IA
details: Formate votre base de code d'une manière facilement compréhensible et traitable par l'IA.
- icon: ⚙️
title: Compatible avec Git
details: Respecte automatiquement vos fichiers .gitignore.
- icon: 🛡️
title: Axé sur la sécurité
details: Intègre Secretlint pour des vérifications de sécurité robustes afin de détecter et prévenir l'inclusion d'informations sensibles.
- icon: 📊
title: Comptage de tokens
details: Fournit le nombre de tokens pour chaque fichier et l'ensemble du dépôt, utile pour les limites de contexte des LLM.
---
## Démarrage rapide
Une fois que vous avez généré un fichier compressé (`repomix-output.txt`) avec Repomix, vous pouvez l'envoyer à un assistant IA avec une instruction comme :
```
Ce fichier contient tous les fichiers du dépôt combinés en un seul.
Je souhaite refactoriser le code, veuillez donc d'abord l'examiner.
```
L'IA analysera votre base de code complète et fournira des informations détaillées :
Lors de la discussion de modifications spécifiques, l'IA peut vous aider à générer du code. Avec des fonctionnalités comme les Artefacts de Claude, vous pouvez même recevoir plusieurs fichiers interdépendants :
Bon codage ! 🚀
## Guide de l'utilisateur avancé
Pour les utilisateurs avancés qui ont besoin de plus de contrôle, Repomix offre de nombreuses options de personnalisation via son interface en ligne de commande.
### Démarrage rapide
Vous pouvez essayer Repomix instantanément dans votre répertoire de projet sans installation :
```bash
npx repomix
```
Ou l'installer globalement pour une utilisation répétée :
```bash
# Installation avec npm
npm install -g repomix
# Alternativement avec yarn
yarn global add repomix
# Alternativement avec Homebrew (macOS/Linux)
brew install repomix
# Puis exécuter dans n'importe quel répertoire de projet
repomix
```
C'est tout ! Repomix générera un fichier `repomix-output.txt` dans votre répertoire actuel, contenant l'intégralité de votre dépôt dans un format adapté à l'IA.
### Utilisation
Pour empaqueter tout votre dépôt :
```bash
repomix
```
Pour empaqueter un répertoire spécifique :
```bash
repomix path/to/directory
```
Pour empaqueter des fichiers ou répertoires spécifiques en utilisant des [motifs glob](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax) :
```bash
repomix --include "src/**/*.ts,**/*.md"
```
Pour exclure des fichiers ou répertoires spécifiques :
```bash
repomix --ignore "**/*.log,tmp/"
```
Pour empaqueter un dépôt distant :
```bash
# Utilisation du format abrégé
npx repomix --remote yamadashy/repomix
# Utilisation de l'URL complète (prend en charge les branches et les chemins spécifiques)
npx repomix --remote https://github.com/yamadashy/repomix
npx repomix --remote https://github.com/yamadashy/repomix/tree/main
# Utilisation de l'URL d'un commit
npx repomix --remote https://github.com/yamadashy/repomix/commit/836abcd7335137228ad77feb28655d85712680f1
```
Pour initialiser un nouveau fichier de configuration (`repomix.config.json`) :
```bash
repomix --init
```
Une fois que vous avez généré le fichier compressé, vous pouvez l'utiliser avec des outils d'IA générative comme Claude, ChatGPT et Gemini.
#### Utilisation avec Docker
Vous pouvez également exécuter Repomix avec Docker 🐳
C'est utile si vous souhaitez exécuter Repomix dans un environnement isolé ou préférez utiliser des conteneurs.
Utilisation de base (répertoire courant) :
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
Pour empaqueter un répertoire spécifique :
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
```
Traiter un dépôt distant et sortir vers un répertoire `output` :
```bash
docker run -v ./output:/app -it --rm ghcr.io/yamadashy/repomix --remote https://github.com/yamadashy/repomix
```
### Formats de sortie
Choisissez votre format de sortie préféré :
```bash
# Format XML (par défaut)
repomix --style xml
# Format Markdown
repomix --style markdown
# Format texte brut
repomix --style plain
```
### Personnalisation
Créez un `repomix.config.json` pour des paramètres persistants :
```json
{
"output": {
"style": "markdown",
"filePath": "custom-output.md",
"removeComments": true,
"showLineNumbers": true,
"topFilesLength": 10
},
"ignore": {
"customPatterns": ["*.test.ts", "docs/**"]
}
}
```
### Plus d'exemples
::: tip
💡 Consultez notre [dépôt GitHub](https://github.com/yamadashy/repomix) pour une documentation complète et plus d'exemples !
:::
# コード圧縮
コード圧縮は、実装の詳細を省きながら、コードの本質的な構造を抽出する強力な機能です。トークン数を削減しながらコードベースの重要な構造情報を維持したい場合に特に有用です。
> [!NOTE]
> これは実験的な機能であり、ユーザーのフィードバックや実際の使用状況に基づいて積極的に改善を行っています。
## 基本的な使い方
`--compress`フラグを使用してコード圧縮を有効にします：
```bash
repomix --compress
```
リモートリポジトリでも使用できます：
```bash
repomix --remote user/repo --compress
```
## 仕組み
圧縮アルゴリズムは、tree-sitterパーシングを使用してコードを処理し、本質的な構造要素を抽出・保持しながら、実装の詳細を除外します。
圧縮で保持される要素：
- 関数やメソッドのシグネチャ
- インターフェースと型定義
- クラス構造とプロパティ
- 重要な構造的要素
以下の要素は除外されます：
- 関数やメソッドの実装内容
- ループや条件分岐のロジック詳細
- 内部変数の宣言
- 実装固有のコード
### 例
元のTypeScriptコード：
```typescript
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;
}
```
圧縮後：
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## 設定
設定ファイルで圧縮を有効にすることもできます：
```json
{
"output": {
"compress": true
}
}
```
## ユースケース
コード圧縮は以下のような場合に特に有用です：
- コードの構造やアーキテクチャの分析
- LLM処理のためのトークン数削減
- 高レベルなドキュメントの作成
- コードパターンやシグネチャの理解
- APIやインターフェース設計の共有
## 関連オプション
圧縮は以下のオプションと組み合わせることができます：
- `--remove-comments`: コードコメントを削除
- `--remove-empty-lines`: 空行を削除
- `--output-show-line-numbers`: 出力に行番号を追加
# Repomixとは
Repomixは、リポジトリ全体をAIフレンドリーな単一ファイルにパッケージングするツールです。ChatGPT、DeepSeek、Perplexity、Gemini、Gemma、Llama、Grokなどの大規模言語モデル（LLM）にコードベースを提供するために設計されています。
## クイックスタート
プロジェクトディレクトリで以下のコマンドを実行するだけです。
```bash
npx repomix
```
これだけで、`repomix-output.txt`ファイルにAIが理解しやすい形式でリポジトリ全体がまとめられます。
このファイルを以下のようなプロンプトとともにAIアシスタントに送信できます。
```
このファイルはリポジトリ内のすべてのファイルを1つにまとめたものです。
コードのリファクタリングを行いたいので、まずはコードレビューをお願いします。
```
すると、AIはコードベース全体を分析し、包括的な洞察を提供してくれます。
具体的な変更点を議論する際には、AIはコードの生成をサポートしてくれます。例えば、Claudeのアーティファクト機能などを使用すると、相互に依存する複数のファイルを一度に生成することも可能です。
良いコーディング体験を！🚀
## 主な機能
- **AI最適化**: コードベースをAIが理解しやすい形式にフォーマット化
- **トークンカウント**: LLMのコンテキスト制限に対応するためのトークン数を計測
- **Git対応**: `.gitignore`および`.git/info/exclude`ファイルを自動的に認識してパッケージング対象から除外
- **セキュリティ重視**: [Secretlint](https://github.com/secretlint/secretlint)を使用した機密情報の検出と保護
- **複数の出力形式**: プレーンテキスト、XML、Markdownの出力形式を選択可能
## 次のステップ
- [インストールガイド](installation.md): Repomixをインストールするにはこちら
- [使用方法](usage.md): 基本的な使い方から高度な使い方まで
- [設定](configuration.md): Repomixをカスタマイズするにはこちら
- [セキュリティ機能](security.md): セキュリティチェックの詳細はこちら
## コミュニティ
[Discordコミュニティ](https://discord.gg/wNYzTwZFku)に参加して、Repomixの使い方について質問したり、経験やノウハウを共有したり、新機能を提案したり、他のユーザーと交流しましょう。
## サポート
バグを見つけた場合や支援が必要な場合は、[GitHubでイシューを作成](https://github.com/yamadashy/repomix/issues)するか、Discordサーバーに参加してください。
# 出力フォーマット
Repomixは3つの出力フォーマットをサポートしています。
- XML（デフォルト）
- Markdown
- プレーンテキスト
## XMLフォーマット
```bash
repomix --style xml
```
XMLフォーマットはAI処理に最適化されています。
```xml
このファイルは、コードベース全体を1つのドキュメントにまとめた表現です...
（メタデータとAI向けの使用説明）
src/
index.ts
utils/
helper.ts
// ファイルの内容がここに表示されます
（output.instructionFilePathで指定されたカスタム指示）
```
::: tip なぜXML？
XMLタグはClaudeなどのAIモデルがコンテンツをより正確に解析するのに役立ちます。[Claude公式ドキュメント](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags)では、構造化されたプロンプトにXMLタグを使用することを推奨しています。
:::
## Markdownフォーマット
```bash
repomix --style markdown
```
Markdownは読みやすいフォーマットを提供します。
```markdown
このファイルは、コードベース全体を1つのドキュメントにまとめた表現です...
# ファイルサマリー
（メタデータとAI向けの使用説明）
# ディレクトリ構造
```
src/
index.ts
utils/
helper.ts
```
# ファイル
## File: src/index.ts
```typescript
// ファイルの内容がここに表示されます
```
```
## AIモデルとの使用
各フォーマットはAIモデルで問題なく動作しますが、以下の点を考慮してください。
- XMLはClaude用に最適化（最も正確な解析）
- Markdownは一般的な読みやすさを重視
- プレーンテキストはシンプルさと互換性を重視
## カスタマイズ
`repomix.config.json`でデフォルトのフォーマットを設定
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
```
## プレーンテキストフォーマット
```bash
repomix --style plain
```
出力の構造
```text
このファイルは、コードベース全体を1つのドキュメントにまとめた表現です...
================
ファイルサマリー
================
（メタデータとAI向けの使用説明）
================
ディレクトリ構造
================
src/
index.ts
utils/
helper.ts
================
ファイル
================
================
File: src/index.js
================
// ファイルの内容がここに表示されます
================
File: src/utils.js
================
// ファイルの内容がここに表示されます
```
# 基本的な使い方
## クイックスタート
リポジトリ全体をパッケージ化：
```bash
repomix
```
## 一般的な使用例
### 特定のディレクトリをパッケージ化
```bash
repomix path/to/directory
```
### 特定のファイルを含める
[glob パターン](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax)を使用：
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### ファイルを除外
```bash
repomix --ignore "**/*.log,tmp/"
```
### リモートリポジトリ
```bash
# GitHub URLを使用
repomix --remote https://github.com/user/repo
# ショートハンドを使用
repomix --remote user/repo
# 特定のブランチ/タグ/コミット
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
### コード圧縮
```bash
repomix --compress
# リモートリポジトリでも使用可能：
repomix --remote user/repo --compress
```
## 出力形式
### XML（デフォルト）
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### プレーンテキスト
```bash
repomix --style plain
```
## その他のオプション
### コメントを削除
```bash
repomix --remove-comments
```
### 行番号を表示
```bash
repomix --output-show-line-numbers
```
### クリップボードにコピー
```bash
repomix --copy
```
### セキュリティチェックを無効化
```bash
repomix --no-security-check
```
## 設定
設定ファイルを初期化：
```bash
repomix --init
```
詳細なオプションについては[設定ガイド](/ja/guide/configuration)を参照してください。
# 코드 압축
코드 압축은 구현 세부 사항을 제거하면서 필수적인 코드 구조를 지능적으로 추출하는 강력한 기능입니다. 이는 코드베이스의 중요한 구조적 정보를 유지하면서 토큰 수를 줄일 때 특히 유용합니다.
> [!NOTE]
> 이것은 실험적인 기능으로, 사용자 피드백과 실제 사용 사례를 바탕으로 지속적으로 개선될 예정입니다.
## 기본 사용법
`--compress` 플래그를 사용하여 코드 압축을 활성화합니다:
```bash
repomix --compress
```
원격 저장소에서도 사용할 수 있습니다:
```bash
repomix --remote user/repo --compress
```
## 작동 방식
압축 알고리즘은 Tree-sitter 파싱을 사용하여 코드를 처리하고, 구현 세부 사항을 제거하면서 필수적인 구조적 요소를 추출하고 보존합니다.
압축 시 유지되는 요소:
- 함수와 메서드 시그니처
- 인터페이스와 타입 정의
- 클래스 구조와 속성
- 중요한 구조적 요소
제거되는 요소:
- 함수와 메서드 구현
- 반복문과 조건문 로직 세부 사항
- 내부 변수 선언
- 구현 관련 코드
### 예시
원본 TypeScript 코드:
```typescript
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;
}
```
압축 후:
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## 설정
설정 파일에서 압축을 활성화할 수 있습니다:
```json
{
"output": {
"compress": true
}
}
```
## 사용 사례
코드 압축은 다음과 같은 경우에 특히 유용합니다:
- 코드 구조와 아키텍처 분석
- LLM 처리를 위한 토큰 수 감소
- 고수준 문서 작성
- 코드 패턴과 시그니처 이해
- API와 인터페이스 설계 공유
## 관련 옵션
압축은 다음 옵션들과 함께 사용할 수 있습니다:
- `--remove-comments`: 코드 주석 제거
- `--remove-empty-lines`: 빈 줄 제거
- `--output-show-line-numbers`: 출력에 줄 번호 추가
# Repomix 시작하기
Repomix는 전체 저장소를 AI 친화적인 단일 파일로 패키징하는 도구입니다. ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok 등의 대규모 언어 모델(LLM)에 코드베이스를 제공하는 데 도움이 되도록 설계되었습니다.
## 빠른 시작
프로젝트 디렉토리에서 다음 명령을 실행하세요.
```bash
npx repomix
```
이게 전부입니다! AI 친화적인 형식으로 전체 저장소를 포함하는 `repomix-output.txt` 파일이 생성됩니다.
그런 다음 이 파일을 다음과 같은 프롬프트와 함께 AI 어시스턴트에 보낼 수 있습니다.
```
이 파일에는 저장소의 모든 파일이 하나로 결합되어 있습니다.
코드를 리팩터링하고 싶으니 먼저 검토해 주세요.
```
AI는 전체 코드베이스를 분석하고 포괄적인 인사이트를 제공합니다.
특정 변경 사항을 논의할 때 AI가 코드 생성을 도울 수 있습니다. Claude의 Artifacts와 같은 기능을 사용하면 상호 의존적인 여러 파일을 받을 수도 있습니다.
즐거운 코딩 되세요! 🚀
## 핵심 기능
- **AI 최적화 출력**: AI 처리에 용이한 형식으로 코드베이스를 구성합니다.
- **토큰 계산**: LLM 컨텍스트 제한을 위한 토큰 사용량을 추적합니다.
- **Git 인식**: `.gitignore` 파일과 `.git/info/exclude` 파일을 존중합니다.
- **보안 중심**: 민감한 정보를 탐지합니다.
- **다양한 출력 형식**: 일반 텍스트, XML, Markdown 중에서 선택할 수 있습니다.
## 다음 단계
- [설치 가이드](installation.md): Repomix를 설치하는 다양한 방법
- [사용 가이드](usage.md): 기본 및 고급 기능에 대해 알아보기
- [구성](configuration.md): 필요에 맞게 Repomix를 사용자 정의하기
- [보안 기능](security.md): 보안 검사에 대해 알아보기
## 커뮤니티
[Discord 커뮤니티](https://discord.gg/wNYzTwZFku)에 참여하세요:
- Repomix에 대한 도움 받기
- 경험 공유
- 새로운 기능 제안
- 다른 사용자와 소통
## 지원
버그를 발견했거나 도움이 필요하신가요?
- [GitHub에 이슈 열기](https://github.com/yamadashy/repomix/issues)
- Discord 서버에 참여하기
- [문서 확인하기](https://repomix.com)
# 출력 형식
Repomix는 세 가지 출력 형식을 지원합니다:
- XML (기본값)
- Markdown
- 일반 텍스트
## XML 형식
```bash
repomix --style xml
```
XML 형식은 AI 처리에 최적화되어 있습니다:
```xml
이 파일은 전체 코드베이스를 하나의 문서로 통합한 것입니다...
(메타데이터 및 AI 지시사항)
src/
index.ts
utils/
helper.ts
// 파일 내용
```
::: tip XML을 사용하는 이유
XML 태그는 Claude와 같은 AI 모델이 내용을 더 정확하게 파싱하는 데 도움이 됩니다. [Claude 공식 문서](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags)에서는 구조화된 프롬프트에 XML 태그 사용을 권장하고 있습니다.
:::
## Markdown 형식
```bash
repomix --style markdown
```
Markdown은 읽기 쉬운 형식을 제공합니다:
```markdown
이 파일은 전체 코드베이스를 하나의 문서로 통합한 것입니다...
# 파일 요약
(메타데이터 및 AI 지시사항)
# 디렉토리 구조
```
src/
index.ts
utils/
helper.ts
```
# 파일
## File: src/index.ts
```typescript
// 파일 내용
```
```
## AI 모델과의 사용
각 형식은 AI 모델에서 잘 작동하지만, 다음 사항을 고려하세요:
- Claude에는 XML 사용 (가장 정확한 파싱)
- 일반적인 가독성을 위해서는 Markdown
- 단순성과 호환성을 위해서는 일반 텍스트
## 사용자 정의
`repomix.config.json`에서 기본 형식 설정:
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
```
## 일반 텍스트 형식
```bash
repomix --style plain
```
출력 구조:
```text
이 파일은 전체 코드베이스를 하나의 문서로 통합한 것입니다...
================
파일 요약
================
(메타데이터 및 AI 지시사항)
================
디렉토리 구조
================
src/
index.ts
utils/
helper.ts
================
파일
================
================
File: src/index.ts
================
// 파일 내용
```
# 기본 사용법
## 빠른 시작
저장소 전체를 패키징:
```bash
repomix
```
## 일반적인 사용 사례
### 특정 디렉토리 패키징
```bash
repomix path/to/directory
```
### 특정 파일 포함
[glob 패턴](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax) 사용:
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### 파일 제외
```bash
repomix --ignore "**/*.log,tmp/"
```
### 원격 저장소 처리
```bash
# GitHub URL 사용
repomix --remote https://github.com/user/repo
# 단축형 사용
repomix --remote user/repo
# 특정 브랜치/태그/커밋
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
## 출력 형식
### XML (기본값)
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### 일반 텍스트
```bash
repomix --style plain
```
## 추가 옵션
### 주석 제거
```bash
repomix --remove-comments
```
### 행 번호 표시
```bash
repomix --output-show-line-numbers
```
### 클립보드에 복사
```bash
repomix --copy
```
### 보안 검사 비활성화
```bash
repomix --no-security-check
```
## 설정
설정 파일 초기화:
```bash
repomix --init
```
더 자세한 설정 옵션은 [설정 가이드](/ko/guide/configuration)를 참조하세요.
# Compressão de Código
A compressão de código é um recurso poderoso que extrai estruturas essenciais do código de forma inteligente enquanto remove detalhes de implementação. Isso é particularmente útil para reduzir a contagem de tokens enquanto mantém informações estruturais importantes sobre sua base de código.
> [!NOTE]
> Este é um recurso experimental que estaremos melhorando ativamente com base no feedback dos usuários e no uso no mundo real.
## Uso Básico
Ative a compressão de código usando a flag `--compress`:
```bash
repomix --compress
```
Você também pode usá-la com repositórios remotos:
```bash
repomix --remote user/repo --compress
```
## Como Funciona
O algoritmo de compressão processa o código usando análise Tree-sitter para extrair e preservar elementos estruturais essenciais enquanto remove detalhes de implementação.
A compressão preserva:
- Assinaturas de funções e métodos
- Definições de interfaces e tipos
- Estruturas de classes e propriedades
- Elementos estruturais importantes
Enquanto remove:
- Implementações de funções e métodos
- Detalhes de lógica de loops e condicionais
- Declarações de variáveis internas
- Código específico de implementação
### Exemplo
Código TypeScript original:
```typescript
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;
}
```
Após a compressão:
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## Configuração
Você pode ativar a compressão em seu arquivo de configuração:
```json
{
"output": {
"compress": true
}
}
```
## Casos de Uso
A compressão de código é particularmente útil quando:
- Analisando estrutura e arquitetura do código
- Reduzindo contagem de tokens para processamento LLM
- Criando documentação de alto nível
- Compreendendo padrões e assinaturas de código
- Compartilhando designs de API e interface
## Opções Relacionadas
Você pode combinar a compressão com outras opções:
- `--remove-comments`: Remover comentários do código
- `--remove-empty-lines`: Remover linhas vazias
- `--output-show-line-numbers`: Adicionar números de linha à saída
# Introdução ao Repomix
O Repomix é uma ferramenta que compacta todo o seu repositório em um único arquivo amigável para IA. Ele foi projetado para ajudá-lo a alimentar seu código-fonte para Modelos de Linguagem Grandes (LLMs) como ChatGPT, DeepSeek, Perplexity, Gemini, Gemma, Llama, Grok e mais.
## Início Rápido
Execute este comando no diretório do seu projeto:
```bash
npx repomix
```
É isso! Você encontrará um arquivo `repomix-output.txt` contendo todo o seu repositório em um formato amigável para IA.
Você pode então enviar este arquivo para um assistente de IA com um prompt como:
```
Este arquivo contém todos os arquivos do repositório combinados em um só.
Eu quero refatorar o código, então, por favor, revise-o primeiro.
```
A IA analisará todo o seu código-fonte e fornecerá insights abrangentes:
Ao discutir mudanças específicas, a IA pode ajudar a gerar código. Com recursos como o Artifacts do Claude, você pode até receber vários arquivos interdependentes:
Feliz codificação! 🚀
## Principais Recursos
- **Saída Otimizada para IA**: Formata seu código-fonte para fácil processamento por IA
- **Contagem de Tokens**: Rastreia o uso de tokens para limites de contexto de LLM
- **Consciente do Git**: Respeita seus arquivos `.gitignore` e `.git/info/exclude`
- **Focado em Segurança**: Detecta informações sensíveis
- **Múltiplos Formatos de Saída**: Escolha entre texto simples, XML ou Markdown
## O que vem a seguir?
- [Guia de Instalação](installation.md): Diferentes maneiras de instalar o Repomix
- [Guia de Uso](usage.md): Aprenda sobre recursos básicos e avançados
- [Configuração](configuration.md): Personalize o Repomix para suas necessidades
- [Recursos de Segurança](security.md): Aprenda sobre verificações de segurança
## Comunidade
Junte-se à nossa [comunidade Discord](https://discord.gg/wNYzTwZFku) para:
- Obter ajuda com o Repomix
- Compartilhar suas experiências
- Sugerir novos recursos
- Conectar-se com outros usuários
## Suporte
Encontrou um bug ou precisa de ajuda?
- [Abra um problema no GitHub](https://github.com/yamadashy/repomix/issues)
- Junte-se ao nosso servidor Discord
- Verifique a [documentação](https://repomix.com)
# Formatos de Saída
O Repomix suporta três formatos de saída:
- XML (padrão)
- Markdown
- Texto simples
## Formato XML
```bash
repomix --style xml
```
O formato XML é otimizado para processamento por IA:
::: tip Por que XML?
As tags XML ajudam modelos de IA como o Claude a analisar o conteúdo com mais precisão. A [documentação do Claude](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags) recomenda o uso de tags XML para prompts estruturados.
:::
```xml
Este arquivo é uma representação consolidada de toda a base de código...
(Metadados e instruções para IA)
src/
index.ts
utils/
helper.ts
// Conteúdo do arquivo aqui
```
## Formato Markdown
```bash
repomix --style markdown
```
O Markdown oferece formatação legível:
```markdown
Este arquivo é uma representação consolidada de toda a base de código...
# Resumo do Arquivo
(Metadados e instruções para IA)
# Estrutura de Diretórios
```text
src/
index.ts
utils/
helper.ts
```
# Arquivos
## Arquivo: src/index.ts
```typescript
// Conteúdo do arquivo aqui
```
```
## Uso com Modelos de IA
Cada formato funciona bem com modelos de IA, mas considere:
- Use XML para Claude (melhor precisão de análise)
- Use Markdown para leitura geral
- Use Texto Simples para simplicidade e compatibilidade universal
## Customização
Defina o formato padrão no `repomix.config.json`:
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
```
## Formato de Texto Simples
```bash
repomix --style plain
```
Estrutura de saída:
```text
Este arquivo é uma representação consolidada de toda a base de código...
================
Resumo do Arquivo
================
(Metadados e instruções para IA)
================
Estrutura de Diretórios
================
src/
index.ts
utils/
helper.ts
================
Arquivos
================
================
Arquivo: src/index.ts
================
// Conteúdo do arquivo aqui
```
# Uso Básico
## Início Rápido
Compacte todo o seu repositório:
```bash
repomix
```
## Casos de Uso Comuns
### Compactar Diretórios Específicos
```bash
repomix path/to/directory
```
### Incluir Arquivos Específicos
Use [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### Excluir Arquivos
```bash
repomix --ignore "**/*.log,tmp/"
```
### Repositórios Remotos
```bash
# Usando URL do GitHub
repomix --remote https://github.com/user/repo
# Usando abreviação
repomix --remote user/repo
# Branch/tag/commit específico
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
## Formatos de Saída
### XML (Padrão)
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### Texto Simples
```bash
repomix --style plain
```
## Opções Adicionais
### Remover Comentários
```bash
repomix --remove-comments
```
### Mostrar Números de Linha
```bash
repomix --output-show-line-numbers
```
### Copiar para a Área de Transferência
```bash
repomix --copy
```
### Desativar Verificação de Segurança
```bash
repomix --no-security-check
```
## Configuração
Inicializar arquivo de configuração:
```bash
repomix --init
```
Veja o [Guia de Configuração](/pt-br/guide/configuration) para opções detalhadas.
# 代码压缩
代码压缩是一个强大的功能，它能够在移除实现细节的同时智能提取关键代码结构。在需要减少令牌数量的同时保持代码库的重要结构信息时，这个功能特别有用。
> [!NOTE]
> 这是一个实验性功能，我们将根据用户反馈和实际使用情况积极改进。
## 基本用法
使用 `--compress` 标志启用代码压缩：
```bash
repomix --compress
```
也可以在远程仓库中使用：
```bash
repomix --remote user/repo --compress
```
## 工作原理
压缩算法使用 Tree-sitter 解析处理代码，提取并保留基本结构元素，同时移除实现细节。
压缩会保留：
- 函数和方法签名
- 接口和类型定义
- 类结构和属性
- 重要的结构元素
同时会移除：
- 函数和方法实现
- 循环和条件逻辑细节
- 内部变量声明
- 具体实现代码
### 示例
原始 TypeScript 代码：
```typescript
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;
}
```
压缩后：
```typescript
import { ShoppingItem } from './shopping-item';
⋮----
/**
* Calculate the total price of shopping items
*/
const calculateTotal = (
items: ShoppingItem[]
) => {
⋮----
// Shopping item interface
interface Item {
name: string;
price: number;
quantity: number;
}
```
## 配置
你可以在配置文件中启用压缩：
```json
{
"output": {
"compress": true
}
}
```
## 使用场景
代码压缩在以下情况特别有用：
- 分析代码结构和架构
- 减少用于 LLM 处理的令牌数量
- 创建高层次文档
- 理解代码模式和签名
- 共享 API 和接口设计
## 相关选项
你可以将压缩与其他选项结合使用：
- `--remove-comments`: 移除代码注释
- `--remove-empty-lines`: 移除空行
- `--output-show-line-numbers`: 在输出中添加行号
# Repomix 入门指南
Repomix 是一个将代码库打包成单个 AI 友好文件的工具。它专为帮助你将代码提供给大型语言模型（如 ChatGPT、DeepSeek、Perplexity、Gemini、Gemma、Llama、Grok 等）而设计。
## 快速开始
在你的项目目录中运行以下命令：
```bash
npx repomix
```
就这么简单！你会在当前目录中找到一个 `repomix-output.txt` 文件，其中包含了以 AI 友好格式整理的整个代码库。
然后，你可以将此文件发送给 AI 助手，并附上类似这样的提示：
```
这个文件包含了仓库中所有文件的合并内容。
我想重构代码，请先帮我审查一下。
```
AI 将分析你的整个代码库并提供全面的见解：
在讨论具体修改时，AI 可以帮助生成代码。通过像 Claude 的 Artifacts 这样的功能，你甚至可以一次性接收多个相互依赖的文件：
祝你编码愉快！🚀
## 核心功能
- **AI 优化**：以 AI 易于理解的格式整理代码库
- **令牌计数**：为 LLM 上下文限制提供令牌使用统计
- **Git 感知**：自动识别并遵循 `.gitignore` 和 `.git/info/exclude` 文件
- **注重安全**：使用 Secretlint 进行敏感信息检测
- **多种输出格式**：可选纯文本、XML 或 Markdown 格式
## 下一步
- [安装指南](installation.md)：了解安装 Repomix 的不同方式
- [使用指南](usage.md)：学习基本和高级功能
- [配置](configuration.md)：根据需求自定义 Repomix
- [安全功能](security.md)：了解安全检查详情
## 社区
加入我们的 [Discord 社区](https://discord.gg/wNYzTwZFku)：
- 获取 Repomix 使用帮助
- 分享你的使用经验
- 提出新功能建议
- 与其他用户交流
## 支持
发现问题或需要帮助？
- [在 GitHub 上提交问题](https://github.com/yamadashy/repomix/issues)
- 加入 Discord 服务器
- 查看[文档](https://repomix.com)
# 输出格式
Repomix 支持三种输出格式：
- XML（默认）
- Markdown
- 纯文本
## XML 格式
```bash
repomix --style xml
```
XML 格式针对 AI 处理进行了优化：
```xml
本文件是整个代码库的合并表示形式...
（元数据和 AI 指令）
src/
index.ts
utils/
helper.ts
// 文件内容
```
::: tip 为什么选择 XML？
XML 标签有助于像 Claude 这样的 AI 模型更准确地解析内容。[Claude 官方文档](https://docs.anthropic.com/en/docs/build-with-claude/prompt-engineering/use-xml-tags)推荐使用 XML 标签来构建结构化提示。
:::
## Markdown 格式
```bash
repomix --style markdown
```
Markdown 提供了易读的格式：
```markdown
本文件是整个代码库的合并表示形式...
# 文件概要
（元数据和 AI 指令）
# 目录结构
```
src/
index.ts
utils/
helper.ts
```
# 文件
## File: src/index.ts
```typescript
// 文件内容
```
```
## 在 AI 模型中的使用
每种格式都能在 AI 模型中正常工作，但需要考虑以下几点：
- 对 Claude 使用 XML（解析最准确）
- 对一般可读性使用 Markdown
- 对简单性和通用兼容性使用纯文本
## 自定义设置
在 `repomix.config.json` 中设置默认格式：
```json
{
"output": {
"style": "xml",
"filePath": "output.xml"
}
}
```
## 纯文本格式
```bash
repomix --style plain
```
输出结构：
```text
本文件是整个代码库的合并表示形式...
================
文件概要
================
（元数据和 AI 指令）
================
目录结构
================
src/
index.ts
utils/
helper.ts
================
文件
================
================
File: src/index.ts
================
// 文件内容
```
# 基本用法
## 快速开始
打包整个仓库：
```bash
repomix
```
## 常见使用场景
### 打包指定目录
```bash
repomix path/to/directory
```
### 包含特定文件
使用 [glob 模式](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax)：
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### 排除文件
```bash
repomix --ignore "**/*.log,tmp/"
```
### 处理远程仓库
```bash
# 使用 GitHub URL
repomix --remote https://github.com/user/repo
# 使用简写形式
repomix --remote user/repo
# 指定分支/标签/提交
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
## 输出格式
### XML（默认）
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### 纯文本
```bash
repomix --style plain
```
## 其他选项
### 移除注释
```bash
repomix --remove-comments
```
### 显示行号
```bash
repomix --output-show-line-numbers
```
### 复制到剪贴板
```bash
repomix --copy
```
### 禁用安全检查
```bash
repomix --no-security-check
```
## 配置
初始化配置文件：
```bash
repomix --init
```
更多详细配置选项请参阅[配置指南](/zh-cn/guide/configuration)。
{
"private": true,
"type": "module",
"scripts": {
"docs:dev": "vitepress dev",
"docs:build": "vitepress build",
"docs:preview": "vitepress preview"
},
"dependencies": {
"jszip": "^3.10.1",
"lucide-vue-next": "^0.474.0",
"vite-plugin-pwa": "^0.21.1",
"vue3-ace-editor": "^2.2.4"
},
"devDependencies": {
"@types/gtag.js": "^0.0.20",
"rollup-plugin-visualizer": "^5.14.0",
"vitepress": "^1.6.3"
}
}
import { isValidRemoteValue } from 'repomix';
import { z } from 'zod';
// Regular expression to validate ignore patterns
// Allowed characters: alphanumeric, *, ?, /, -, _, ., !, (, ), space, comma
const ignorePatternRegex = /^[a-zA-Z0-9*?\/\-_.,!()\s]*$/;
export const packOptionsSchema = z
.object({
removeComments: z.boolean().optional(),
removeEmptyLines: z.boolean().optional(),
showLineNumbers: z.boolean().optional(),
fileSummary: z.boolean().optional(),
directoryStructure: z.boolean().optional(),
includePatterns: z
.string()
.max(1000, 'Include patterns too long')
.optional()
.transform((val) => val?.trim()),
ignorePatterns: z
.string()
.regex(ignorePatternRegex, 'Invalid characters in ignore patterns')
.max(1000, 'Ignore patterns too long')
.optional()
.transform((val) => val?.trim()),
outputParsable: z.boolean().optional(),
})
.strict();
const isValidZipFile = (file: File) => {
return file.type === 'application/zip' || file.name.endsWith('.zip');
};
const fileSchema = z
.custom()
.refine((file) => file instanceof File, {
message: 'Invalid file format',
})
.refine((file) => isValidZipFile(file), {
message: 'Only ZIP files are allowed',
})
.refine((file) => file.size <= 10 * 1024 * 1024, {
// 10MB limit
message: 'File size must be less than 10MB',
});
export const packRequestSchema = z
.object({
url: z
.string()
.min(1, 'Repository URL is required')
.max(200, 'Repository URL is too long')
.transform((val) => val.trim())
.refine((val) => isValidRemoteValue(val), { message: 'Invalid repository URL' })
.optional(),
file: fileSchema.optional(),
format: z.enum(['xml', 'markdown', 'plain']),
options: packOptionsSchema,
})
.strict()
.refine((data) => data.url || data.file, {
message: 'Either URL or file must be provided',
})
.refine((data) => !(data.url && data.file), {
message: 'Cannot provide both URL and file',
});
export type PackRequest = z.infer;
# Important
- Follow custom AI instructions written in `.github/copilot-instructions.md`.
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"compress": false,
"headerText": "This repository contains the source code for the Repomix tool.\nRepomix is designed to pack repository contents into a single file,\nmaking it easier for AI systems to analyze and process the codebase.\n\nKey Features:\n- Configurable ignore patterns\n- Custom header text support\n- Efficient file processing and packing\n\nPlease refer to the README.md file for more detailed information on usage and configuration.\n",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"includeEmptyDirectories": true,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": [],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
// ignore is specified in .repomixignore
"customPatterns": []
},
"security": {
"enableSecurityCheck": true
},
"tokenCount": {
"encoding": "o200k_base"
}
}
# Repomix Project Structure and Overview
This document provides a structural overview of the Repomix project, designed to aid AI code assistants (like Copilot) in understanding the codebase.
Please refer to `README.md` for a complete and up-to-date project overview, and `CONTRIBUTING.md` for implementation guidelines and contribution procedures.
## Project Overview
Repomix is a tool that packs the contents of a software repository into a single file, making it easier for AI systems to analyze and process the codebase. It supports various output formats (XML, Markdown, or plain text), ignores files based on configurable patterns, and performs security checks to exclude potentially sensitive information.
## Directory Structure
The project is organized into the following directories:
```
repomix/
├── src/ # Main source code
│ ├── cli/ # Command-line interface logic (argument parsing, command handling, output)
│ ├── config/ # Configuration loading, schema, and defaults
│ ├── core/ # Core logic of Repomix
│ │ ├── file/ # File handling (reading, processing, searching, tree structure generation, git commands)
│ │ ├── metrics/ # Calculating code metrics (character count, token count)
│ │ ├── output/ # Output generation (different styles, headers, etc.)
│ │ ├── packager/ # Orchestrates file collection, processing, output, and clipboard operations.
│ │ ├── security/ # Security checks to exclude sensitive files
│ │ ├── mcp/ # MCP server integration (packaging codebases for AI analysis)
│ │ ├── tokenCount/ # Token counting using Tiktoken
│ │ └── treeSitter/ # Code parsing using Tree-sitter and language-specific queries
│ └── shared/ # Shared utilities and types (error handling, logging, helper functions)
├── tests/ # Unit and integration tests (organized mirroring src/)
│ ├── cli/
│ ├── config/
│ ├── core/
│ ├── integration-tests/
│ ├── shared/
│ └── testing/
└── website/ # Documentation website (VitePress)
├── client/ # Client-side code (Vue.js components, styles, configuration)
│ ├── .vitepress/ # VitePress configuration and theme
│ │ ├── config/ # Site configuration files (navigation, sidebar, etc.)
│ │ └── theme/ # Custom theme and styles
│ ├── components/ # Vue.js components for the website
│ └── src/ # Markdown files for the documentation in various languages (en, ja, etc.)
└── server/ # Server-side API (for remote repository processing)
└── src/ # Server source code (API endpoints, request handling)
```
----------------------------------------------------------------
# Coding Guidelines
- Follow the Airbnb JavaScript Style Guide.
- Split files into smaller, focused units when appropriate:
- Aim to keep code files under 250 lines. If a file exceeds 250 lines, split it into multiple files based on functionality.
- Add comments to clarify non-obvious logic. **Ensure all comments are written in English.**
- Provide corresponding unit tests for all new features.
- After implementation, verify changes by running:
```bash
npm run lint # Ensure code style compliance
npm run test # Verify all tests pass
```
## Dependencies and Testing
- Inject dependencies through a deps object parameter for testability
- Example:
```typescript
export const functionName = async (
param1: Type1,
param2: Type2,
deps = {
defaultFunction1,
defaultFunction2,
}
) => {
// Use deps.defaultFunction1() instead of direct call
};
```
- Mock dependencies by passing test doubles through deps object
- Use vi.mock() only when dependency injection is not feasible
## Generate Comprehensive Output
- Include all content without abbreviation, unless specified otherwise
- Optimize for handling large codebases while maintaining output quality
----------------------------------------------------------------
# GitHub Release Note Guidelines
When writing release notes, please follow these guidelines:
- When referencing issues or PRs, use the gh command to verify the content:
```bash
gh issue view # For checking issue content
gh pr view # For checking PR content
```
This helps ensure accuracy in release note descriptions.
Here are some examples of release notes that follow the guidelines:
v0.2.25
````md
This release brings significant improvements to output formatting and introduces flexible remote repository handling capabilities along with enhanced logging features.
# Improvements ⚡
## Remote Repository Enhancement (#335)
- Added branch/tag parsing directly from repository URLs:
```bash
repomix --remote https://github.com/yamadashy/repomix/tree/0.1.x
```
Functions identically to:
```bash
repomix --remote https://github.com/yamadashy/repomix --remote-branch 0.1.x
```
Special thanks to @huy-trn for implementing this user-friendly feature!
## Enhanced Output Formatting (#328, #329, #330)
- Added "End of Codebase" marker for better clarity in output
- Improved output header accuracy:
- Better representation of codebase scope
- Clear indication when using `--include` or `--ignore` options
Special thanks to @gitkenan for adding the "End of Codebase" marker and reporting the header issue!
## Path Pattern Support (#337)
- Added support for special characters in paths:
- Handles parentheses in include patterns (e.g., `src/(categories)/**/*`)
- Improved escaping for `[]` and `{}`
- Essential for Next.js route groups and similar frameworks
Thank you @matheuscoelhomalta for improving path pattern support!
# How to Update
```bash
npm update -g repomix
```
---
As always, if you encounter any issues or have suggestions, please let us know through our GitHub issues or join our [Discord community](https://discord.gg/wNYzTwZFku) for support.
````
v0.2.24
````md
This release significantly enhances configuration flexibility with comprehensive CLI flag support and expands default ignore patterns for better project scaffolding.
# What's New 🚀
## CLI Flags Revolution (#324)
- New command-line configuration now available.
```
- `--no-gitignore`: Disable .gitignore file usage
- `--no-default-patterns`: Disable default patterns
- `--header-text `: Custom text to include in the file header
- `--instruction-file-path `: Path to a file containing detailed custom instructions
- `--include-empty-directories`: Include empty directories in the output
```
Special recognition to @massdo for driving ecosystem growth.
# Improvements ⚡
## Enhanced Ignore Patterns (#318, #322)
- Expanded default ignores for Rust projects:
- `target/`, `Cargo.lock`, build artifacts
- PHP, Ruby, Go, Elixir, Haskell: package manager lock files
To @boralg for helping curate Rust-specific patterns!
# How to Update
```bash
npm update -g repomix
```
---
As always, if you encounter any issues or have suggestions, please let us know through our GitHub issues or join our [Discord community](https://discord.gg/wNYzTwZFku) for support.
````
v0.2.23
````md
This release adds significant performance improvements for large repositories, making Repomix faster and more efficient when needed.
# Improvements ⚡
## Parallel Processing Enhancement (#309)
- Implemented worker threads using [Piscina](https://github.com/piscinajs/piscina) for parallel processing
### Benchmark Results
- `yamadashy.repomix`: No significant change
- Before: 868.73 millis
- After: 671.26 millis
- `facebook/react`: 29x faster
- Before: 123.31 secs
- After: 4.19 secs
- `vercel/next.js`: 58x faster
- Before: 17.85 mins
- After: 17.27 secs
Note: While Repomix is not primarily designed for processing large repositories, and speed is not a primary goal, faster processing can provide a better user experience when working with larger codebases.
# How to Update
```bash
npm update -g repomix
```
---
As always, if you encounter any issues or have suggestions, please let us know through our GitHub issues or join our [Discord community](https://discord.gg/wNYzTwZFku) for support.
````
v0.2.22
````md
This release introduces significant improvements to large file handling and expands the Repomix ecosystem with new tools and community channels.
# Improvements ⚡
## Improved Large File Handling (#302)
- Added a file size limit check (50MB) to prevent memory issues
- Graceful error handling for large files with clear user guidance:
Special thanks to @slavashvets for their continued contributions!
# Ecosystem Growth 🤝
## New VS Code Extension (#300)
A community-created VS Code extension "Repomix Runner" is now available:
- Run Repomix directly from VS Code
- Extension by @massdo: [View on VS Code Marketplace](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner)
Thank you @massdo for bringing Repomix to VS Code and expanding our tooling ecosystem!
## Official Social Media
- Launched official Repomix X (Twitter) account: [@repomix_ai](https://x.com/repomix_ai)
- Follow for updates, tips, and community highlights
# How to Update
```bash
npm update -g repomix
```
---
Join our growing community on [Discord](https://discord.gg/BF8GxZHE2C) and follow us on [X](https://x.com/repomix_ai) for updates!
````
v0.2.21
````md
This release introduces significant improvements to output formatting and documentation, featuring a new parsable style option for enhanced XML handling.
# What's New 🚀
## Enhanced Output Style Control (#287)
- Added new `parsableStyle` option for better output handling:
- Ensures output strictly follows the specification of the chosen format
- Provides properly escaped XML output with fast-xml-parser
- Dynamically adjusts markdown code block delimiters to avoid content conflicts
- Available via CLI flag `--parsable-style` or in configuration file
Special thanks to @atollk for their first contribution!
# Documentation 📚
## README Enhancements (#296)
- Updated Homebrew installation documentation to include Linux support
Special thanks to @chenrui333 for their continued contributions!
## Website Multi-Language Support (#293)
- Enhanced multi-language support in [repomix.com](https://repomix.com)
# How to Update
To update to the latest version, run:
```bash
npm update -g repomix
```
---
As always, if you encounter any issues or have suggestions, please let us know through our GitHub issues or join our [Discord community](https://discord.gg/wNYzTwZFku) for support.
import { runMcpServer } from '../../mcp/mcpServer.js';
import { logger } from '../../shared/logger.js';
export const runMcpAction = async (): Promise => {
logger.trace('Starting Repomix MCP server...');
await runMcpServer();
};
import * as fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import GitUrlParse, { type GitUrl } from 'git-url-parse';
import pc from 'picocolors';
import { execGitShallowClone, isGitInstalled } from '../../core/file/gitCommand.js';
import { RepomixError } from '../../shared/errorHandle.js';
import { logger } from '../../shared/logger.js';
import { Spinner } from '../cliSpinner.js';
import type { CliOptions } from '../types.js';
import { type DefaultActionRunnerResult, runDefaultAction } from './defaultAction.js';
interface IGitUrl extends GitUrl {
commit: string | undefined;
}
export const runRemoteAction = async (
repoUrl: string,
cliOptions: CliOptions,
deps = {
isGitInstalled,
execGitShallowClone,
runDefaultAction,
},
): Promise => {
if (!(await deps.isGitInstalled())) {
throw new RepomixError('Git is not installed or not in the system PATH.');
}
const parsedFields = parseRemoteValue(repoUrl);
const spinner = new Spinner('Cloning repository...', cliOptions);
const tempDirPath = await createTempDirectory();
let result: DefaultActionRunnerResult;
try {
spinner.start();
// Clone the repository
await cloneRepository(parsedFields.repoUrl, tempDirPath, cliOptions.remoteBranch || parsedFields.remoteBranch, {
execGitShallowClone: deps.execGitShallowClone,
});
spinner.succeed('Repository cloned successfully!');
logger.log('');
// Run the default action on the cloned repository
result = await deps.runDefaultAction([tempDirPath], tempDirPath, cliOptions);
await copyOutputToCurrentDirectory(tempDirPath, process.cwd(), result.config.output.filePath);
} catch (error) {
spinner.fail('Error during repository cloning. cleanup...');
throw error;
} finally {
// Cleanup the temporary directory
await cleanupTempDirectory(tempDirPath);
}
return result;
};
// Check the short form of the GitHub URL. e.g. yamadashy/repomix
const VALID_NAME_PATTERN = '[a-zA-Z0-9](?:[a-zA-Z0-9._-]*[a-zA-Z0-9])?';
const validShorthandRegex = new RegExp(`^${VALID_NAME_PATTERN}/${VALID_NAME_PATTERN}$`);
export const isValidShorthand = (remoteValue: string): boolean => {
return validShorthandRegex.test(remoteValue);
};
export const parseRemoteValue = (remoteValue: string): { repoUrl: string; remoteBranch: string | undefined } => {
if (isValidShorthand(remoteValue)) {
logger.trace(`Formatting GitHub shorthand: ${remoteValue}`);
return {
repoUrl: `https://github.com/${remoteValue}.git`,
remoteBranch: undefined,
};
}
try {
const parsedFields = GitUrlParse(remoteValue) as IGitUrl;
// This will make parsedFields.toString() automatically append '.git' to the returned url
parsedFields.git_suffix = true;
const ownerSlashRepo =
parsedFields.full_name.split('/').length > 1 ? parsedFields.full_name.split('/').slice(-2).join('/') : '';
if (ownerSlashRepo !== '' && !isValidShorthand(ownerSlashRepo)) {
throw new RepomixError('Invalid owner/repo in repo URL');
}
const repoUrl = parsedFields.toString(parsedFields.protocol);
if (parsedFields.ref) {
return {
repoUrl: repoUrl,
remoteBranch: parsedFields.filepath ? `${parsedFields.ref}/${parsedFields.filepath}` : parsedFields.ref,
};
}
if (parsedFields.commit) {
return {
repoUrl: repoUrl,
remoteBranch: parsedFields.commit,
};
}
return {
repoUrl: repoUrl,
remoteBranch: undefined,
};
} catch (error) {
throw new RepomixError('Invalid remote repository URL or repository shorthand (owner/repo)');
}
};
export const isValidRemoteValue = (remoteValue: string): boolean => {
try {
parseRemoteValue(remoteValue);
return true;
} catch (error) {
return false;
}
};
export const createTempDirectory = async (): Promise => {
const tempDir = await fs.mkdtemp(path.join(os.tmpdir(), 'repomix-'));
logger.trace(`Created temporary directory. (path: ${pc.dim(tempDir)})`);
return tempDir;
};
export const cloneRepository = async (
url: string,
directory: string,
remoteBranch?: string,
deps = {
execGitShallowClone,
},
): Promise => {
logger.log(`Clone repository: ${url} to temporary directory. ${pc.dim(`path: ${directory}`)}`);
logger.log('');
try {
await deps.execGitShallowClone(url, directory, remoteBranch);
} catch (error) {
throw new RepomixError(`Failed to clone repository: ${(error as Error).message}`);
}
};
export const cleanupTempDirectory = async (directory: string): Promise => {
logger.trace(`Cleaning up temporary directory: ${directory}`);
await fs.rm(directory, { recursive: true, force: true });
};
export const copyOutputToCurrentDirectory = async (
sourceDir: string,
targetDir: string,
outputFileName: string,
): Promise => {
const sourcePath = path.resolve(sourceDir, outputFileName);
const targetPath = path.resolve(targetDir, outputFileName);
try {
logger.trace(`Copying output file from: ${sourcePath} to: ${targetPath}`);
// Create target directory if it doesn't exist
await fs.mkdir(path.dirname(targetPath), { recursive: true });
await fs.copyFile(sourcePath, targetPath);
} catch (error) {
throw new RepomixError(`Failed to copy output file: ${(error as Error).message}`);
}
};
import type { TiktokenEncoding } from 'tiktoken';
import { z } from 'zod';
// Output style enum
export const repomixOutputStyleSchema = z.enum(['xml', 'markdown', 'plain']);
export type RepomixOutputStyle = z.infer;
// Default values map
export const defaultFilePathMap: Record = {
xml: 'repomix-output.xml',
markdown: 'repomix-output.md',
plain: 'repomix-output.txt',
} as const;
// Base config schema
export const repomixConfigBaseSchema = z.object({
output: z
.object({
filePath: z.string().optional(),
style: repomixOutputStyleSchema.optional(),
parsableStyle: z.boolean().optional(),
headerText: z.string().optional(),
instructionFilePath: z.string().optional(),
fileSummary: z.boolean().optional(),
directoryStructure: z.boolean().optional(),
removeComments: z.boolean().optional(),
removeEmptyLines: z.boolean().optional(),
compress: z.boolean().optional(),
topFilesLength: z.number().optional(),
showLineNumbers: z.boolean().optional(),
copyToClipboard: z.boolean().optional(),
includeEmptyDirectories: z.boolean().optional(),
git: z
.object({
sortByChanges: z.boolean().optional(),
sortByChangesMaxCommits: z.number().optional(),
})
.optional(),
})
.optional(),
include: z.array(z.string()).optional(),
ignore: z
.object({
useGitignore: z.boolean().optional(),
useDefaultPatterns: z.boolean().optional(),
customPatterns: z.array(z.string()).optional(),
})
.optional(),
security: z
.object({
enableSecurityCheck: z.boolean().optional(),
})
.optional(),
tokenCount: z
.object({
encoding: z.string().optional(),
})
.optional(),
});
// Default config schema with default values
export const repomixConfigDefaultSchema = z.object({
output: z
.object({
filePath: z.string().default(defaultFilePathMap.xml),
style: repomixOutputStyleSchema.default('xml'),
parsableStyle: z.boolean().default(false),
headerText: z.string().optional(),
instructionFilePath: z.string().optional(),
fileSummary: z.boolean().default(true),
directoryStructure: z.boolean().default(true),
removeComments: z.boolean().default(false),
removeEmptyLines: z.boolean().default(false),
compress: z.boolean().default(false),
topFilesLength: z.number().int().min(0).default(5),
showLineNumbers: z.boolean().default(false),
copyToClipboard: z.boolean().default(false),
includeEmptyDirectories: z.boolean().optional(),
git: z
.object({
sortByChanges: z.boolean().default(true),
sortByChangesMaxCommits: z.number().int().min(1).default(100),
})
.default({}),
})
.default({}),
include: z.array(z.string()).default([]),
ignore: z
.object({
useGitignore: z.boolean().default(true),
useDefaultPatterns: z.boolean().default(true),
customPatterns: z.array(z.string()).default([]),
})
.default({}),
security: z
.object({
enableSecurityCheck: z.boolean().default(true),
})
.default({}),
tokenCount: z
.object({
encoding: z
.string()
.default('o200k_base')
.transform((val) => val as TiktokenEncoding),
})
.default({}),
});
export const repomixConfigFileSchema = repomixConfigBaseSchema;
export const repomixConfigCliSchema = repomixConfigBaseSchema;
export const repomixConfigMergedSchema = repomixConfigDefaultSchema
.and(repomixConfigFileSchema)
.and(repomixConfigCliSchema)
.and(
z.object({
cwd: z.string(),
}),
);
export type RepomixConfigDefault = z.infer;
export type RepomixConfigFile = z.infer;
export type RepomixConfigCli = z.infer;
export type RepomixConfigMerged = z.infer;
export const defaultConfig = repomixConfigDefaultSchema.parse({});
export const defaultIgnoreList = [
// Version control
'.git/**',
'.hg/**',
'.hgignore',
'.svn/**',
// Dependency directories
'**/node_modules/**',
'**/bower_components/**',
'**/jspm_packages/**',
'vendor/**',
'**/.bundle/**',
'**/.gradle/**',
'target/**',
// Logs
'logs/**',
'**/*.log',
'**/npm-debug.log*',
'**/yarn-debug.log*',
'**/yarn-error.log*',
// Runtime data
'pids/**',
'*.pid',
'*.seed',
'*.pid.lock',
// Directory for instrumented libs generated by jscoverage/JSCover
'lib-cov/**',
// Coverage directory used by tools like istanbul
'coverage/**',
// nyc test coverage
'.nyc_output/**',
// Grunt intermediate storage
'.grunt/**',
// node-waf configuration
'.lock-wscript',
// Compiled binary addons
'build/Release/**',
// TypeScript v1 declaration files
'typings/**',
// Optional npm cache directory
'**/.npm/**',
// Cache directories
'.eslintcache',
'.rollup.cache/**',
'.webpack.cache/**',
'.parcel-cache/**',
'.sass-cache/**',
'*.cache',
// Optional REPL history
'.node_repl_history',
// Output of 'npm pack'
'*.tgz',
// Yarn files
'**/.yarn/**',
// Yarn Integrity file
'**/.yarn-integrity',
// dotenv environment variables file
'.env',
// next.js build output
'.next/**',
// nuxt.js build output
'.nuxt/**',
// vuepress build output
'.vuepress/dist/**',
// Serverless directories
'.serverless/**',
// FuseBox cache
'.fusebox/**',
// DynamoDB Local files
'.dynamodb/**',
// TypeScript output
'dist/**',
// OS generated files
'**/.DS_Store',
'**/Thumbs.db',
// Editor directories and files
'.idea/**',
'.vscode/**',
'**/*.swp',
'**/*.swo',
'**/*.swn',
'**/*.bak',
// Build outputs
'build/**',
'out/**',
// Temporary files
'tmp/**',
'temp/**',
// repomix output
'**/repomix-output.*',
'**/repopack-output.*', // Legacy
// Essential Node.js-related entries
'**/package-lock.json',
'**/yarn-error.log',
'**/yarn.lock',
'**/pnpm-lock.yaml',
'**/bun.lockb',
'**/bun.lock',
// Essential Python-related entries
'**/__pycache__/**',
'**/*.py[cod]',
'**/venv/**',
'**/.venv/**',
'**/.pytest_cache/**',
'**/.mypy_cache/**',
'**/.ipynb_checkpoints/**',
'**/Pipfile.lock',
'**/poetry.lock',
'**/uv.lock',
// Essential Rust-related entries
'**/Cargo.lock',
'**/Cargo.toml.orig',
'**/target/**',
'**/*.rs.bk',
// Essential PHP-related entries
'**/composer.lock',
// Essential Ruby-related entries
'**/Gemfile.lock',
// Essential Go-related entries
'**/go.sum',
// Essential Elixir-related entries
'**/mix.lock',
// Essential Haskell-related entries
'**/stack.yaml.lock',
'**/cabal.project.freeze',
];
import type { Query, SyntaxNode, Tree } from 'web-tree-sitter';
import type { RepomixConfigMerged } from '../../../config/configSchema.js';
import type { SupportedLang } from '../lang2Query.js';
import { CssParseStrategy } from './CssParseStrategy.js';
import { DefaultParseStrategy } from './DefaultParseStrategy.js';
import { GoParseStrategy } from './GoParseStrategy.js';
import { PythonParseStrategy } from './PythonParseStrategy.js';
import { TypeScriptParseStrategy } from './TypeScriptParseStrategy.js';
import { VueParseStrategy } from './VueParseStrategy.js';
export interface ParseContext {
fileContent: string;
lines: string[];
tree: Tree;
query: Query;
config: RepomixConfigMerged;
}
export interface ParseStrategy {
parseCapture(
capture: { node: SyntaxNode; name: string },
lines: string[],
processedChunks: Set,
context: ParseContext,
): string | null;
}
export function createParseStrategy(lang: SupportedLang): ParseStrategy {
switch (lang) {
case 'typescript':
return new TypeScriptParseStrategy();
case 'python':
return new PythonParseStrategy();
case 'go':
return new GoParseStrategy();
case 'css':
return new CssParseStrategy();
case 'vue':
return new VueParseStrategy();
default:
return new DefaultParseStrategy();
}
}
import path from 'node:path';
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import { runCli } from '../../cli/cliRun.js';
import type { CliOptions } from '../../cli/types.js';
import { createToolWorkspace, formatToolError, formatToolResponse } from './mcpToolRuntime.js';
export const registerPackCodebaseTool = (mcpServer: McpServer) => {
mcpServer.tool(
'pack_codebase',
'Package local code directory into a consolidated file for AI analysis',
{
directory: z.string().describe('Directory to pack (Absolute path)'),
compress: z
.boolean()
.default(true)
.describe(
'Utilize Tree-sitter to intelligently extract essential code signatures and structure while removing implementation details, significantly reducing token usage (default: true)',
),
includePatterns: z
.string()
.optional()
.describe(
'Specify which files to include using fast-glob compatible patterns (e.g., "**/*.js,src/**"). Only files matching these patterns will be processed. It is recommended to pack only necessary files.',
),
ignorePatterns: z
.string()
.optional()
.describe(
'Specify additional files to exclude using fast-glob compatible patterns (e.g., "test/**,*.spec.js"). These patterns complement .gitignore and default ignores. It is recommended to pack only necessary files.',
),
topFilesLength: z
.number()
.optional()
.default(10)
.describe('Number of top files to display in the metrics (default: 10)'),
},
async ({ directory, compress, includePatterns, ignorePatterns, topFilesLength }): Promise => {
let tempDir = '';
try {
tempDir = await createToolWorkspace();
const outputFilePath = path.join(tempDir, 'repomix-output.xml');
const cliOptions = {
compress,
include: includePatterns,
ignore: ignorePatterns,
output: outputFilePath,
style: 'xml',
securityCheck: true,
topFilesLen: topFilesLength,
quiet: true,
} as CliOptions;
const result = await runCli(['.'], directory, cliOptions);
if (!result) {
return {
isError: true,
content: [
{
type: 'text',
text: JSON.stringify(
{
success: false,
error: 'Failed to return a result',
},
null,
2,
),
},
],
};
}
// Extract metrics information from the pack result
const { packResult } = result;
return formatToolResponse({ directory }, packResult, outputFilePath, topFilesLength);
} catch (error) {
return formatToolError(error);
}
},
);
};
import path from 'node:path';
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import { runCli } from '../../cli/cliRun.js';
import type { CliOptions } from '../../cli/types.js';
import { createToolWorkspace, formatToolError, formatToolResponse } from './mcpToolRuntime.js';
export const registerPackRemoteRepositoryTool = (mcpServer: McpServer) => {
mcpServer.tool(
'pack_remote_repository',
'Fetch, clone and package a GitHub repository into a consolidated file for AI analysis',
{
remote: z.string().describe('GitHub repository URL or user/repo (e.g., yamadashy/repomix)'),
compress: z
.boolean()
.default(true)
.describe(
'Utilize Tree-sitter to intelligently extract essential code signatures and structure while removing implementation details, significantly reducing token usage (default: true)',
),
includePatterns: z
.string()
.optional()
.describe(
'Specify which files to include using fast-glob compatible patterns (e.g., "**/*.js,src/**"). Only files matching these patterns will be processed. It is recommended to pack only necessary files.',
),
ignorePatterns: z
.string()
.optional()
.describe(
'Specify additional files to exclude using fast-glob compatible patterns (e.g., "test/**,*.spec.js"). These patterns complement .gitignore and default ignores. It is recommended to pack only necessary files.',
),
topFilesLength: z
.number()
.optional()
.default(10)
.describe('Number of top files to display in the metrics (default: 10)'),
},
async ({ remote, compress, includePatterns, ignorePatterns, topFilesLength }): Promise => {
let tempDir = '';
try {
tempDir = await createToolWorkspace();
const outputFilePath = path.join(tempDir, 'repomix-output.xml');
const cliOptions = {
remote,
compress,
include: includePatterns,
ignore: ignorePatterns,
output: outputFilePath,
style: 'xml',
securityCheck: true,
topFilesLen: topFilesLength,
quiet: true,
} as CliOptions;
const result = await runCli(['.'], process.cwd(), cliOptions);
if (!result) {
return {
isError: true,
content: [
{
type: 'text',
text: 'Failed to return a result',
},
],
};
}
// Extract metrics information from the pack result
const { packResult } = result;
return formatToolResponse({ repository: remote }, packResult, outputFilePath, topFilesLength);
} catch (error) {
return formatToolError(error);
}
},
);
};
import process from 'node:process';
import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
import { runDefaultAction } from '../../../src/cli/actions/defaultAction.js';
import type { CliOptions } from '../../../src/cli/types.js';
import * as configLoader from '../../../src/config/configLoad.js';
import * as packageJsonParser from '../../../src/core/file/packageJsonParse.js';
import * as packager from '../../../src/core/packager.js';
vi.mock('../../../src/core/packager');
vi.mock('../../../src/config/configLoad');
vi.mock('../../../src/core/file/packageJsonParse');
vi.mock('../../../src/shared/logger');
describe('defaultAction', () => {
beforeEach(() => {
vi.resetAllMocks();
vi.mocked(packageJsonParser.getVersion).mockResolvedValue('1.0.0');
vi.mocked(configLoader.loadFileConfig).mockResolvedValue({});
vi.mocked(configLoader.mergeConfigs).mockReturnValue({
cwd: process.cwd(),
output: {
filePath: 'output.txt',
style: 'plain',
parsableStyle: false,
fileSummary: true,
directoryStructure: true,
topFilesLength: 5,
showLineNumbers: false,
removeComments: false,
removeEmptyLines: false,
compress: false,
copyToClipboard: false,
git: {
sortByChanges: true,
sortByChangesMaxCommits: 100,
},
},
ignore: {
useGitignore: true,
useDefaultPatterns: true,
customPatterns: [],
},
include: [],
security: {
enableSecurityCheck: true,
},
tokenCount: {
encoding: 'o200k_base',
},
});
vi.mocked(packager.pack).mockResolvedValue({
totalFiles: 10,
totalCharacters: 1000,
totalTokens: 200,
fileCharCounts: {},
fileTokenCounts: {},
suspiciousFilesResults: [],
});
});
afterEach(() => {
vi.resetAllMocks();
});
it('should run the default command successfully', async () => {
const options: CliOptions = {
output: 'custom-output.txt',
verbose: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.loadFileConfig).toHaveBeenCalled();
expect(configLoader.mergeConfigs).toHaveBeenCalled();
expect(packager.pack).toHaveBeenCalled();
});
it('should handle custom include patterns', async () => {
const options: CliOptions = {
include: '*.js,*.ts',
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
include: ['*.js', '*.ts'],
}),
);
});
it('should handle custom ignore patterns', async () => {
const options: CliOptions = {
ignore: 'node_modules,*.log',
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
ignore: {
customPatterns: ['node_modules', '*.log'],
},
}),
);
});
it('should handle custom output style', async () => {
const options: CliOptions = {
style: 'xml',
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: expect.objectContaining({
style: 'xml',
}),
}),
);
});
it('should handle errors gracefully', async () => {
vi.mocked(packager.pack).mockRejectedValue(new Error('Test error'));
const options: CliOptions = {};
await expect(runDefaultAction(['.'], process.cwd(), options)).rejects.toThrow('Test error');
});
describe('parsableStyle flag', () => {
it('should handle --parsable-style flag', async () => {
const options: CliOptions = {
parsableStyle: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
parsableStyle: true,
},
}),
);
});
it('should handle explicit --no-parsable-style flag', async () => {
const options: CliOptions = {
parsableStyle: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
parsableStyle: false,
},
}),
);
});
});
describe('security check flag', () => {
it('should handle --no-security-check flag', async () => {
const options: CliOptions = {
securityCheck: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
security: {
enableSecurityCheck: false,
},
}),
);
});
it('should handle explicit --security-check flag', async () => {
const options: CliOptions = {
securityCheck: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({}),
);
});
});
describe('gitignore flag', () => {
it('should handle explicit --no-gitignore flag', async () => {
const options: CliOptions = {
gitignore: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
ignore: {
useGitignore: false,
},
}),
);
});
it('should handle explicit --no-gitignore flag', async () => {
const options: CliOptions = {
gitignore: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({}),
);
});
});
describe('defaultPatterns flag', () => {
it('should handle explicit --no-default-patterns flag', async () => {
const options: CliOptions = {
defaultPatterns: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
ignore: {
useDefaultPatterns: false,
},
}),
);
});
it('should handle explicit --no-default-patterns flag', async () => {
const options: CliOptions = {
defaultPatterns: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({}),
);
});
});
describe('fileSummary flag', () => {
it('should handle --no-file-summary flag', async () => {
const options: CliOptions = {
fileSummary: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
fileSummary: false,
},
}),
);
});
it('should handle explicit --file-summary flag', async () => {
const options: CliOptions = {
fileSummary: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({}),
);
});
});
describe('directoryStructure flag', () => {
it('should handle --no-directory-structure flag', async () => {
const options: CliOptions = {
directoryStructure: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
directoryStructure: false,
},
}),
);
});
it('should handle explicit --directory-structure flag', async () => {
const options: CliOptions = {
directoryStructure: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({}),
);
});
});
describe('removeComments flag', () => {
it('should handle --remove-comments flag', async () => {
const options: CliOptions = {
removeComments: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
removeComments: true,
},
}),
);
});
it('should handle explicit --no-remove-comments flag', async () => {
const options: CliOptions = {
removeComments: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
removeComments: false,
},
}),
);
});
});
describe('removeEmptyLines flag', () => {
it('should handle --remove-empty-lines flag', async () => {
const options: CliOptions = {
removeEmptyLines: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
removeEmptyLines: true,
},
}),
);
});
it('should handle explicit --no-remove-empty-lines flag', async () => {
const options: CliOptions = {
removeEmptyLines: false,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
removeEmptyLines: false,
},
}),
);
});
});
describe('headerText flag', () => {
it('should handle --header-text flag', async () => {
const options: CliOptions = {
headerText: 'Another header text',
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
headerText: 'Another header text',
},
}),
);
});
});
describe('instructionFilePath flag', () => {
it('should handle --instruction-file-path flag', async () => {
const options: CliOptions = {
instructionFilePath: 'path/to/instruction.txt',
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
instructionFilePath: 'path/to/instruction.txt',
},
}),
);
});
});
describe('includeEmptyDirectories flag', () => {
it('should handle --include-empty-directories flag', async () => {
const options: CliOptions = {
includeEmptyDirectories: true,
};
await runDefaultAction(['.'], process.cwd(), options);
expect(configLoader.mergeConfigs).toHaveBeenCalledWith(
process.cwd(),
expect.anything(),
expect.objectContaining({
output: {
includeEmptyDirectories: true,
},
}),
);
});
});
});
import * as fs from 'node:fs/promises';
import path from 'node:path';
import { beforeEach, describe, expect, test, vi } from 'vitest';
import type { DefaultActionRunnerResult } from '../../../src/cli/actions/defaultAction.js';
import {
copyOutputToCurrentDirectory,
isValidRemoteValue,
parseRemoteValue,
runRemoteAction,
} from '../../../src/cli/actions/remoteAction.js';
import { createMockConfig } from '../../testing/testUtils.js';
vi.mock('node:fs/promises', async (importOriginal) => {
const actual = await importOriginal();
return {
...actual,
copyFile: vi.fn(),
mkdir: vi.fn(),
};
});
vi.mock('../../../src/shared/logger');
describe('remoteAction functions', () => {
beforeEach(() => {
vi.resetAllMocks();
});
describe('runRemoteAction', () => {
test('should clone the repository', async () => {
vi.mocked(fs.copyFile).mockResolvedValue(undefined);
await runRemoteAction(
'yamadashy/repomix',
{},
{
isGitInstalled: async () => Promise.resolve(true),
execGitShallowClone: async (url: string, directory: string) => {
await fs.writeFile(path.join(directory, 'README.md'), 'Hello, world!');
},
runDefaultAction: async () => {
return {
packResult: {
totalFiles: 1,
totalCharacters: 1,
totalTokens: 1,
fileCharCounts: {},
fileTokenCounts: {},
suspiciousFilesResults: [],
},
config: createMockConfig(),
} satisfies DefaultActionRunnerResult;
},
},
);
});
});
describe('parseRemoteValue', () => {
test('should convert GitHub shorthand to full URL', () => {
expect(parseRemoteValue('user/repo')).toEqual({
repoUrl: 'https://github.com/user/repo.git',
remoteBranch: undefined,
});
expect(parseRemoteValue('user-name/repo-name')).toEqual({
repoUrl: 'https://github.com/user-name/repo-name.git',
remoteBranch: undefined,
});
expect(parseRemoteValue('user_name/repo_name')).toEqual({
repoUrl: 'https://github.com/user_name/repo_name.git',
remoteBranch: undefined,
});
expect(parseRemoteValue('a.b/a-b_c')).toEqual({
repoUrl: 'https://github.com/a.b/a-b_c.git',
remoteBranch: undefined,
});
});
test('should handle HTTPS URLs', () => {
expect(parseRemoteValue('https://github.com/user/repo')).toEqual({
repoUrl: 'https://github.com/user/repo.git',
remoteBranch: undefined,
});
expect(parseRemoteValue('https://github.com/user/repo.git')).toEqual({
repoUrl: 'https://github.com/user/repo.git',
remoteBranch: undefined,
});
});
test('should not modify SSH URLs', () => {
const sshUrl = 'git@github.com:user/repo.git';
const parsed = parseRemoteValue(sshUrl);
expect(parsed).toEqual({
repoUrl: sshUrl,
remoteBranch: undefined,
});
});
test('should get correct branch name from url', () => {
expect(parseRemoteValue('https://github.com/username/repo/tree/branchname')).toEqual({
repoUrl: 'https://github.com/username/repo.git',
remoteBranch: 'branchname',
});
expect(parseRemoteValue('https://some.gitlab.domain/some/path/username/repo/-/tree/branchname')).toEqual({
repoUrl: 'https://some.gitlab.domain/some/path/username/repo.git',
remoteBranch: 'branchname',
});
expect(
parseRemoteValue('https://some.gitlab.domain/some/path/username/repo/-/tree/branchname/withslash'),
).toEqual({
repoUrl: 'https://some.gitlab.domain/some/path/username/repo.git',
remoteBranch: 'branchname/withslash',
});
});
test('should get correct commit hash from url', () => {
expect(
parseRemoteValue(
'https://some.gitlab.domain/some/path/username/repo/commit/c482755296cce46e58f87d50f25f545c5d15be6f',
),
).toEqual({
repoUrl: 'https://some.gitlab.domain/some/path/username/repo.git',
remoteBranch: 'c482755296cce46e58f87d50f25f545c5d15be6f',
});
});
test('should throw when the URL is invalid or harmful', () => {
expect(() => parseRemoteValue('some random string')).toThrowError();
});
});
describe('copyOutputToCurrentDirectory', () => {
test('should copy output file', async () => {
const sourceDir = '/source/dir';
const targetDir = '/target/dir';
const fileName = 'output.txt';
vi.mocked(fs.copyFile).mockResolvedValue();
await copyOutputToCurrentDirectory(sourceDir, targetDir, fileName);
expect(fs.copyFile).toHaveBeenCalledWith(path.resolve(sourceDir, fileName), path.resolve(targetDir, fileName));
});
test('should throw error when copy fails', async () => {
const sourceDir = '/source/dir';
const targetDir = '/target/dir';
const fileName = 'output.txt';
vi.mocked(fs.copyFile).mockRejectedValue(new Error('Permission denied'));
await expect(copyOutputToCurrentDirectory(sourceDir, targetDir, fileName)).rejects.toThrow(
'Failed to copy output file',
);
});
});
describe('isValidRemoteValue', () => {
describe('GitHub shorthand format (user/repo)', () => {
test('should accept valid repository names', () => {
// Test cases for valid repository names with various allowed characters
const validUrls = [
'user/repo',
'user123/repo-name',
'org-name/repo_name',
'user.name/repo.test',
'user_name/repo_test',
'a/b', // Minimum length case
'user-name123/repo-test123.sub_123', // Complex case
];
for (const url of validUrls) {
expect(isValidRemoteValue(url), `URL should be valid: ${url}`).toBe(true);
}
});
test('should reject invalid repository names', () => {
// Test cases for invalid patterns and disallowed characters
const invalidUrls = [
'', // Empty string
'user', // Missing slash
'/repo', // Missing username
'user/', // Missing repository name
'-user/repo', // Starts with hyphen
'user/-repo', // Repository starts with hyphen
'user./repo', // Username ends with dot
'user/repo.', // Repository ends with dot
'user/repo#branch', // Contains invalid character
'user/repo/extra', // Extra path segment
'us!er/repo', // Contains invalid character
'user/re*po', // Contains invalid character
'user//repo', // Double slash
'.user/repo', // Starts with dot
'user/.repo', // Repository starts with dot
];
for (const url of invalidUrls) {
expect(isValidRemoteValue(url), `URL should be invalid: ${url}`).toBe(false);
}
});
});
describe('Full URL format', () => {
test('should accept valid URLs', () => {
// Test cases for standard URL formats
const validUrls = [
'https://example.com',
'http://localhost',
'https://github.com/user/repo',
'https://gitlab.com/user/repo',
'https://domain.com/path/to/something',
];
for (const url of validUrls) {
expect(isValidRemoteValue(url), `URL should be valid: ${url}`).toBe(true);
}
});
test('should reject invalid URLs', () => {
// Test cases for malformed URLs
const invalidUrls = ['not-a-url', 'http://', 'https://', '://no-protocol.com', 'http://[invalid]'];
for (const url of invalidUrls) {
expect(isValidRemoteValue(url), `URL should be invalid: ${url}`).toBe(false);
}
});
});
});
});
import { describe, expect, test } from 'vitest';
import type { RepomixConfigMerged } from '../../../src/config/configSchema.js';
import { parseFile } from '../../../src/core/treeSitter/parseFile.js';
describe('parseFile for CSS', () => {
test('should parse CSS correctly', async () => {
const fileContent = `
/* Main styles for the application */
body {
font-family: 'Arial', sans-serif;
line-height: 1.6;
color: #333;
background-color: #f4f4f4;
margin: 0;
padding: 0;
}
/* Header styles */
.header {
background-color: #35424a;
color: #ffffff;
padding: 20px;
border-bottom: #e8491d 3px solid;
}
/* Navigation styles */
.nav {
display: flex;
justify-content: space-between;
align-items: center;
}
@media (max-width: 768px) {
.nav {
flex-direction: column;
}
.container {
width: 95%;
}
}
`;
const filePath = 'style.css';
const config = {};
const result = await parseFile(fileContent, filePath, config as RepomixConfigMerged);
expect(typeof result).toBe('string');
const expectContents = [
// Comments (all lines should be extracted)
'Main styles for the application',
'Header styles',
'Navigation styles',
// Selectors (only the first line should be extracted)
'body {',
'.header {',
'.nav {',
// at-rules are not extracted with the current query, so removed from expectations
// '@media (max-width: 768px) {',
];
for (const expectContent of expectContents) {
expect(result).toContain(expectContent);
}
// Properties should not be extracted
const unexpectedContents = [
'font-family:',
'line-height:',
'color:',
'background-color:',
'margin:',
'padding:',
'display:',
'justify-content:',
'align-items:',
'flex-direction:',
'width:',
];
for (const unexpectedContent of unexpectedContents) {
expect(result).not.toContain(unexpectedContent);
}
});
test('should handle different comment styles', async () => {
const fileContent = `
/* Single line comment */
body { color: black; }
/* Multi-line comment
spanning multiple lines */
.container { width: 100%; }
`;
const filePath = 'comments.css';
const config = {};
const result = await parseFile(fileContent, filePath, config as RepomixConfigMerged);
expect(typeof result).toBe('string');
const expectContents = [
'Single line comment',
'Multi-line comment\n spanning multiple lines',
'body {',
'.container {',
];
for (const expectContent of expectContents) {
expect(result).toContain(expectContent);
}
});
test('should handle various at-rules', async () => {
const fileContent = `
@import url('https://fonts.googleapis.com/css2?family=Roboto&display=swap');
@charset "UTF-8";
@keyframes fadeIn {
from { opacity: 0; }
to { opacity: 1; }
}
@media screen and (min-width: 768px) {
body { font-size: 16px; }
}
`;
const filePath = 'at-rules.css';
const config = {};
const result = await parseFile(fileContent, filePath, config as RepomixConfigMerged);
expect(typeof result).toBe('string');
// Output the result for debugging
console.log('At-Rules Parse Result:', result);
// Skip testing at-rules as they are not extracted in the current implementation
// Enable this test when at-rule extraction is implemented in the future
// Inner rules should not be extracted
const unexpectedContents = ['from { opacity: 0; }', 'to { opacity: 1; }'];
for (const unexpectedContent of unexpectedContents) {
expect(result).not.toContain(unexpectedContent);
}
});
test('should handle complex selectors', async () => {
const fileContent = `
/* Complex selectors */
body.dark-theme .container > div:first-child {
color: white;
background-color: #333;
}
.sidebar ul li a:hover,
.sidebar ul li a:focus {
text-decoration: underline;
color: blue;
}
#main-content h1 + p::first-line {
font-weight: bold;
font-size: 1.2em;
}
`;
const filePath = 'complex-selectors.css';
const config = {};
const result = await parseFile(fileContent, filePath, config as RepomixConfigMerged);
expect(typeof result).toBe('string');
const expectContents = [
'Complex selectors',
'body.dark-theme .container > div:first-child {',
'.sidebar ul li a:hover,',
'#main-content h1 + p::first-line {',
];
for (const expectContent of expectContents) {
expect(result).toContain(expectContent);
}
// Properties should not be extracted
const unexpectedContents = [
'color: white;',
'background-color: #333;',
'text-decoration: underline;',
'color: blue;',
'font-weight: bold;',
'font-size: 1.2em;',
];
for (const unexpectedContent of unexpectedContents) {
expect(result).not.toContain(unexpectedContent);
}
});
});
# Kommandozeilenoptionen
## Grundlegende Optionen
- `-v, --version`: Zeigt die Version an
## Ausgabeoptionen
- `-o, --output `: Ausgabedateiname (Standard: `repomix-output.txt`)
- `--style `: Ausgabeformat (`plain`, `xml`, `markdown`) (Standard: `plain`)
- `--parsable-style`: Aktiviert parsbare Ausgabe basierend auf dem gewählten Formatschema (Standard: `false`)
- `--compress`: Führt eine intelligente Code-Extraktion durch, die sich auf Funktions- und Klassensignaturen konzentriert und Implementierungsdetails entfernt. Weitere Details und Beispiele finden Sie im [Code-Komprimierungsleitfaden](code-compress)
- `--output-show-line-numbers`: Fügt Zeilennummern hinzu (Standard: `false`)
- `--copy`: In die Zwischenablage kopieren (Standard: `false`)
- `--no-file-summary`: Deaktiviert die Dateizusammenfassung (Standard: `true`)
- `--no-directory-structure`: Deaktiviert die Verzeichnisstruktur (Standard: `true`)
- `--remove-comments`: Entfernt Kommentare (Standard: `false`)
- `--remove-empty-lines`: Entfernt leere Zeilen (Standard: `false`)
- `--header-text `: Benutzerdefinierter Text für den Dateikopf
- `--instruction-file-path `: Pfad zu einer Datei mit detaillierten benutzerdefinierten Anweisungen
- `--include-empty-directories`: Leere Verzeichnisse in die Ausgabe einbeziehen (Standard: `false`)
## Filteroptionen
- `--include `: Einzuschließende Muster (durch Komma getrennt)
- `-i, --ignore `: Zu ignorierende Muster (durch Komma getrennt)
- `--no-gitignore`: Deaktiviert die Verwendung der .gitignore-Datei
- `--no-default-patterns`: Deaktiviert Standardmuster
## Remote-Repository-Optionen
- `--remote `: Remote-Repository verarbeiten
- `--remote-branch `: Remote-Branch-Name, Tag oder Commit-Hash angeben (Standard ist der Standard-Branch des Repositories)
## Konfigurationsoptionen
- `-c, --config `: Pfad zur benutzerdefinierten Konfigurationsdatei
- `--init`: Konfigurationsdatei erstellen
- `--global`: Globale Konfiguration verwenden
## Sicherheitsoptionen
- `--no-security-check`: Deaktiviert die Sicherheitsprüfung (Standard: `true`)
## Token-Zähloptionen
- `--token-count-encoding `: Token-Zählkodierung festlegen (z.B. `o200k_base`, `cl100k_base`) (Standard: `o200k_base`)
## Weitere Optionen
- `--top-files-len `: Anzahl der anzuzeigenden Top-Dateien (Standard: `5`)
- `--verbose`: Ausführliche Protokollierung aktivieren
- `--quiet`: Deaktiviert alle Ausgaben an stdout
## Beispiele
```bash
# Grundlegende Verwendung
repomix
# Benutzerdefinierte Ausgabe
repomix -o output.xml --style xml
# Benutzerdefinierte Ausgabe mit Komprimierung
repomix --compress
# Bestimmte Dateien verarbeiten
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# Remote-Repository mit Branch
repomix --remote https://github.com/user/repo/tree/main
# Remote-Repository mit Commit
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# Remote-Repository mit Kurzform
repomix --remote user/repo
```
# Konfiguration
## Schnellstart
Konfigurationsdatei erstellen:
```bash
repomix --init
```
## Konfigurationsdatei
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "Benutzerdefinierter Kopftext",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## Globale Konfiguration
Globale Konfiguration erstellen:
```bash
repomix --init --global
```
Speicherort:
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## Ignore-Muster
Prioritätsreihenfolge:
1. CLI-Optionen (`--ignore`)
2. `.repomixignore`
3. `.gitignore` und `.git/info/exclude`
4. Standard-Muster
Beispiel für `.repomixignore`:
```text
# Cache-Verzeichnisse
.cache/
tmp/
# Build-Ausgaben
dist/
build/
# Logs
*.log
```
## Standard-Ignore-Muster
Standardmäßig enthaltene häufige Muster:
```text
node_modules/**
.git/**
coverage/**
dist/**
```
Vollständige Liste: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## Beispiele
### Code-Komprimierung
Wenn `output.compress` auf `true` gesetzt ist, extrahiert Repomix wesentliche Code-Strukturen und entfernt dabei Implementierungsdetails. Dies reduziert die Token-Anzahl und behält gleichzeitig wichtige strukturelle Informationen bei.
Weitere Details und Beispiele finden Sie im [Code-Komprimierungs-Leitfaden](code-compress).
### Git-Integration
Die `output.git`-Konfiguration ermöglicht es Ihnen, die Sortierung von Dateien basierend auf der Git-Historie zu steuern:
- `sortByChanges`: Wenn auf `true` gesetzt, werden Dateien nach der Anzahl der Git-Änderungen (Commits, die die Datei geändert haben) sortiert. Dateien mit mehr Änderungen erscheinen am Ende der Ausgabe. Dies hilft dabei, aktiver entwickelte Dateien zu priorisieren. Standard: `true`
- `sortByChangesMaxCommits`: Die maximale Anzahl von Commits, die bei der Zählung der Dateiänderungen analysiert werden. Standard: `100`
Beispielkonfiguration:
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### Kommentarentfernung
Wenn `output.removeComments` auf `true` gesetzt ist, werden Kommentare aus unterstützten Dateitypen entfernt, um die Ausgabegröße zu reduzieren und sich auf den wesentlichen Code-Inhalt zu konzentrieren.
Unterstützte Sprachen und detaillierte Beispiele finden Sie im [Kommentarentfernungs-Leitfaden](comment-removal).
# Command Line Options
## Basic Options
- `-v, --version`: Show tool version
## Output Options
- `-o, --output `: Output file name (default: `repomix-output.txt`)
- `--style `: Output style (`plain`, `xml`, `markdown`) (default: `plain`)
- `--parsable-style`: Enable parsable output based on the chosen style schema (default: `false`)
- `--compress`: Perform intelligent code extraction, focusing on essential function and class signatures while removing implementation details. For more details and examples, see [Code Compression Guide](code-compress).
- `--output-show-line-numbers`: Add line numbers (default: `false`)
- `--copy`: Copy to clipboard (default: `false`)
- `--no-file-summary`: Disable file summary (default: `true`)
- `--no-directory-structure`: Disable directory structure (default: `true`)
- `--remove-comments`: Remove comments (default: `false`)
- `--remove-empty-lines`: Remove empty lines (default: `false`)
- `--header-text `: Custom text to include in the file header
- `--instruction-file-path `: Path to a file containing detailed custom instructions
- `--include-empty-directories`: Include empty directories in the output (default: `false`)
## Filter Options
- `--include `: Include patterns (comma-separated)
- `-i, --ignore `: Ignore patterns (comma-separated)
- `--no-gitignore`: Disable .gitignore file usage
- `--no-default-patterns`: Disable default patterns
## Remote Repository Options
- `--remote `: Process remote repository
- `--remote-branch `: Specify the remote branch name, tag, or commit hash (defaults to repository default branch)
## Configuration Options
- `-c, --config `: Custom config file path
- `--init`: Create config file
- `--global`: Use global config
## Security Options
- `--no-security-check`: Disable security check (default: `true`)
## Token Count Options
- `--token-count-encoding `: Specify token count encoding (e.g., `o200k_base`, `cl100k_base`) (default: `o200k_base`)
## Other Options
- `--top-files-len `: Number of top files to show (default: `5`)
- `--verbose`: Enable verbose logging
- `--quiet`: Disable all output to stdout
## Examples
```bash
# Basic usage
repomix
# Custom output
repomix -o output.xml --style xml
# 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
```
# Configuration
## Quick Start
Create configuration file:
```bash
repomix --init
```
## Configuration File
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "Custom header text",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## Global Configuration
Create global configuration:
```bash
repomix --init --global
```
Location:
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## Ignore Patterns
Priority:
1. CLI options (`--ignore`)
2. `.repomixignore`
3. `.gitignore` and `.git/info/exclude`
4. Default patterns
`.repomixignore` example:
```text
# Cache directories
.cache/
tmp/
# Build outputs
dist/
build/
# Logs
*.log
```
## Default Ignore Patterns
Common patterns included by default:
```text
node_modules/**
.git/**
coverage/**
dist/**
```
Full list: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## Examples
### Code Compression
When `output.compress` is set to `true`, Repomix will intelligently extract essential code structures while removing implementation details. This helps reduce token count while maintaining important structural information.
For more details and examples, see [Code Compression Guide](code-compress).
### Git Integration
The `output.git` configuration allows you to control how files are sorted based on Git history:
- `sortByChanges`: When set to `true`, files are sorted by the number of Git changes (commits that modified the file). Files with more changes appear at the bottom of the output. This can help prioritize more actively developed files. Default: `true`
- `sortByChangesMaxCommits`: The maximum number of commits to analyze when counting file changes. Default: `100`
Example configuration:
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### Comment Removal
When `output.removeComments` is set to `true`, Repomix will remove comments from supported file types to reduce the output size and focus on essential code content.
For supported languages and detailed examples, see [Comment Removal Guide](comment-removal).
# Basic Usage
## Quick Start
Pack your entire repository:
```bash
repomix
```
## Common Use Cases
### Pack Specific Directories
```bash
repomix path/to/directory
```
### Include Specific Files
Use [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### Exclude Files
```bash
repomix --ignore "**/*.log,tmp/"
```
### Remote Repositories
```bash
# Using GitHub URL
repomix --remote https://github.com/user/repo
# Using shorthand
repomix --remote user/repo
# Specific branch/tag/commit
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
### Code Compression
```bash
repomix --compress
# You can also use it with remote repositories:
repomix --remote yamadashy/repomix --compress
```
## Output Formats
### XML (Default)
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### Plain Text
```bash
repomix --style plain
```
## Additional Options
### Remove Comments
```bash
repomix --remove-comments
```
### Show Line Numbers
```bash
repomix --output-show-line-numbers
```
### Copy to Clipboard
```bash
repomix --copy
```
### Disable Security Check
```bash
repomix --no-security-check
```
## Configuration
Initialize configuration file:
```bash
repomix --init
```
See [Configuration Guide](/guide/configuration) for detailed options.
# Opciones de Línea de Comandos
## Opciones Básicas
- `-v, --version`: Muestra la versión
## Opciones de Salida
- `-o, --output `: Nombre del archivo de salida (predeterminado: `repomix-output.txt`)
- `--style `: Estilo de salida (`plain`, `xml`, `markdown`) (predeterminado: `plain`)
- `--parsable-style`: Habilita la salida analizable basada en el esquema del estilo elegido (predeterminado: `false`)
- `--compress`: Realiza una extracción inteligente de código, centrándose en las firmas de funciones y clases mientras elimina los detalles de implementación. Para más detalles y ejemplos, consulte la [Guía de Compresión de Código](code-compress)
- `--output-show-line-numbers`: Agrega números de línea (predeterminado: `false`)
- `--copy`: Copiar al portapapeles (predeterminado: `false`)
- `--no-file-summary`: Deshabilita el resumen de archivos (predeterminado: `true`)
- `--no-directory-structure`: Deshabilita la estructura de directorios (predeterminado: `true`)
- `--remove-comments`: Elimina comentarios (predeterminado: `false`)
- `--remove-empty-lines`: Elimina líneas vacías (predeterminado: `false`)
- `--header-text `: Texto personalizado para incluir en el encabezado del archivo
- `--instruction-file-path `: Ruta al archivo con instrucciones personalizadas detalladas
- `--include-empty-directories`: Incluye directorios vacíos en la salida (predeterminado: `false`)
## Opciones de Filtrado
- `--include `: Patrones a incluir (separados por comas)
- `-i, --ignore `: Patrones a ignorar (separados por comas)
- `--no-gitignore`: Deshabilita el uso del archivo .gitignore
- `--no-default-patterns`: Deshabilita los patrones predeterminados
## Opciones de Repositorio Remoto
- `--remote `: Procesa repositorio remoto
- `--remote-branch `: Especifica el nombre de la rama remota, etiqueta o hash de commit (por defecto es la rama principal del repositorio)
## Opciones de Configuración
- `-c, --config `: Ruta del archivo de configuración personalizado
- `--init`: Crea archivo de configuración
- `--global`: Usa configuración global
## Opciones de Seguridad
- `--no-security-check`: Deshabilita la verificación de seguridad (predeterminado: `true`)
## Opciones de Conteo de Tokens
- `--token-count-encoding `: Especifica la codificación para el conteo de tokens (ej. `o200k_base`, `cl100k_base`) (predeterminado: `o200k_base`)
## Otras Opciones
- `--top-files-len `: Número de archivos principales a mostrar (predeterminado: `5`)
- `--verbose`: Habilita el registro detallado
- `--quiet`: Deshabilita toda la salida a stdout
## Ejemplos
```bash
# Uso básico
repomix
# Salida personalizada
repomix -o output.xml --style xml
# Salida personalizada con compresión
repomix --compress
# Procesar archivos específicos
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# Repositorio remoto con rama
repomix --remote https://github.com/user/repo/tree/main
# Repositorio remoto con commit
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# Repositorio remoto con formato abreviado
repomix --remote user/repo
```
# Configuración
## Inicio Rápido
Crear archivo de configuración:
```bash
repomix --init
```
## Archivo de Configuración
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "Texto de encabezado personalizado",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## Configuración Global
Crear configuración global:
```bash
repomix --init --global
```
Ubicación:
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## Patrones de Ignorar
Prioridad:
1. Opciones CLI (`--ignore`)
2. `.repomixignore`
3. `.gitignore` y `.git/info/exclude`
4. Patrones predeterminados
Ejemplo de `.repomixignore`:
```text
# Directorios de caché
.cache/
tmp/
# Salidas de construcción
dist/
build/
# Registros
*.log
```
## Patrones de Ignorar Predeterminados
Patrones comunes incluidos por defecto:
```text
node_modules/**
.git/**
coverage/**
dist/**
```
Lista completa: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## Ejemplos
### Compresión de Código
Cuando `output.compress` está configurado como `true`, Repomix extraerá las estructuras esenciales del código mientras elimina los detalles de implementación. Esto reduce el conteo de tokens mientras mantiene información estructural importante.
Para más detalles y ejemplos, consulte la [Guía de Compresión de Código](code-compress).
### Integración con Git
La configuración `output.git` le permite controlar cómo se ordenan los archivos según el historial de Git:
- `sortByChanges`: Cuando está configurado como `true`, los archivos se ordenan por el número de cambios en Git (commits que modificaron el archivo). Los archivos con más cambios aparecen al final de la salida. Esto ayuda a priorizar los archivos más activamente desarrollados. Por defecto: `true`
- `sortByChangesMaxCommits`: El número máximo de commits a analizar al contar los cambios de archivos. Por defecto: `100`
Ejemplo de configuración:
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### Eliminación de Comentarios
Cuando `output.removeComments` está configurado como `true`, se eliminan los comentarios de los tipos de archivo soportados para reducir el tamaño de la salida y enfocarse en el contenido esencial del código.
Para ver los lenguajes soportados y ejemplos detallados, consulte la [Guía de Eliminación de Comentarios](comment-removal).
# Utilisation de base
## Démarrage rapide
Empaquetez tout votre dépôt:
```bash
repomix
```
## Cas d'utilisation courants
### Empaqueter des répertoires spécifiques
```bash
repomix path/to/directory
```
### Inclure des fichiers spécifiques
Utilisez des [motifs glob](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
### Exclure des fichiers
```bash
repomix --ignore "**/*.log,tmp/"
```
### Dépôts distants
```bash
# En utilisant l'URL GitHub
repomix --remote https://github.com/user/repo
# En utilisant le format abrégé
repomix --remote user/repo
# Branche/tag/commit spécifique
repomix --remote user/repo --remote-branch main
repomix --remote user/repo --remote-branch 935b695
```
### Compression de code
```bash
repomix --compress
# Vous pouvez également l'utiliser avec des dépôts distants:
repomix --remote yamadashy/repomix --compress
```
## Formats de sortie
### XML (Par défaut)
```bash
repomix --style xml
```
### Markdown
```bash
repomix --style markdown
```
### Texte brut
```bash
repomix --style plain
```
## Options supplémentaires
### Supprimer les commentaires
```bash
repomix --remove-comments
```
### Afficher les numéros de ligne
```bash
repomix --output-show-line-numbers
```
### Copier dans le presse-papiers
```bash
repomix --copy
```
### Désactiver la vérification de sécurité
```bash
repomix --no-security-check
```
## Configuration
Initialiser le fichier de configuration:
```bash
repomix --init
```
Consultez le [Guide de configuration](/fr/guide/configuration) pour les options détaillées.
# コマンドラインオプション
## 基本オプション
- `-v, --version`: バージョンを表示
## 出力オプション
- `-o, --output `: 出力ファイル名（デフォルト: `repomix-output.txt`）
- `--style `: 出力形式（`plain`、`xml`、`markdown`）（デフォルト: `plain`）
- `--parsable-style`: 選択した形式のスキーマに基づいて解析可能な出力を有効化（デフォルト: `false`）
- `--compress`: 関数やクラスのシグネチャなどの重要な構造を保持しながら、実装の詳細を削除するインテリジェントなコード抽出を実行します。詳細と例については、[コード圧縮ガイド](code-compress)を参照してください。
- `--output-show-line-numbers`: 行番号を追加（デフォルト: `false`）
- `--copy`: クリップボードにコピー（デフォルト: `false`）
- `--no-file-summary`: ファイルサマリーを無効化（デフォルト: `true`）
- `--no-directory-structure`: ディレクトリ構造を無効化（デフォルト: `true`）
- `--remove-comments`: コメントを削除（デフォルト: `false`）
- `--remove-empty-lines`: 空行を削除（デフォルト: `false`）
- `--header-text `: ファイルヘッダーに含めるカスタムテキスト
- `--instruction-file-path `: 詳細なカスタム指示を含むファイルのパス
- `--include-empty-directories`: 空のディレクトリを出力に含める（デフォルト: `false`）
## フィルターオプション
- `--include `: 含めるパターン（カンマ区切り）
- `-i, --ignore `: 除外パターン（カンマ区切り）
- `--no-gitignore`: .gitignoreファイルの使用を無効化
- `--no-default-patterns`: デフォルトパターンを無効化
## リモートリポジトリオプション
- `--remote `: リモートリポジトリを処理
- `--remote-branch `: リモートブランチ名、タグ、またはコミットハッシュを指定（デフォルトはリポジトリのデフォルトブランチ）
## 設定オプション
- `-c, --config `: カスタム設定ファイルのパス
- `--init`: 設定ファイルを作成
- `--global`: グローバル設定を使用
## セキュリティオプション
- `--no-security-check`: セキュリティチェックを無効化（デフォルト: `true`）
## トークンカウントオプション
- `--token-count-encoding `: トークンカウントのエンコーディングを指定（例: `o200k_base`、`cl100k_base`）（デフォルト: `o200k_base`）
## その他のオプション
- `--top-files-len `: 表示するトップファイルの数（デフォルト: `5`）
- `--verbose`: 詳細なログを有効化
- `--quiet`: 標準出力へのすべての出力を無効化
## 使用例
```bash
# 基本的な使用方法
repomix
# カスタム出力
repomix -o output.xml --style xml
# 圧縮を使用したカスタム出力
repomix --compress
# 特定のファイルを処理
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# ブランチを指定したリモートリポジトリ
repomix --remote https://github.com/user/repo/tree/main
# コミットを指定したリモートリポジトリ
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# ショートハンドを使用したリモートリポジトリ
repomix --remote user/repo
```
# 設定
## クイックスタート
設定ファイルを作成：
```bash
repomix --init
```
## 設定ファイル
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "カスタムヘッダーテキスト",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## グローバル設定
グローバル設定を作成：
```bash
repomix --init --global
```
設定ファイルの場所：
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## 除外パターン
優先順位：
1. CLIオプション（`--ignore`）
2. `.repomixignore`
3. `.gitignore` および `.git/info/exclude`
4. デフォルトパターン
`.repomixignore` の例：
```text
# キャッシュディレクトリ
.cache/
tmp/
# ビルド出力
dist/
build/
# ログ
*.log
```
## デフォルトの除外パターン
デフォルトで含まれる一般的なパターン：
```text
node_modules/**
.git/**
coverage/**
dist/**
```
全リスト: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## 設定例
### コード圧縮
`output.compress`を`true`に設定すると、Repomixは実装の詳細を削除しながら、本質的なコード構造を抽出します。これにより、トークン数を削減しながら重要な構造情報を維持できます。
詳細と例については[コード圧縮ガイド](code-compress)をご覧ください。
### Git統合
`output.git`設定では、Gitの履歴に基づいてファイルをソートする方法を制御できます：
- `sortByChanges`: `true`に設定すると、ファイルはGitの変更回数（そのファイルを変更したコミット数）でソートされます。より多くの変更があるファイルが出力の下部に表示されます。これは、より活発に開発されているファイルを優先するのに役立ちます。デフォルト: `true`
- `sortByChangesMaxCommits`: ファイルの変更回数を数える際に分析する最大コミット数。デフォルト: `100`
設定例：
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### コメントの削除
`output.removeComments`を`true`に設定すると、サポートされているファイルタイプからコメントが削除され、出力サイズを削減し、本質的なコード内容に焦点を当てることができます。
サポートされている言語と詳細な例については[コメント削除ガイド](comment-removal)をご覧ください。
# 명령줄 옵션
## 기본 옵션
- `-v, --version`: 버전 표시
## 출력 옵션
- `-o, --output `: 출력 파일 이름 (기본값: `repomix-output.txt`)
- `--style `: 출력 스타일 (`plain`, `xml`, `markdown`) (기본값: `plain`)
- `--parsable-style`: 선택한 스타일 스키마에 기반한 파싱 가능한 출력 활성화 (기본값: `false`)
- `--compress`: 함수와 클래스 시그니처에 중점을 두고 구현 세부 사항을 제거하는 지능형 코드 추출을 수행합니다. 자세한 내용과 예제는 [코드 압축 가이드](code-compress)를 참조하세요.
- `--output-show-line-numbers`: 줄 번호 추가 (기본값: `false`)
- `--copy`: 클립보드에 복사 (기본값: `false`)
- `--no-file-summary`: 파일 요약 비활성화 (기본값: `true`)
- `--no-directory-structure`: 디렉토리 구조 비활성화 (기본값: `true`)
- `--remove-comments`: 주석 제거 (기본값: `false`)
- `--remove-empty-lines`: 빈 줄 제거 (기본값: `false`)
- `--header-text `: 파일 헤더에 포함할 사용자 정의 텍스트
- `--instruction-file-path `: 상세한 사용자 정의 지침이 포함된 파일 경로
- `--include-empty-directories`: 출력에 빈 디렉토리 포함 (기본값: `false`)
## 필터 옵션
- `--include `: 포함할 패턴 (쉼표로 구분)
- `-i, --ignore `: 무시할 패턴 (쉼표로 구분)
- `--no-gitignore`: .gitignore 파일 사용 비활성화
- `--no-default-patterns`: 기본 패턴 비활성화
## 원격 저장소 옵션
- `--remote `: 원격 저장소 처리
- `--remote-branch `: 원격 브랜치 이름, 태그 또는 커밋 해시 지정 (기본값은 저장소의 기본 브랜치)
## 설정 옵션
- `-c, --config `: 사용자 정의 설정 파일 경로
- `--init`: 설정 파일 생성
- `--global`: 전역 설정 사용
## 보안 옵션
- `--no-security-check`: 보안 검사 비활성화 (기본값: `true`)
## 토큰 카운트 옵션
- `--token-count-encoding `: 토큰 카운트 인코딩 지정 (예: `o200k_base`, `cl100k_base`) (기본값: `o200k_base`)
## 기타 옵션
- `--top-files-len `: 표시할 상위 파일 수 (기본값: `5`)
- `--verbose`: 상세 로깅 활성화
- `--quiet`: 표준 출력에 대한 모든 출력 비활성화
## 예제
```bash
# 기본 사용법
repomix
# 사용자 정의 출력
repomix -o output.xml --style xml
# 압축을 사용한 사용자 정의 출력
repomix --compress
# 특정 파일 처리
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# 브랜치를 지정한 원격 저장소
repomix --remote https://github.com/user/repo/tree/main
# 커밋을 지정한 원격 저장소
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# 단축형을 사용한 원격 저장소
repomix --remote user/repo
```
# 설정
## 빠른 시작
설정 파일 생성:
```bash
repomix --init
```
## 설정 파일
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "사용자 정의 헤더 텍스트",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## 전역 설정
전역 설정 생성:
```bash
repomix --init --global
```
위치:
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## 무시 패턴
우선순위:
1. CLI 옵션 (`--ignore`)
2. `.repomixignore`
3. `.gitignore` 및 `.git/info/exclude`
4. 기본 패턴
`.repomixignore` 예시:
```text
# 캐시 디렉토리
.cache/
tmp/
# 빌드 출력
dist/
build/
# 로그
*.log
```
## 기본 무시 패턴
기본적으로 포함되는 일반적인 패턴:
```text
node_modules/**
.git/**
coverage/**
dist/**
```
전체 목록: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## 예제
### 코드 압축
`output.compress`를 `true`로 설정하면, Repomix는 구현 세부 사항을 제거하면서 필수적인 코드 구조를 추출합니다. 이를 통해 중요한 구조적 정보를 유지하면서 토큰 수를 줄일 수 있습니다.
자세한 내용과 예제는 [코드 압축 가이드](code-compress)를 참조하세요.
### Git 통합
`output.git` 설정을 통해 Git 히스토리를 기반으로 파일을 정렬하는 방법을 제어할 수 있습니다:
- `sortByChanges`: `true`로 설정하면, 파일은 Git 변경 횟수(해당 파일을 수정한 커밋 수)에 따라 정렬됩니다. 더 많은 변경이 있는 파일이 출력의 하단에 표시됩니다. 이는 더 활발하게 개발되는 파일을 우선순위화하는 데 도움이 됩니다. 기본값: `true`
- `sortByChangesMaxCommits`: 파일 변경 횟수를 계산할 때 분석할 최대 커밋 수입니다. 기본값: `100`
설정 예시:
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### 주석 제거
`output.removeComments`를 `true`로 설정하면, 지원되는 파일 유형에서 주석이 제거되어 출력 크기를 줄이고 핵심 코드 내용에 집중할 수 있습니다.
지원되는 언어와 자세한 예제는 [주석 제거 가이드](comment-removal)를 참조하세요.
# Opções de Linha de Comando
## Opções Básicas
- `-v, --version`: Mostra a versão
## Opções de Saída
- `-o, --output `: Nome do arquivo de saída (padrão: `repomix-output.txt`)
- `--style `: Estilo de saída (`plain`, `xml`, `markdown`) (padrão: `plain`)
- `--parsable-style`: Habilita saída analisável baseada no esquema do estilo escolhido (padrão: `false`)
- `--compress`: Realiza extração inteligente de código, focando nas assinaturas de funções e classes enquanto remove detalhes de implementação. Para mais detalhes e exemplos, consulte o [Guia de Compressão de Código](code-compress)
- `--output-show-line-numbers`: Adiciona números de linha (padrão: `false`)
- `--copy`: Copia para a área de transferência (padrão: `false`)
- `--no-file-summary`: Desabilita o resumo de arquivos (padrão: `true`)
- `--no-directory-structure`: Desabilita a estrutura de diretórios (padrão: `true`)
- `--remove-comments`: Remove comentários (padrão: `false`)
- `--remove-empty-lines`: Remove linhas vazias (padrão: `false`)
- `--header-text `: Texto personalizado para incluir no cabeçalho do arquivo
- `--instruction-file-path `: Caminho para um arquivo contendo instruções personalizadas detalhadas
- `--include-empty-directories`: Inclui diretórios vazios na saída (padrão: `false`)
## Opções de Filtro
- `--include `: Padrões para incluir (separados por vírgula)
- `-i, --ignore `: Padrões para ignorar (separados por vírgula)
- `--no-gitignore`: Desabilita o uso do arquivo .gitignore
- `--no-default-patterns`: Desabilita padrões padrão
## Opções de Repositório Remoto
- `--remote `: Processa repositório remoto
- `--remote-branch `: Especifica o nome do branch remoto, tag ou hash do commit (padrão é o branch padrão do repositório)
## Opções de Configuração
- `-c, --config `: Caminho do arquivo de configuração personalizado
- `--init`: Cria arquivo de configuração
- `--global`: Usa configuração global
## Opções de Segurança
- `--no-security-check`: Desabilita verificação de segurança (padrão: `true`)
## Opções de Contagem de Tokens
- `--token-count-encoding `: Especifica a codificação para contagem de tokens (ex: `o200k_base`, `cl100k_base`) (padrão: `o200k_base`)
## Outras Opções
- `--top-files-len `: Número de arquivos principais para mostrar (padrão: `5`)
- `--verbose`: Habilita log detalhado
- `--quiet`: Desabilita toda saída para stdout
## Exemplos
```bash
# Uso básico
repomix
# Saída personalizada
repomix -o output.xml --style xml
# Saída personalizada com compressão
repomix --compress
# Processar arquivos específicos
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# Repositório remoto com branch
repomix --remote https://github.com/user/repo/tree/main
# Repositório remoto com commit
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# Repositório remoto com formato curto
repomix --remote user/repo
```
# Configuração
## Início Rápido
Criar arquivo de configuração:
```bash
repomix --init
```
## Arquivo de Configuração
`repomix.config.json`:
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "Texto personalizado do cabeçalho",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## Configuração Global
Criar configuração global:
```bash
repomix --init --global
```
Localização:
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## Padrões de Ignorar
Prioridade:
1. Opções CLI (`--ignore`)
2. `.repomixignore`
3. `.gitignore` e `.git/info/exclude`
4. Padrões padrão
Exemplo de `.repomixignore`:
```text
# Diretórios de cache
.cache/
tmp/
# Saídas de build
dist/
build/
# Logs
*.log
```
## Padrões de Ignorar Padrão
Padrões comuns incluídos por padrão:
```text
node_modules/**
.git/**
coverage/**
dist/**
```
Lista completa: [defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## Exemplos
### Compressão de Código
Quando `output.compress` está configurado como `true`, o Repomix extrairá as estruturas essenciais do código enquanto remove os detalhes de implementação. Isso reduz a contagem de tokens enquanto mantém informações estruturais importantes.
Para mais detalhes e exemplos, consulte o [Guia de Compressão de Código](code-compress).
### Integração com Git
A configuração `output.git` permite controlar como os arquivos são ordenados com base no histórico do Git:
- `sortByChanges`: Quando configurado como `true`, os arquivos são ordenados pelo número de alterações no Git (commits que modificaram o arquivo). Arquivos com mais alterações aparecem no final da saída. Isso ajuda a priorizar arquivos mais ativamente desenvolvidos. Padrão: `true`
- `sortByChangesMaxCommits`: O número máximo de commits a analisar ao contar as alterações de arquivos. Padrão: `100`
Exemplo de configuração:
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### Remoção de Comentários
Quando `output.removeComments` está configurado como `true`, os comentários são removidos dos tipos de arquivo suportados para reduzir o tamanho da saída e focar no conteúdo essencial do código.
Para linguagens suportadas e exemplos detalhados, consulte o [Guia de Remoção de Comentários](comment-removal).
# 命令行选项
## 基本选项
- `-v, --version`: 显示版本
## 输出选项
- `-o, --output `: 输出文件名（默认：`repomix-output.txt`）
- `--style `: 输出样式（`plain`、`xml`、`markdown`）（默认：`plain`）
- `--parsable-style`: 启用基于所选样式模式的可解析输出（默认：`false`）
- `--compress`: 执行智能代码提取，专注于函数和类的签名，同时删除实现细节。有关详细信息和示例，请参阅[代码压缩指南](code-compress)。
- `--output-show-line-numbers`: 添加行号（默认：`false`）
- `--copy`: 复制到剪贴板（默认：`false`）
- `--no-file-summary`: 禁用文件摘要（默认：`true`）
- `--no-directory-structure`: 禁用目录结构（默认：`true`）
- `--remove-comments`: 移除注释（默认：`false`）
- `--remove-empty-lines`: 移除空行（默认：`false`）
- `--header-text `: 文件头部包含的自定义文本
- `--instruction-file-path `: 包含详细自定义指令的文件路径
- `--include-empty-directories`: 在输出中包含空目录（默认：`false`）
## 过滤选项
- `--include `: 包含模式（逗号分隔）
- `-i, --ignore `: 忽略模式（逗号分隔）
- `--no-gitignore`: 禁用 .gitignore 文件
- `--no-default-patterns`: 禁用默认模式
## 远程仓库选项
- `--remote `: 处理远程仓库
- `--remote-branch `: 指定远程分支名称、标签或提交哈希（默认为仓库的默认分支）
## 配置选项
- `-c, --config `: 自定义配置文件路径
- `--init`: 创建配置文件
- `--global`: 使用全局配置
## 安全选项
- `--no-security-check`: 禁用安全检查（默认：`true`）
## 令牌计数选项
- `--token-count-encoding `: 指定令牌计数编码（如 `o200k_base`、`cl100k_base`）（默认：`o200k_base`）
## 其他选项
- `--top-files-len `: 显示的顶部文件数量（默认：`5`）
- `--verbose`: 启用详细日志
- `--quiet`: 禁止所有标准输出
## 示例
```bash
# 基本用法
repomix
# 自定义输出
repomix -o output.xml --style xml
# 使用压缩的自定义输出
repomix --compress
# 处理特定文件
repomix --include "src/**/*.ts" --ignore "**/*.test.ts"
# 带分支的远程仓库
repomix --remote https://github.com/user/repo/tree/main
# 带提交的远程仓库
repomix --remote https://github.com/user/repo/commit/836abcd7335137228ad77feb28655d85712680f1
# 使用简写的远程仓库
repomix --remote user/repo
```
# 配置
## 快速开始
创建配置文件：
```bash
repomix --init
```
## 配置文件
`repomix.config.json`：
```json
{
"output": {
"filePath": "repomix-output.xml",
"style": "xml",
"parsableStyle": true,
"compress": false,
"headerText": "自定义头部文本",
"instructionFilePath": "repomix-instruction.md",
"fileSummary": true,
"directoryStructure": true,
"removeComments": false,
"removeEmptyLines": false,
"topFilesLength": 5,
"showLineNumbers": false,
"copyToClipboard": false,
"includeEmptyDirectories": false,
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
},
"include": ["**/*"],
"ignore": {
"useGitignore": true,
"useDefaultPatterns": true,
"customPatterns": ["tmp/", "*.log"]
},
"security": {
"enableSecurityCheck": true
}
}
```
## 全局配置
创建全局配置：
```bash
repomix --init --global
```
位置：
- Windows: `%LOCALAPPDATA%\Repomix\repomix.config.json`
- macOS/Linux: `~/.config/repomix/repomix.config.json`
## 忽略模式
优先级：
1. CLI 选项 (`--ignore`)
2. `.repomixignore`
3. `.gitignore` 和 `.git/info/exclude`
4. 默认模式
`.repomixignore` 示例：
```text
# 缓存目录
.cache/
tmp/
# 构建输出
dist/
build/
# 日志
*.log
```
## 默认忽略模式
默认包含的常见模式：
```text
node_modules/**
.git/**
coverage/**
dist/**
```
完整列表：[defaultIgnore.ts](https://github.com/yamadashy/repomix/blob/main/src/config/defaultIgnore.ts)
## 示例
### 代码压缩
当 `output.compress` 设置为 `true` 时，Repomix 将提取基本代码结构，同时移除实现细节。这可以在保持重要的结构信息的同时减少令牌数量。
更多详细信息和示例，请参阅[代码压缩指南](code-compress)。
### Git 集成
`output.git` 配置允许您控制如何基于 Git 历史记录对文件进行排序：
- `sortByChanges`：当设置为 `true` 时，文件将按 Git 更改次数（修改该文件的提交数）进行排序。更改次数较多的文件将出现在输出的底部。这有助于优先处理更活跃开发的文件。默认值：`true`
- `sortByChangesMaxCommits`：计算文件更改次数时要分析的最大提交数。默认值：`100`
配置示例：
```json
{
"output": {
"git": {
"sortByChanges": true,
"sortByChangesMaxCommits": 100
}
}
}
```
### 注释移除
当 `output.removeComments` 设置为 `true` 时，将从支持的文件类型中移除注释，以减少输出大小并专注于核心代码内容。
有关支持的语言和详细示例，请参阅[注释移除指南](comment-removal)。
import path from 'node:path';
import { loadFileConfig, mergeConfigs } from '../../config/configLoad.js';
import {
type RepomixConfigCli,
type RepomixConfigFile,
type RepomixConfigMerged,
type RepomixOutputStyle,
repomixConfigCliSchema,
} from '../../config/configSchema.js';
import { type PackResult, pack } from '../../core/packager.js';
import { rethrowValidationErrorIfZodError } from '../../shared/errorHandle.js';
import { logger } from '../../shared/logger.js';
import { printCompletion, printSecurityCheck, printSummary, printTopFiles } from '../cliPrint.js';
import { Spinner } from '../cliSpinner.js';
import type { CliOptions } from '../types.js';
import { runMigrationAction } from './migrationAction.js';
export interface DefaultActionRunnerResult {
packResult: PackResult;
config: RepomixConfigMerged;
}
export const runDefaultAction = async (
directories: string[],
cwd: string,
cliOptions: CliOptions,
): Promise => {
logger.trace('Loaded CLI options:', cliOptions);
// Run migration before loading config
await runMigrationAction(cwd);
// Load the config file
const fileConfig: RepomixConfigFile = await loadFileConfig(cwd, cliOptions.config ?? null);
logger.trace('Loaded file config:', fileConfig);
// Parse the CLI options into a config
const cliConfig: RepomixConfigCli = buildCliConfig(cliOptions);
logger.trace('CLI config:', cliConfig);
// Merge default, file, and CLI configs
const config: RepomixConfigMerged = mergeConfigs(cwd, fileConfig, cliConfig);
logger.trace('Merged config:', config);
const targetPaths = directories.map((directory) => path.resolve(cwd, directory));
const spinner = new Spinner('Packing files...', cliOptions);
spinner.start();
let packResult: PackResult;
try {
packResult = await pack(targetPaths, config, (message) => {
spinner.update(message);
});
} catch (error) {
spinner.fail('Error during packing');
throw error;
}
spinner.succeed('Packing completed successfully!');
logger.log('');
if (config.output.topFilesLength > 0) {
printTopFiles(packResult.fileCharCounts, packResult.fileTokenCounts, config.output.topFilesLength);
logger.log('');
}
printSecurityCheck(cwd, packResult.suspiciousFilesResults, config);
logger.log('');
printSummary(
packResult.totalFiles,
packResult.totalCharacters,
packResult.totalTokens,
config.output.filePath,
packResult.suspiciousFilesResults,
config,
);
logger.log('');
printCompletion();
return {
packResult,
config,
};
};
/**
* Builds CLI configuration from command-line options.
*
* Note: Due to Commander.js behavior with --no-* flags:
* - When --no-* flags are used (e.g., --no-file-summary), the options explicitly become false
* - When no flag is specified, Commander defaults to true (e.g., options.fileSummary === true)
* - For --no-* flags, we only apply the setting when it's explicitly false to respect config file values
* - This allows the config file to maintain control unless explicitly overridden by CLI
*/
const buildCliConfig = (options: CliOptions): RepomixConfigCli => {
const cliConfig: RepomixConfigCli = {};
if (options.output) {
cliConfig.output = { filePath: options.output };
}
if (options.include) {
cliConfig.include = options.include.split(',');
}
if (options.ignore) {
cliConfig.ignore = { customPatterns: options.ignore.split(',') };
}
// Only apply gitignore setting if explicitly set to false
if (options.gitignore === false) {
cliConfig.ignore = { ...cliConfig.ignore, useGitignore: options.gitignore };
}
// Only apply defaultPatterns setting if explicitly set to false
if (options.defaultPatterns === false) {
cliConfig.ignore = {
...cliConfig.ignore,
useDefaultPatterns: options.defaultPatterns,
};
}
if (options.topFilesLen !== undefined) {
cliConfig.output = {
...cliConfig.output,
topFilesLength: options.topFilesLen,
};
}
if (options.outputShowLineNumbers !== undefined) {
cliConfig.output = {
...cliConfig.output,
showLineNumbers: options.outputShowLineNumbers,
};
}
if (options.copy) {
cliConfig.output = { ...cliConfig.output, copyToClipboard: options.copy };
}
if (options.style) {
cliConfig.output = {
...cliConfig.output,
style: options.style.toLowerCase() as RepomixOutputStyle,
};
}
if (options.parsableStyle !== undefined) {
cliConfig.output = {
...cliConfig.output,
parsableStyle: options.parsableStyle,
};
}
// Only apply securityCheck setting if explicitly set to false
if (options.securityCheck === false) {
cliConfig.security = { enableSecurityCheck: options.securityCheck };
}
// Only apply fileSummary setting if explicitly set to false
if (options.fileSummary === false) {
cliConfig.output = {
...cliConfig.output,
fileSummary: false,
};
}
// Only apply directoryStructure setting if explicitly set to false
if (options.directoryStructure === false) {
cliConfig.output = {
...cliConfig.output,
directoryStructure: false,
};
}
if (options.removeComments !== undefined) {
cliConfig.output = {
...cliConfig.output,
removeComments: options.removeComments,
};
}
if (options.removeEmptyLines !== undefined) {
cliConfig.output = {
...cliConfig.output,
removeEmptyLines: options.removeEmptyLines,
};
}
if (options.headerText !== undefined) {
cliConfig.output = { ...cliConfig.output, headerText: options.headerText };
}
if (options.compress !== undefined) {
cliConfig.output = { ...cliConfig.output, compress: options.compress };
}
if (options.tokenCountEncoding) {
cliConfig.tokenCount = { encoding: options.tokenCountEncoding };
}
if (options.instructionFilePath) {
cliConfig.output = {
...cliConfig.output,
instructionFilePath: options.instructionFilePath,
};
}
if (options.includeEmptyDirectories) {
cliConfig.output = {
...cliConfig.output,
includeEmptyDirectories: options.includeEmptyDirectories,
};
}
// Only apply gitSortByChanges setting if explicitly set to false
if (options.gitSortByChanges === false) {
cliConfig.output = {
...cliConfig.output,
git: {
...cliConfig.output?.git,
sortByChanges: false,
},
};
}
try {
return repomixConfigCliSchema.parse(cliConfig);
} catch (error) {
rethrowValidationErrorIfZodError(error, 'Invalid cli arguments');
throw error;
}
};
import type { OptionValues } from 'commander';
import type { RepomixOutputStyle } from '../config/configSchema.js';
export interface CliOptions extends OptionValues {
// Basic Options
version?: boolean;
// Output Options
output?: string;
style?: RepomixOutputStyle;
parsableStyle?: boolean;
compress?: boolean;
outputShowLineNumbers?: boolean;
copy?: boolean;
fileSummary?: boolean;
directoryStructure?: boolean;
removeComments?: boolean;
removeEmptyLines?: boolean;
headerText?: string;
instructionFilePath?: string;
includeEmptyDirectories?: boolean;
gitSortByChanges?: boolean;
// Filter Options
include?: string;
ignore?: string;
gitignore?: boolean;
defaultPatterns?: boolean;
// Remote Repository Options
remote?: string;
remoteBranch?: string;
// Configuration Options
config?: string;
init?: boolean;
global?: boolean;
// Security Options
securityCheck?: boolean;
// Token Count Options
tokenCountEncoding?: string;
// MCP
mcp?: boolean;
// Other Options
topFilesLen?: number;
verbose?: boolean;
quiet?: boolean;
}
import fs from 'node:fs/promises';
import path from 'node:path';
import { globby } from 'globby';
import { minimatch } from 'minimatch';
import type { RepomixConfigMerged } from '../../config/configSchema.js';
import { defaultIgnoreList } from '../../config/defaultIgnore.js';
import { RepomixError } from '../../shared/errorHandle.js';
import { logger } from '../../shared/logger.js';
import { sortPaths } from './filePathSort.js';
import { PermissionError, checkDirectoryPermissions } from './permissionCheck.js';
export interface FileSearchResult {
filePaths: string[];
emptyDirPaths: string[];
}
const findEmptyDirectories = async (
rootDir: string,
directories: string[],
ignorePatterns: string[],
): Promise => {
const emptyDirs: string[] = [];
for (const dir of directories) {
const fullPath = path.join(rootDir, dir);
try {
const entries = await fs.readdir(fullPath);
const hasVisibleContents = entries.some((entry) => !entry.startsWith('.'));
if (!hasVisibleContents) {
// This checks if the directory itself matches any ignore patterns
const shouldIgnore = ignorePatterns.some((pattern) => minimatch(dir, pattern) || minimatch(`${dir}/`, pattern));
if (!shouldIgnore) {
emptyDirs.push(dir);
}
}
} catch (error) {
logger.debug(`Error checking directory ${dir}:`, error);
}
}
return emptyDirs;
};
// Check if a path is a git worktree reference file
const isGitWorktreeRef = async (gitPath: string): Promise => {
try {
const stats = await fs.stat(gitPath);
if (!stats.isFile()) {
return false;
}
const content = await fs.readFile(gitPath, 'utf8');
return content.startsWith('gitdir:');
} catch {
return false;
}
};
/**
* Escapes special characters in glob patterns to handle paths with parentheses.
* Example: "src/(categories)" -> "src/\\(categories\\)"
*/
export const escapeGlobPattern = (pattern: string): string => {
// First escape backslashes
const escapedBackslashes = pattern.replace(/\\/g, '\\\\');
// Then escape special characters
return escapedBackslashes.replace(/[()[\]{}]/g, '\\$&');
};
// Get all file paths considering the config
export const searchFiles = async (rootDir: string, config: RepomixConfigMerged): Promise => {
// First check directory permissions
const permissionCheck = await checkDirectoryPermissions(rootDir);
if (permissionCheck.details?.read !== true) {
if (permissionCheck.error instanceof PermissionError) {
throw permissionCheck.error;
}
throw new RepomixError(
`Target directory is not readable or does not exist. Please check folder access permissions for your terminal app.\npath: ${rootDir}`,
);
}
const includePatterns =
config.include.length > 0 ? config.include.map((pattern) => escapeGlobPattern(pattern)) : ['**/*'];
try {
const [ignorePatterns, ignoreFilePatterns] = await Promise.all([
getIgnorePatterns(rootDir, config),
getIgnoreFilePatterns(config),
]);
logger.trace('Include patterns:', includePatterns);
logger.trace('Ignore patterns:', ignorePatterns);
logger.trace('Ignore file patterns:', ignoreFilePatterns);
// Check if .git is a worktree reference
const gitPath = path.join(rootDir, '.git');
const isWorktree = await isGitWorktreeRef(gitPath);
// Modify ignore patterns for git worktree
const adjustedIgnorePatterns = [...ignorePatterns];
if (isWorktree) {
// Remove '.git/**' pattern and add '.git' to ignore the reference file
const gitIndex = adjustedIgnorePatterns.indexOf('.git/**');
if (gitIndex !== -1) {
adjustedIgnorePatterns.splice(gitIndex, 1);
adjustedIgnorePatterns.push('.git');
}
}
const filePaths = await globby(includePatterns, {
cwd: rootDir,
ignore: [...adjustedIgnorePatterns],
ignoreFiles: [...ignoreFilePatterns],
onlyFiles: true,
absolute: false,
dot: true,
followSymbolicLinks: false,
}).catch((error) => {
// Handle EPERM errors specifically
if (error.code === 'EPERM' || error.code === 'EACCES') {
throw new PermissionError(
`Permission denied while scanning directory. Please check folder access permissions for your terminal app. path: ${rootDir}`,
rootDir,
);
}
throw error;
});
let emptyDirPaths: string[] = [];
if (config.output.includeEmptyDirectories) {
const directories = await globby(includePatterns, {
cwd: rootDir,
ignore: [...adjustedIgnorePatterns],
ignoreFiles: [...ignoreFilePatterns],
onlyDirectories: true,
absolute: false,
dot: true,
followSymbolicLinks: false,
});
emptyDirPaths = await findEmptyDirectories(rootDir, directories, adjustedIgnorePatterns);
}
logger.trace(`Filtered ${filePaths.length} files`);
return {
filePaths: sortPaths(filePaths),
emptyDirPaths: sortPaths(emptyDirPaths),
};
} catch (error: unknown) {
// Re-throw PermissionError as is
if (error instanceof PermissionError) {
throw error;
}
if (error instanceof Error) {
logger.error('Error filtering files:', error.message);
throw new Error(`Failed to filter files in directory ${rootDir}. Reason: ${error.message}`);
}
logger.error('An unexpected error occurred:', error);
throw new Error('An unexpected error occurred while filtering files.');
}
};
export const parseIgnoreContent = (content: string): string[] => {
if (!content) return [];
return content.split('\n').reduce((acc, line) => {
const trimmedLine = line.trim();
if (trimmedLine && !trimmedLine.startsWith('#')) {
acc.push(trimmedLine);
}
return acc;
}, []);
};
export const getIgnoreFilePatterns = async (config: RepomixConfigMerged): Promise => {
const ignoreFilePatterns: string[] = [];
if (config.ignore.useGitignore) {
ignoreFilePatterns.push('**/.gitignore');
}
ignoreFilePatterns.push('**/.repomixignore');
return ignoreFilePatterns;
};
export const getIgnorePatterns = async (rootDir: string, config: RepomixConfigMerged): Promise => {
const ignorePatterns = new Set();
// Add default ignore patterns
if (config.ignore.useDefaultPatterns) {
logger.trace('Adding default ignore patterns');
for (const pattern of defaultIgnoreList) {
ignorePatterns.add(pattern);
}
}
// Add repomix output file
if (config.output.filePath) {
const absoluteOutputPath = path.resolve(config.cwd, config.output.filePath);
const relativeToTargetPath = path.relative(rootDir, absoluteOutputPath);
logger.trace('Adding output file to ignore patterns:', relativeToTargetPath);
ignorePatterns.add(relativeToTargetPath);
}
// Add custom ignore patterns
if (config.ignore.customPatterns) {
logger.trace('Adding custom ignore patterns:', config.ignore.customPatterns);
for (const pattern of config.ignore.customPatterns) {
ignorePatterns.add(pattern);
}
}
// Add patterns from .git/info/exclude if useGitignore is enabled
if (config.ignore.useGitignore) {
const excludeFilePath = path.join(rootDir, '.git', 'info', 'exclude');
try {
const excludeFileContent = await fs.readFile(excludeFilePath, 'utf8');
const excludePatterns = parseIgnoreContent(excludeFileContent);
for (const pattern of excludePatterns) {
ignorePatterns.add(pattern);
}
} catch (error) {
// File might not exist or might not be accessible, which is fine
logger.trace('Could not read .git/info/exclude file:', error instanceof Error ? error.message : String(error));
}
}
return Array.from(ignorePatterns);
};
import { queryC } from './queries/queryC.js';
import { queryCSharp } from './queries/queryCSharp.js';
import { queryCpp } from './queries/queryCpp.js';
import { queryCss } from './queries/queryCss.js';
import { queryGo } from './queries/queryGo.js';
import { queryJava } from './queries/queryJava.js';
import { queryJavascript } from './queries/queryJavascript.js';
import { queryPhp } from './queries/queryPhp.js';
import { queryPython } from './queries/queryPython.js';
import { queryRuby } from './queries/queryRuby.js';
import { queryRust } from './queries/queryRust.js';
import { querySolidity } from './queries/querySolidity.js';
import { querySwift } from './queries/querySwift.js';
import { queryTypescript } from './queries/queryTypescript.js';
import { queryVue } from './queries/queryVue.js';
export const lang2Query = {
javascript: queryJavascript,
typescript: queryTypescript,
c: queryC,
cpp: queryCpp,
python: queryPython,
rust: queryRust,
go: queryGo,
c_sharp: queryCSharp,
ruby: queryRuby,
java: queryJava,
php: queryPhp,
swift: querySwift,
solidity: querySolidity,
css: queryCss,
vue: queryVue,
};
export type SupportedLang = keyof typeof lang2Query;
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { z } from 'zod';
/**
* Register Repomix-related prompts to the MCP server
*/
export const registerPackRemoteRepositoryPrompt = (mcpServer: McpServer) => {
// Pack Remote Repository Prompt
mcpServer.prompt(
'pack_remote_repository',
'Pack a remote GitHub repository for analysis',
{
repository: z.string().describe('GitHub repository URL or owner/repo format (e.g., "yamadashy/repomix")'),
includePatterns: z
.string()
.optional()
.describe(
'Comma-separated list of glob patterns to include (e.g., "src/**,lib/**"). It is recommended to pack only necessary files.',
),
ignorePatterns: z
.string()
.optional()
.describe(
'Comma-separated list of glob patterns to ignore (e.g., "**/*.test.js,**/*.spec.js"). It is recommended to pack only necessary files.',
),
},
async ({ repository, includePatterns, ignorePatterns }) => {
// Convert compress string to boolean
return {
messages: [
{
role: 'user',
content: {
type: 'text',
text: `Please analyze the GitHub repository at ${repository}.
First, use the pack_remote_repository tool with these parameters:
- repository: "${repository}"
${includePatterns ? `- includePatterns: "${includePatterns}"` : ''}
${ignorePatterns ? `- ignorePatterns: "${ignorePatterns}"` : ''}
Once you have the packed repository:
1. Read the code using the outputId from the tool response
2. Give me a high-level overview of this project
3. Explain its architecture and main components
4. Identify the key technologies and dependencies used
5. Highlight any interesting patterns or design decisions
Please be thorough in your analysis.`,
},
},
],
};
},
);
};
import fs from 'node:fs/promises';
import type { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
import { z } from 'zod';
import { logger } from '../../shared/logger.js';
import { getOutputFilePath } from './mcpToolRuntime.js';
/**
* Register the tool to read Repomix output files
*/
export const registerReadRepomixOutputTool = (mcpServer: McpServer) => {
mcpServer.tool(
'read_repomix_output',
'Read the contents of a Repomix output file in environments where direct file access is not possible. This tool is specifically intended for cases where the client cannot access the file system directly, such as in web-based environments or sandboxed applications. For systems with direct file access, use standard file operations instead.',
{
outputId: z.string().describe('ID of the Repomix output file to read'),
},
async ({ outputId }): Promise => {
try {
logger.trace(`Reading Repomix output with ID: ${outputId}`);
// Get the file path from the registry
const filePath = getOutputFilePath(outputId);
if (!filePath) {
return {
isError: true,
content: [
{
type: 'text',
text: `Error: Output file with ID ${outputId} not found. The output file may have been deleted or the ID is invalid.`,
},
],
};
}
// Check if the file exists
try {
await fs.access(filePath);
} catch (error) {
return {
isError: true,
content: [
{
type: 'text',
text: `Error: Output file does not exist at path: ${filePath}. The temporary file may have been cleaned up.`,
},
],
};
}
// Read the file content
const content = await fs.readFile(filePath, 'utf8');
return {
content: [
{
type: 'resource',
resource: {
text: content,
uri: `file://${filePath}`,
mimeType: 'application/xml',
},
},
],
};
} catch (error) {
logger.error(`Error reading Repomix output: ${error}`);
return {
isError: true,
content: [
{
type: 'text',
text: `Error reading Repomix output: ${error instanceof Error ? error.message : String(error)}`,
},
],
};
}
},
);
};
import type { Stats } from 'node:fs';
import * as fs from 'node:fs/promises';
import path from 'node:path';
import process from 'node:process';
import { globby } from 'globby';
import { minimatch } from 'minimatch';
import { beforeEach, describe, expect, test, vi } from 'vitest';
import {
escapeGlobPattern,
getIgnoreFilePatterns,
getIgnorePatterns,
parseIgnoreContent,
searchFiles,
} from '../../../src/core/file/fileSearch.js';
import { createMockConfig, isWindows } from '../../testing/testUtils.js';
vi.mock('fs/promises');
vi.mock('globby');
describe('fileSearch', () => {
beforeEach(() => {
vi.resetAllMocks();
});
describe('getIgnoreFilePaths', () => {
test('should return correct paths when .gitignore and .repomixignore exist', async () => {
vi.mocked(fs.access).mockResolvedValue(undefined);
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: true,
customPatterns: [],
},
});
const filePatterns = await getIgnoreFilePatterns(mockConfig);
expect(filePatterns).toEqual(['**/.gitignore', '**/.repomixignore']);
});
test('should not include .gitignore when useGitignore is false', async () => {
vi.mocked(fs.access).mockResolvedValue(undefined);
const mockConfig = createMockConfig({
ignore: {
useGitignore: false,
useDefaultPatterns: true,
customPatterns: [],
},
});
const filePatterns = await getIgnoreFilePatterns(mockConfig);
expect(filePatterns).toEqual(['**/.repomixignore']);
});
test('should handle empty directories when enabled', async () => {
const mockConfig = createMockConfig({
output: {
includeEmptyDirectories: true,
},
});
const mockFilePaths = ['src/file1.js', 'src/file2.js'];
const mockEmptyDirs = ['src/empty', 'empty-root'];
vi.mocked(globby).mockImplementation(async (_, options) => {
if (options?.onlyDirectories) {
return mockEmptyDirs;
}
return mockFilePaths;
});
vi.mocked(fs.readdir).mockResolvedValue([]);
const result = await searchFiles('/mock/root', mockConfig);
expect(result.filePaths).toEqual(mockFilePaths);
expect(result.emptyDirPaths.sort()).toEqual(mockEmptyDirs.sort());
});
test('should not collect empty directories when disabled', async () => {
const mockConfig = createMockConfig({
output: {
includeEmptyDirectories: false,
},
});
const mockFilePaths = ['src/file1.js', 'src/file2.js'];
vi.mocked(globby).mockImplementation(async (_, options) => {
if (options?.onlyDirectories) {
throw new Error('Should not search for directories when disabled');
}
return mockFilePaths;
});
const result = await searchFiles('/mock/root', mockConfig);
expect(result.filePaths).toEqual(mockFilePaths);
expect(result.emptyDirPaths).toEqual([]);
expect(globby).toHaveBeenCalledTimes(1);
});
});
describe('getIgnorePatterns', () => {
test('should return default patterns when useDefaultPatterns is true', async () => {
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: true,
customPatterns: [],
},
});
const patterns = await getIgnorePatterns(process.cwd(), mockConfig);
expect(patterns.length).toBeGreaterThan(0);
expect(patterns).toContain('**/node_modules/**');
});
test('should include custom patterns', async () => {
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: false,
customPatterns: ['*.custom', 'temp/'],
},
});
const patterns = await getIgnorePatterns(process.cwd(), mockConfig);
expect(patterns).toEqual(['repomix-output.xml', '*.custom', 'temp/']);
});
test('should combine default and custom patterns', async () => {
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: true,
customPatterns: ['*.custom', 'temp/'],
},
});
const patterns = await getIgnorePatterns(process.cwd(), mockConfig);
expect(patterns).toContain('**/node_modules/**');
expect(patterns).toContain('*.custom');
expect(patterns).toContain('temp/');
});
test('should include patterns from .git/info/exclude when useGitignore is true', async () => {
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: false,
customPatterns: [],
},
});
const mockExcludeContent = `
# Test exclude file
*.ignored
temp-files/
`;
vi.mocked(fs.readFile).mockImplementation(async (filePath) => {
// Use path.join to create platform-specific path for testing
const excludePath = path.join('.git', 'info', 'exclude');
if (filePath.toString().endsWith(excludePath)) {
return mockExcludeContent;
}
return '';
});
const patterns = await getIgnorePatterns('/mock/root', mockConfig);
// Only test for the exclude file patterns
expect(patterns).toContain('*.ignored');
expect(patterns).toContain('temp-files/');
});
});
describe('parseIgnoreContent', () => {
test('should correctly parse ignore content', () => {
const content = `
# Comment
node_modules
*.log
.DS_Store
`;
const patterns = parseIgnoreContent(content);
expect(patterns).toEqual(['node_modules', '*.log', '.DS_Store']);
});
test('should handle mixed line endings', () => {
const content = 'node_modules\n*.log\r\n.DS_Store\r';
const patterns = parseIgnoreContent(content);
expect(patterns).toEqual(['node_modules', '*.log', '.DS_Store']);
});
});
describe('filterFiles', () => {
beforeEach(() => {
vi.resetAllMocks();
});
test('should call globby with correct parameters', async () => {
const mockConfig = createMockConfig({
include: ['**/*.js'],
ignore: {
useGitignore: true,
useDefaultPatterns: false,
customPatterns: ['*.custom'],
},
});
vi.mocked(globby).mockResolvedValue(['file1.js', 'file2.js']);
vi.mocked(fs.access).mockResolvedValue(undefined);
await searchFiles('/mock/root', mockConfig);
expect(globby).toHaveBeenCalledWith(
['**/*.js'],
expect.objectContaining({
cwd: '/mock/root',
ignore: expect.arrayContaining(['*.custom']),
ignoreFiles: expect.arrayContaining(['**/.gitignore', '**/.repomixignore']),
onlyFiles: true,
absolute: false,
dot: true,
followSymbolicLinks: false,
}),
);
});
test.runIf(!isWindows)('Honor .gitignore files in subdirectories', async () => {
const mockConfig = createMockConfig({
include: ['**/*.js'],
ignore: {
useGitignore: true,
useDefaultPatterns: false,
customPatterns: [],
},
});
const mockFileStructure = [
'root/file1.js',
'root/subdir/file2.js',
'root/subdir/ignored.js',
'root/another/file3.js',
];
const mockGitignoreContent = {
'/mock/root/.gitignore': '*.log',
'/mock/root/subdir/.gitignore': 'ignored.js',
};
vi.mocked(globby).mockImplementation(async () => {
// Simulate filtering files based on .gitignore
return mockFileStructure.filter((file) => {
const relativePath = file.replace('root/', '');
const dir = path.dirname(relativePath);
const gitignorePath = path.join('/mock/root', dir, '.gitignore');
const gitignoreContent = mockGitignoreContent[gitignorePath as keyof typeof mockGitignoreContent];
if (gitignoreContent && minimatch(path.basename(file), gitignoreContent)) {
return false;
}
return true;
});
});
vi.mocked(fs.readFile).mockImplementation(async (filePath) => {
return mockGitignoreContent[filePath as keyof typeof mockGitignoreContent] || '';
});
const result = await searchFiles('/mock/root', mockConfig);
expect(result.filePaths).toEqual(['root/another/file3.js', 'root/subdir/file2.js', 'root/file1.js']);
expect(result.filePaths).not.toContain('root/subdir/ignored.js');
expect(result.emptyDirPaths).toEqual([]);
});
test('should not apply .gitignore when useGitignore is false', async () => {
const mockConfig = createMockConfig({
include: ['**/*.js'],
ignore: {
useGitignore: false,
useDefaultPatterns: false,
customPatterns: [],
},
});
const mockFileStructure = [
'root/file1.js',
'root/another/file3.js',
'root/subdir/file2.js',
'root/subdir/ignored.js',
];
vi.mocked(globby).mockResolvedValue(mockFileStructure);
const result = await searchFiles('/mock/root', mockConfig);
expect(result.filePaths).toEqual(mockFileStructure);
expect(result.filePaths).toContain('root/subdir/ignored.js');
expect(result.emptyDirPaths).toEqual([]);
});
test('should handle git worktree correctly', async () => {
// Mock .git file content for worktree
const gitWorktreeContent = 'gitdir: /path/to/main/repo/.git/worktrees/feature-branch';
// Mock fs.stat and fs.readFile for .git file
vi.mocked(fs.stat).mockResolvedValue({
isFile: () => true,
} as Stats);
vi.mocked(fs.readFile).mockResolvedValue(gitWorktreeContent);
// Mock globby to return some test files
vi.mocked(globby).mockResolvedValue(['file1.js', 'file2.js']);
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: true,
customPatterns: [],
},
});
const result = await searchFiles('/test/dir', mockConfig);
// Check that globby was called with correct ignore patterns
const globbyCall = vi.mocked(globby).mock.calls[0];
const ignorePatterns = globbyCall[1]?.ignore as string[];
// Verify .git file (not directory) is in ignore patterns
expect(ignorePatterns).toContain('.git');
// Verify .git/** is not in ignore patterns
expect(ignorePatterns).not.toContain('.git/**');
// Verify the files were returned correctly
expect(result.filePaths).toEqual(['file1.js', 'file2.js']);
});
test('should handle regular git repository correctly', async () => {
// Mock .git as a directory
vi.mocked(fs.stat).mockResolvedValue({
isFile: () => false,
} as Stats);
// Mock globby to return some test files
vi.mocked(globby).mockResolvedValue(['file1.js', 'file2.js']);
const mockConfig = createMockConfig({
ignore: {
useGitignore: true,
useDefaultPatterns: true,
customPatterns: [],
},
});
const result = await searchFiles('/test/dir', mockConfig);
// Check that globby was called with correct ignore patterns
const globbyCall = vi.mocked(globby).mock.calls[0];
const ignorePatterns = globbyCall[1]?.ignore as string[];
// Verify .git/** is in ignore patterns for regular git repos
expect(ignorePatterns).toContain('.git/**');
// Verify just .git is not in ignore patterns
expect(ignorePatterns).not.toContain('.git');
// Verify the files were returned correctly
expect(result.filePaths).toEqual(['file1.js', 'file2.js']);
});
});
describe('escapeGlobPattern', () => {
test('should escape parentheses in pattern', () => {
const pattern = 'src/(categories)/**/*.ts';
expect(escapeGlobPattern(pattern)).toBe('src/\\(categories\\)/**/*.ts');
});
test('should escape multiple types of brackets', () => {
const pattern = 'src/(auth)/[id]/{slug}/**/*.ts';
expect(escapeGlobPattern(pattern)).toBe('src/\\(auth\\)/\\[id\\]/\\{slug\\}/**/*.ts');
});
test('should handle nested brackets', () => {
const pattern = 'src/(auth)/([id])/**/*.ts';
expect(escapeGlobPattern(pattern)).toBe('src/\\(auth\\)/\\(\\[id\\]\\)/**/*.ts');
});
test('should handle empty string', () => {
expect(escapeGlobPattern('')).toBe('');
});
test('should not modify patterns without special characters', () => {
const pattern = 'src/components/**/*.ts';
expect(escapeGlobPattern(pattern)).toBe(pattern);
});
test('should handle multiple occurrences of the same bracket type', () => {
const pattern = 'src/(auth)/(settings)/**/*.ts';
expect(escapeGlobPattern(pattern)).toBe('src/\\(auth\\)/\\(settings\\)/**/*.ts');
});
});
test('should escape backslashes in pattern', () => {
const pattern = 'src\\temp\\(categories)';
expect(escapeGlobPattern(pattern)).toBe('src\\\\temp\\\\\\(categories\\)');
});
test('should handle patterns with already escaped special characters', () => {
const pattern = 'src\\\\(categories)';
expect(escapeGlobPattern(pattern)).toBe('src\\\\\\\\\\(categories\\)');
});
test('should handle patterns with mixed backslashes and special characters', () => {
const pattern = 'src\\temp\\[id]\\{slug}';
expect(escapeGlobPattern(pattern)).toBe('src\\\\temp\\\\\\[id\\]\\\\\\{slug\\}');
});
});
import process from 'node:process';
import { Option, program } from 'commander';
import pc from 'picocolors';
import { getVersion } from '../core/file/packageJsonParse.js';
import { handleError } from '../shared/errorHandle.js';
import { logger, repomixLogLevels } from '../shared/logger.js';
import { runDefaultAction } from './actions/defaultAction.js';
import { runInitAction } from './actions/initAction.js';
import { runMcpAction } from './actions/mcpAction.js';
import { runRemoteAction } from './actions/remoteAction.js';
import { runVersionAction } from './actions/versionAction.js';
import type { CliOptions } from './types.js';
export const run = async () => {
try {
program
.description('Repomix - Pack your repository into a single AI-friendly file')
.argument('[directories...]', 'list of directories to process', ['.'])
// Basic Options
.option('-v, --version', 'show version information')
// Output Options
.option('-o, --output ', 'specify the output file name')
.option('--style ', 'specify the output style (xml, markdown, plain)')
.option('--parsable-style', 'by escaping and formatting, ensure the output is parsable as a document of its type')
.option('--compress', 'perform code compression to reduce token count')
.option('--output-show-line-numbers', 'add line numbers to each line in the output')
.option('--copy', 'copy generated output to system clipboard')
.option('--no-file-summary', 'disable file summary section output')
.option('--no-directory-structure', 'disable directory structure section output')
.option('--remove-comments', 'remove comments')
.option('--remove-empty-lines', 'remove empty lines')
.option('--header-text ', 'specify the header text')
.option('--instruction-file-path ', 'path to a file containing detailed custom instructions')
.option('--include-empty-directories', 'include empty directories in the output')
.option('--no-git-sort-by-changes', 'disable sorting files by git change count')
// Filter Options
.option('--include ', 'list of include patterns (comma-separated)')
.option('-i, --ignore ', 'additional ignore patterns (comma-separated)')
.option('--no-gitignore', 'disable .gitignore file usage')
.option('--no-default-patterns', 'disable default patterns')
// Remote Repository Options
.option('--remote ', 'process a remote Git repository')
.option(
'--remote-branch ',
'specify the remote branch name, tag, or commit hash (defaults to repository default branch)',
)
// Configuration Options
.option('-c, --config ', 'path to a custom config file')
.option('--init', 'initialize a new repomix.config.json file')
.option('--global', 'use global configuration (only applicable with --init)')
// Security Options
.option('--no-security-check', 'disable security check')
// Token Count Options
.option('--token-count-encoding ', 'specify token count encoding (e.g., o200k_base, cl100k_base)')
// MCP
.option('--mcp', 'run as a MCP server')
// Other Options
.option('--top-files-len ', 'specify the number of top files to display', Number.parseInt)
.addOption(new Option('--verbose', 'enable verbose logging for detailed output').conflicts('quiet'))
.addOption(new Option('--quiet', 'disable all output to stdout').conflicts('verbose'))
.action(commanderActionEndpoint);
await program.parseAsync(process.argv);
} catch (error) {
handleError(error);
}
};
const commanderActionEndpoint = async (directories: string[], options: CliOptions = {}) => {
await runCli(directories, process.cwd(), options);
};
export const runCli = async (directories: string[], cwd: string, options: CliOptions) => {
// Set log level based on verbose and quiet flags
if (options.quiet) {
logger.setLogLevel(repomixLogLevels.SILENT);
} else if (options.verbose) {
logger.setLogLevel(repomixLogLevels.DEBUG);
} else {
logger.setLogLevel(repomixLogLevels.INFO);
}
logger.trace('directories:', directories);
logger.trace('cwd:', cwd);
logger.trace('options:', options);
if (options.mcp) {
return await runMcpAction();
}
if (options.version) {
await runVersionAction();
return;
}
const version = await getVersion();
logger.log(pc.dim(`\n📦 Repomix v${version}\n`));
if (options.init) {
await runInitAction(cwd, options.global || false);
return;
}
if (options.remote) {
return await runRemoteAction(options.remote, options);
}
return await runDefaultAction(directories, cwd, options);
};
import path from 'node:path';
import strip from 'strip-comments';
export interface FileManipulator {
removeComments(content: string): string;
removeEmptyLines(content: string): string;
}
const rtrimLines = (content: string): string =>
content
.split('\n')
.map((line) => line.trimEnd())
.join('\n');
class BaseManipulator implements FileManipulator {
removeComments(content: string): string {
return content;
}
removeEmptyLines(content: string): string {
return content
.split('\n')
.filter((line) => line.trim() !== '')
.join('\n');
}
}
class StripCommentsManipulator extends BaseManipulator {
private language: string;
constructor(language: string) {
super();
this.language = language;
}
removeComments(content: string): string {
const result = strip(content, {
language: this.language,
preserveNewlines: true,
});
return rtrimLines(result);
}
}
class CppManipulator extends BaseManipulator {
removeComments(content: string): string {
let result = strip(content, {
language: 'c',
preserveNewlines: true,
});
result = result
.split('\n')
.map((line) => {
const tripleSlashIndex = line.indexOf('///');
if (tripleSlashIndex !== -1) {
return line.substring(0, tripleSlashIndex).trimEnd();
}
return line;
})
.join('\n');
return rtrimLines(result);
}
}
class PythonManipulator extends BaseManipulator {
removeDocStrings(content: string): string {
if (!content) return '';
const lines = content.split('\n');
let result = '';
let buffer = '';
let quoteType: '' | "'" | '"' = '';
let tripleQuotes = 0;
const doubleQuoteRegex = /^\s*(? {
return pairs.some(([start, end]) => hashIndex > start && hashIndex < end);
};
let result = '';
const pairs: [number, number][] = [];
let prevQuote = 0;
while (prevQuote < content.length) {
const openingQuote = content.slice(prevQuote + 1).search(/(? manipulator.removeComments(acc), content);
}
}
const manipulators: Record = {
'.c': new StripCommentsManipulator('c'),
'.h': new StripCommentsManipulator('c'),
'.hpp': new CppManipulator(),
'.cpp': new CppManipulator(),
'.cc': new CppManipulator(),
'.cxx': new CppManipulator(),
'.cs': new StripCommentsManipulator('csharp'),
'.css': new StripCommentsManipulator('css'),
'.dart': new StripCommentsManipulator('c'),
'.go': new StripCommentsManipulator('c'),
'.html': new StripCommentsManipulator('html'),
'.java': new StripCommentsManipulator('java'),
'.js': new StripCommentsManipulator('javascript'),
'.jsx': new StripCommentsManipulator('javascript'),
'.kt': new StripCommentsManipulator('c'),
'.less': new StripCommentsManipulator('less'),
'.php': new StripCommentsManipulator('php'),
'.rb': new StripCommentsManipulator('ruby'),
'.rs': new StripCommentsManipulator('c'),
'.sass': new StripCommentsManipulator('sass'),
'.scss': new StripCommentsManipulator('sass'),
'.sh': new StripCommentsManipulator('perl'),
'.sol': new StripCommentsManipulator('c'),
'.sql': new StripCommentsManipulator('sql'),
'.swift': new StripCommentsManipulator('swift'),
'.ts': new StripCommentsManipulator('javascript'),
'.tsx': new StripCommentsManipulator('javascript'),
'.xml': new StripCommentsManipulator('xml'),
'.yaml': new StripCommentsManipulator('perl'),
'.yml': new StripCommentsManipulator('perl'),
'.py': new PythonManipulator(),
'.vue': new CompositeManipulator(
new StripCommentsManipulator('html'),
new StripCommentsManipulator('css'),
new StripCommentsManipulator('javascript'),
),
'.svelte': new CompositeManipulator(
new StripCommentsManipulator('html'),
new StripCommentsManipulator('css'),
new StripCommentsManipulator('javascript'),
),
};
export const getFileManipulator = (filePath: string): FileManipulator | null => {
const ext = path.extname(filePath);
return manipulators[ext] || null;
};
/**
* @see https://unpkg.com/browse/tree-sitter-wasms@latest/out/
*/
export const ext2Lang = {
vue: 'vue',
cjs: 'javascript',
mjs: 'javascript',
mjsx: 'javascript',
js: 'javascript',
jsx: 'javascript',
ctx: 'typescript',
mts: 'typescript',
mtsx: 'typescript',
ts: 'typescript',
tsx: 'typescript',
h: 'c',
c: 'c',
hpp: 'cpp',
cpp: 'cpp',
py: 'python',
rs: 'rust',
java: 'java',
go: 'go',
cs: 'c_sharp',
rb: 'ruby',
php: 'php',
swift: 'swift',
css: 'css',
sol: 'solidity',
};
import crypto from 'node:crypto';
import fs from 'node:fs/promises';
import os from 'node:os';
import path from 'node:path';
import type { CallToolResult } from '@modelcontextprotocol/sdk/types.js';
import { logger } from '../../shared/logger.js';
// Map to store generated output files
const outputFileRegistry = new Map();
// Register an output file
export const registerOutputFile = (id: string, filePath: string): void => {
outputFileRegistry.set(id, filePath);
};
// Get file path from output ID
export const getOutputFilePath = (id: string): string | undefined => {
return outputFileRegistry.get(id);
};
export interface McpToolMetrics {
totalFiles: number;
totalCharacters: number;
totalTokens: number;
fileCharCounts: Record;
fileTokenCounts: Record;
}
export interface McpToolContext {
directory?: string;
repository?: string;
}
/**
* Creates a temporary directory for MCP tool operations
*/
export const createToolWorkspace = async (): Promise => {
try {
const tmpBaseDir = path.join(os.tmpdir(), 'repomix', 'mcp-outputs');
await fs.mkdir(tmpBaseDir, { recursive: true });
const tempDir = await fs.mkdtemp(`${tmpBaseDir}/`);
return tempDir;
} catch (error) {
const message = error instanceof Error ? error.message : String(error);
throw new Error(`Failed to create temporary directory: ${message}`);
}
};
/**
* Generate a unique output ID
*/
export const generateOutputId = (): string => {
return crypto.randomBytes(8).toString('hex');
};
/**
* Creates a result object with metrics information for MCP tools
*/
export const formatToolResponse = (
context: McpToolContext,
metrics: McpToolMetrics,
outputFilePath: string,
topFilesLen = 5,
): CallToolResult => {
// Generate output ID and register the file
const outputId = generateOutputId();
registerOutputFile(outputId, outputFilePath);
// Get top files by character count
const topFiles = Object.entries(metrics.fileCharCounts)
.map(([filePath, charCount]) => ({
path: filePath,
charCount,
tokenCount: metrics.fileTokenCounts[filePath] || 0,
}))
.sort((a, b) => b.charCount - a.charCount)
.slice(0, topFilesLen);
// Create JSON string with all the metrics information
const jsonResult = JSON.stringify(
{
...(context.directory ? { directory: context.directory } : {}),
...(context.repository ? { repository: context.repository } : {}),
outputFilePath,
outputId,
metrics: {
totalFiles: metrics.totalFiles,
totalCharacters: metrics.totalCharacters,
totalTokens: metrics.totalTokens,
topFiles,
},
},
null,
2,
);
return {
content: [
{
type: 'text',
text: '🎉 Successfully packed codebase!\nPlease review the metrics below and consider adjusting compress/includePatterns/ignorePatterns if the token count is too high and you need to reduce it before reading the file content.',
},
{
type: 'text',
text: jsonResult,
},
{
type: 'text',
text: `For environments with direct file system access, you can read the file directly using path: ${outputFilePath}`,
},
{
type: 'text',
text: `For environments without direct file access (e.g., web browsers or sandboxed apps), use the \`read_repomix_output\` tool with this outputId: ${outputId} to access the packed codebase contents.`,
},
],
};
};
/**
* Creates an error result for MCP tools
*/
export const formatToolError = (error: unknown): CallToolResult => {
logger.error(`Error in MCP tool: ${error instanceof Error ? error.message : String(error)}`);
return {
isError: true,
content: [
{
type: 'text',
text: JSON.stringify(
{
success: false,
error: error instanceof Error ? error.message : String(error),
},
null,
2,
),
},
],
};
};
import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
import { getVersion } from '../core/file/packageJsonParse.js';
import { logger } from '../shared/logger.js';
import { registerPackRemoteRepositoryPrompt } from './prompts/packRemoteRepositoryPrompts.js';
import { registerFileSystemReadDirectoryTool } from './tools/fileSystemReadDirectoryTool.js';
import { registerFileSystemReadFileTool } from './tools/fileSystemReadFileTool.js';
import { registerPackCodebaseTool } from './tools/packCodebaseTool.js';
import { registerPackRemoteRepositoryTool } from './tools/packRemoteRepositoryTool.js';
import { registerReadRepomixOutputTool } from './tools/readRepomixOutputTool.js';
export const createMcpServer = async () => {
const mcpServer = new McpServer({
name: 'repomix-mcp-server',
version: await getVersion(),
});
// Register the prompts
registerPackRemoteRepositoryPrompt(mcpServer);
// Register the tools
registerPackCodebaseTool(mcpServer);
registerPackRemoteRepositoryTool(mcpServer);
registerReadRepomixOutputTool(mcpServer);
registerFileSystemReadFileTool(mcpServer);
registerFileSystemReadDirectoryTool(mcpServer);
return mcpServer;
};
type Dependencies = {
processExit?: (code?: number) => never;
};
const defaultDependencies: Dependencies = {
processExit: process.exit,
};
export const runMcpServer = async (deps: Dependencies = defaultDependencies) => {
const server = await createMcpServer();
const transport = new StdioServerTransport();
const processExit = deps.processExit ?? process.exit;
const handleExit = async () => {
try {
await server.close();
logger.trace('Repomix MCP Server shutdown complete');
processExit(0);
} catch (error) {
logger.error('Error during MCP server shutdown:', error);
processExit(1);
}
};
process.on('SIGINT', handleExit);
process.on('SIGTERM', handleExit);
try {
await server.connect(transport);
logger.trace('Repomix MCP Server running on stdio');
} catch (error) {
logger.error('Failed to start MCP server:', error);
processExit(1);
}
};
# MCP-Server
Repomix unterstützt das [Model Context Protocol (MCP)](https://modelcontextprotocol.io), das es KI-Assistenten ermöglicht, direkt mit Ihrer Codebasis zu interagieren. Wenn Repomix als MCP-Server ausgeführt wird, stellt es Tools bereit, die es KI-Assistenten ermöglichen, lokale oder entfernte Repositories ohne manuelle Dateivorbereitung für die Analyse zu verpacken.
> [!NOTE]
> Dies ist eine experimentelle Funktion, die wir basierend auf Benutzerfeedback und praktischer Nutzung aktiv verbessern werden
## Repomix als MCP-Server ausführen
Um Repomix als MCP-Server auszuführen, verwenden Sie die `--mcp`-Flag:
```bash
repomix --mcp
```
Dadurch wird Repomix im MCP-Server-Modus gestartet und steht KI-Assistenten zur Verfügung, die das Model Context Protocol unterstützen.
## Verfügbare MCP-Tools
Wenn Repomix als MCP-Server ausgeführt wird, stellt es die folgenden Tools bereit:
### pack_codebase
Dieses Tool verpackt ein lokales Code-Verzeichnis in eine konsolidierte Datei für die KI-Analyse.
**Parameter:**
- `directory`: (Erforderlich) Absoluter Pfad zum zu verpackenden Verzeichnis
- `compress`: (Optional, Standard: true) Ob eine intelligente Code-Extraktion durchgeführt werden soll, um die Token-Anzahl zu reduzieren
- `includePatterns`: (Optional) Kommagetrennte Liste von Einschlussmuster
- `ignorePatterns`: (Optional) Kommagetrennte Liste von Ausschlussmuster
**Beispiel:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
Dieses Tool holt, klont und verpackt ein GitHub-Repository in eine konsolidierte Datei für die KI-Analyse.
**Parameter:**
- `remote`: (Erforderlich) GitHub-Repository-URL oder user/repo-Format (z.B. yamadashy/repomix)
- `compress`: (Optional, Standard: true) Ob eine intelligente Code-Extraktion durchgeführt werden soll, um die Token-Anzahl zu reduzieren
- `includePatterns`: (Optional) Kommagetrennte Liste von Einschlussmuster
- `ignorePatterns`: (Optional) Kommagetrennte Liste von Ausschlussmuster
**Beispiel:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### file_system_read_file und file_system_read_directory
Der Repomix MCP-Server bietet zwei Dateisystemwerkzeuge, die es KI-Assistenten ermöglichen, sicher mit dem lokalen Dateisystem zu interagieren:
1. `file_system_read_file`
- Liest Dateiinhalte unter Verwendung absoluter Pfade
- Implementiert Sicherheitsvalidierung mit [Secretlint](https://github.com/secretlint/secretlint)
- Verhindert den Zugriff auf Dateien mit sensiblen Informationen
- Liefert klare Fehlermeldungen für ungültige Pfade und Sicherheitsprobleme
2. `file_system_read_directory`
- Listet Verzeichnisinhalte unter Verwendung absoluter Pfade
- Zeigt Dateien und Verzeichnisse mit klaren Indikatoren (`[FILE]` oder `[DIR]`)
- Bietet sichere Verzeichnisnavigation mit angemessener Fehlerbehandlung
- Validiert Pfade und stellt sicher, dass sie absolut sind
Beide Werkzeuge beinhalten robuste Sicherheitsmaßnahmen:
- Validierung absoluter Pfade zur Verhinderung von Directory Traversal-Angriffen
- Berechtigungsprüfungen zur Gewährleistung angemessener Zugriffsrechte
- Integration mit Secretlint zur Erkennung sensibler Informationen
- Klare Fehlermeldungen für Debugging und Sicherheitsbewusstsein
**Beispiel:**
```typescript
// Datei lesen
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// Verzeichnisinhalt auflisten
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
Diese Werkzeuge sind besonders nützlich, wenn KI-Assistenten:
- Bestimmte Dateien im Codebase analysieren müssen
- Verzeichnisstrukturen navigieren müssen
- Existenz und Zugänglichkeit von Dateien überprüfen müssen
- Sichere Dateisystemoperationen gewährleisten müssen
## MCP-Server konfigurieren
Um Repomix als MCP-Server mit KI-Assistenten wie Claude zu verwenden, müssen Sie die MCP-Einstellungen konfigurieren:
### Für Cline (VS Code-Erweiterung)
Bearbeiten Sie die `cline_mcp_settings.json`-Datei:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### Für Claude Desktop
Bearbeiten Sie die `claude_desktop_config.json`-Datei mit einer ähnlichen Konfiguration wie bei Cline.
## Vorteile der Verwendung von Repomix als MCP-Server
Die Verwendung von Repomix als MCP-Server bietet mehrere Vorteile:
1. **Direkte Integration**: KI-Assistenten können Ihre Codebasis ohne manuelle Dateivorbereitung direkt analysieren.
2. **Effizienter Workflow**: Optimiert den Prozess der Codeanalyse, indem die Notwendigkeit entfällt, Dateien manuell zu generieren und hochzuladen.
3. **Konsistente Ausgabe**: Stellt sicher, dass der KI-Assistent die Codebasis in einem konsistenten, optimierten Format erhält.
4. **Erweiterte Funktionen**: Nutzt alle Funktionen von Repomix wie Code-Komprimierung, Token-Zählung und Sicherheitsprüfungen.
Nach der Konfiguration kann Ihr KI-Assistent die Funktionen von Repomix direkt nutzen, um Codebasen zu analysieren, was Codeanalyse-Workflows effizienter macht.
# Repomix MCP Server Installation Guide
This guide is specifically designed for AI agents like Cline to install and configure the Repomix MCP server for use with LLM applications like Claude Desktop, Cursor, Roo Code, and Cline.
## Overview
Repomix MCP server is a powerful tool that packages local or remote codebases into AI-friendly formats. It allows AI assistants to analyze code efficiently without manual file preparation, optimizing token usage and providing consistent output.
## Prerequisites
Before installation, you need:
1. Node.js 18.0.0 or higher
2. npm (Node Package Manager)
## Installation and Configuration
### Configure MCP Settings
Add the Repomix MCP server configuration to your MCP settings file based on your LLM client:
#### Configuration File Locations
- Cline (VS Code Extension): `~/Library/Application Support/Code/User/globalStorage/saoudrizwan.claude-dev/settings/cline_mcp_settings.json`
- Roo Code (VS Code Extension): `~/Library/Application Support/Code/User/globalStorage/rooveterinaryinc.roo-cline/settings/cline_mcp_settings.json`
- Claude Desktop: `~/Library/Application Support/Claude/claude_desktop_config.json`
- Cursor: `[project root]/.cursor/mcp.json`
Add this configuration to your chosen client's settings file:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
],
"disabled": false,
"autoApprove": []
}
}
}
```
This configuration uses `npx` to run Repomix directly without requiring a global installation.
## Available MCP Tools
Once configured, you'll have access to these Repomix tools:
### 1. pack_codebase
This tool packages a local code directory into a consolidated file for AI analysis.
**Parameters:**
- `directory`: (Required) Absolute path to the directory to pack
- `compress`: (Optional, default: true) Whether to perform intelligent code extraction to reduce token count
- `includePatterns`: (Optional) Comma-separated list of include patterns
- `ignorePatterns`: (Optional) Comma-separated list of ignore patterns
**Example:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### 2. pack_remote_repository
This tool fetches, clones, and packages a GitHub repository into a consolidated file for AI analysis.
**Parameters:**
- `remote`: (Required) GitHub repository URL or user/repo format (e.g., yamadashy/repomix)
- `compress`: (Optional, default: true) Whether to perform intelligent code extraction to reduce token count
- `includePatterns`: (Optional) Comma-separated list of include patterns
- `ignorePatterns`: (Optional) Comma-separated list of ignore patterns
**Example:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### 3. read_repomix_output
This tool reads the contents of a Repomix output file in environments where direct file access is not possible.
**Parameters:**
- `outputId`: (Required) ID of the Repomix output file to read
**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
**Example:**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### 4. file_system_read_file
This tool reads a file using an absolute path with security validation.
**Parameters:**
- `path`: (Required) 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
- Validates absolute paths to prevent directory traversal attacks
**Example:**
```json
{
"path": "/absolute/path/to/file.txt"
}
```
### 5. file_system_read_directory
This tool lists contents of a directory using an absolute path.
**Parameters:**
- `path`: (Required) 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
**Example:**
```json
{
"path": "/absolute/path/to/directory"
}
```
## Verify Installation
To verify the installation is working:
1. Restart your LLM application (Cline, Claude Desktop, etc.)
2. Test the connection by running a simple command like:
```
Please package the local directory /path/to/project for AI analysis using Repomix.
```
or
```
Please fetch and package the GitHub repository yamadashy/repomix for AI analysis.
```
## Usage Examples
Here are some examples of how to use Repomix MCP server with AI assistants:
### Local Codebase Analysis
```
Can you analyze the code in my project at /path/to/project? Please use Repomix to package it first.
```
### Remote Repository Analysis
```
I'd like you to review the code in the GitHub repository username/repo. Please use Repomix to package it first.
```
### Specific File Types Analysis
```
Please package my project at /path/to/project, but only include TypeScript files and markdown documentation.
```
## Troubleshooting
### Common Issues and Solutions
1. **MCP server connection issues**
- Verify the syntax in your MCP settings file is correct
- Ensure you have an active internet connection (needed for npx to fetch the package)
- Check if any other MCP servers are causing conflicts
2. **Packaging failures**
- Verify the specified directory or repository exists
- Check if you have sufficient disk space
- For remote repositories, ensure you have internet connectivity
- Try with simpler parameters first, then add complexity
3. **JSON parsing errors in configuration**
- Make sure your MCP settings file is properly formatted
- Verify all paths use forward slashes, even on Windows
- Check for any missing commas or brackets in the configuration
## Additional Information
For more detailed information, visit the [Repomix official documentation](https://repomix.com). You can also join the [Discord community](https://discord.gg/wNYzTwZFku) for support and questions.
# MCP Server
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.
> [!NOTE]
> This is an experimental feature that we'll be actively improving based on user feedback and real-world usage
## Running Repomix as an MCP Server
To run Repomix as an MCP server, use the `--mcp` flag:
```bash
repomix --mcp
```
This starts Repomix in MCP server mode, making it available for AI assistants that support the Model Context Protocol.
## Available MCP Tools
When running as an MCP server, Repomix provides the following tools:
### pack_codebase
This tool packages a local code directory into a consolidated file for AI analysis.
**Parameters:**
- `directory`: (Required) Absolute path to the directory to pack
- `compress`: (Optional, default: true) Whether to perform intelligent code extraction to reduce token count
- `includePatterns`: (Optional) Comma-separated list of include patterns
- `ignorePatterns`: (Optional) Comma-separated list of ignore patterns
**Example:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
This tool fetches, clones, and packages a GitHub repository into a consolidated file for AI analysis.
**Parameters:**
- `remote`: (Required) GitHub repository URL or user/repo format (e.g., yamadashy/repomix)
- `compress`: (Optional, default: true) Whether to perform intelligent code extraction to reduce token count
- `includePatterns`: (Optional) Comma-separated list of include patterns
- `ignorePatterns`: (Optional) Comma-separated list of ignore patterns
**Example:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### read_repomix_output
This tool reads the contents of a Repomix output file in environments where direct file access is not possible.
**Parameters:**
- `outputId`: (Required) ID of the Repomix output file to read
**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
**Example:**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### file_system_read_file and file_system_read_directory
Repomix's MCP server provides two file system tools that allow AI assistants to safely interact with the local file system:
1. `file_system_read_file`
- Reads file contents using absolute paths
- Implements security validation using [Secretlint](https://github.com/secretlint/secretlint)
- Prevents access to files containing sensitive information
- Returns formatted content with clear error messages for invalid paths or security issues
2. `file_system_read_directory`
- Lists directory contents using absolute paths
- Shows both files and directories with clear indicators (`[FILE]` or `[DIR]`)
- Provides safe directory traversal with proper error handling
- Validates paths and ensures they are absolute
Both tools incorporate robust security measures:
- Absolute path validation to prevent directory traversal attacks
- Permission checks to ensure proper access rights
- Integration with Secretlint for sensitive information detection
- Clear error messaging for better debugging and security awareness
**Example:**
```typescript
// Reading a file
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// Listing directory contents
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
These tools are particularly useful when AI assistants need to:
- Analyze specific files in the codebase
- Navigate directory structures
- Verify file existence and accessibility
- Ensure secure file system operations
## Configuring MCP Servers
To use Repomix as an MCP server with AI assistants like Claude, you need to configure the MCP settings:
### For Cline (VS Code extension)
Edit the `cline_mcp_settings.json` file:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### For Claude Desktop
Edit the `claude_desktop_config.json` file with similar configuration to Cline's config.
## Benefits of Using Repomix as an MCP Server
Using Repomix as an MCP server offers several advantages:
1. **Direct Integration**: AI assistants can directly analyze your codebase without manual file preparation.
2. **Efficient Workflow**: Streamlines the process of code analysis by eliminating the need to manually generate and upload files.
3. **Consistent Output**: Ensures that the AI assistant receives the codebase in a consistent, optimized format.
4. **Advanced Features**: Leverages all of Repomix's features like code compression, token counting, and security checks.
Once configured, your AI assistant can directly use Repomix's capabilities to analyze codebases, making code analysis workflows more efficient.
# Servidor MCP
Repomix es compatible con el [Model Context Protocol (MCP)](https://modelcontextprotocol.io), lo que permite a los asistentes de IA interactuar directamente con tu código. Cuando se ejecuta como servidor MCP, Repomix proporciona herramientas que permiten a los asistentes de IA empaquetar repositorios locales o remotos para su análisis sin necesidad de preparación manual de archivos.
> [!NOTE]
> Esta es una función experimental que mejoraremos activamente según los comentarios de los usuarios y el uso en el mundo real
## Ejecutar Repomix como servidor MCP
Para ejecutar Repomix como servidor MCP, utiliza la opción `--mcp`:
```bash
repomix --mcp
```
Esto inicia Repomix en modo servidor MCP, haciéndolo disponible para asistentes de IA que soporten el Model Context Protocol.
## Herramientas MCP disponibles
Cuando se ejecuta como servidor MCP, Repomix proporciona las siguientes herramientas:
### pack_codebase
Esta herramienta empaqueta un directorio de código local en un archivo consolidado para análisis de IA.
**Parámetros:**
- `directory`: (Requerido) Ruta absoluta al directorio a empaquetar
- `compress`: (Opcional, predeterminado: true) Si se debe realizar extracción inteligente de código para reducir el recuento de tokens
- `includePatterns`: (Opcional) Lista separada por comas de patrones de inclusión
- `ignorePatterns`: (Opcional) Lista separada por comas de patrones de exclusión
**Ejemplo:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
Esta herramienta obtiene, clona y empaqueta un repositorio de GitHub en un archivo consolidado para análisis de IA.
**Parámetros:**
- `remote`: (Requerido) URL del repositorio de GitHub o formato usuario/repo (ej. yamadashy/repomix)
- `compress`: (Opcional, predeterminado: true) Si se debe realizar extracción inteligente de código para reducir el recuento de tokens
- `includePatterns`: (Opcional) Lista separada por comas de patrones de inclusión
- `ignorePatterns`: (Opcional) Lista separada por comas de patrones de exclusión
**Ejemplo:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### read_repomix_output
Esta herramienta lee el contenido de un archivo de salida de Repomix en entornos donde no es posible el acceso directo a archivos.
**Parámetros:**
- `outputId`: (Requerido) ID del archivo de salida de Repomix para leer
**Características:**
- Diseñado específicamente para entornos basados en web o aplicaciones en sandbox
- Recupera el contenido de salidas generadas previamente usando su ID
- Proporciona acceso seguro al código empaquetado sin requerir acceso al sistema de archivos
**Ejemplo:**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### file_system_read_file y file_system_read_directory
El servidor MCP de Repomix proporciona dos herramientas de sistema de archivos que permiten a los asistentes de IA interactuar de manera segura con el sistema de archivos local:
1. `file_system_read_file`
- Lee contenido de archivos usando rutas absolutas
- Implementa validación de seguridad usando [Secretlint](https://github.com/secretlint/secretlint)
- Previene el acceso a archivos que contienen información sensible
- Devuelve mensajes de error claros para rutas inválidas y problemas de seguridad
2. `file_system_read_directory`
- Lista contenidos de directorios usando rutas absolutas
- Muestra archivos y directorios con indicadores claros (`[FILE]` o `[DIR]`)
- Proporciona navegación segura de directorios con manejo apropiado de errores
- Valida rutas y asegura que sean absolutas
Ambas herramientas incorporan medidas de seguridad robustas:
- Validación de rutas absolutas para prevenir ataques de traversal de directorios
- Verificaciones de permisos para asegurar derechos de acceso apropiados
- Integración con Secretlint para detección de información sensible
- Mensajes de error claros para depuración y conciencia de seguridad
**Ejemplo:**
```typescript
// Leer un archivo
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// Listar contenidos de directorio
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
Estas herramientas son particularmente útiles cuando los asistentes de IA necesitan:
- Analizar archivos específicos en el código base
- Navegar estructuras de directorios
- Verificar existencia y accesibilidad de archivos
- Asegurar operaciones seguras del sistema de archivos
## Configuración de servidores MCP
Para usar Repomix como servidor MCP con asistentes de IA como Claude, necesitas configurar los ajustes de MCP:
### Para Cline (extensión de VS Code)
Edita el archivo `cline_mcp_settings.json`:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### Para Claude Desktop
Edita el archivo `claude_desktop_config.json` con una configuración similar a la de Cline.
## Beneficios de usar Repomix como servidor MCP
Usar Repomix como servidor MCP ofrece varias ventajas:
1. **Integración directa**: Los asistentes de IA pueden analizar tu código directamente sin preparación manual de archivos.
2. **Flujo de trabajo eficiente**: Optimiza el proceso de análisis de código eliminando la necesidad de generar y cargar archivos manualmente.
3. **Salida consistente**: Asegura que el asistente de IA reciba el código en un formato consistente y optimizado.
4. **Funciones avanzadas**: Aprovecha todas las características de Repomix como compresión de código, conteo de tokens y verificaciones de seguridad.
Una vez configurado, tu asistente de IA puede usar directamente las capacidades de Repomix para analizar bases de código, haciendo que los flujos de trabajo de análisis de código sean más eficientes.
# MCPサーバー
Repomixは[Model Context Protocol (MCP)](https://modelcontextprotocol.io)をサポートしており、AIアシスタントがコードベースと直接対話できるようになります。MCPサーバーとして実行すると、Repomixはローカルまたはリモートリポジトリを手動でファイル準備することなく、AI分析用にパッケージ化するツールを提供します。
> [!NOTE]
> これは実験的な機能であり、ユーザーのフィードバックと実際の使用状況に基づいて積極的に改善を進めていきます
## RepomixをMCPサーバーとして実行する
RepomixをMCPサーバーとして実行するには、`--mcp`フラグを使用します：
```bash
repomix --mcp
```
これによりRepomixがMCPサーバーモードで起動し、Model Context ProtocolをサポートするAIアシスタントから利用できるようになります。
## 利用可能なMCPツール
MCPサーバーとして実行すると、Repomixは以下のツールを提供します：
### pack_codebase
このツールはローカルのコードディレクトリをAI分析用に単一ファイルにパッケージ化します。
**パラメータ：**
- `directory`: (必須) パッケージ化するディレクトリの絶対パス
- `compress`: (オプション、デフォルト: true) トークン数を削減するためのインテリジェントなコード抽出を実行するかどうか
- `includePatterns`: (オプション) カンマ区切りの包含パターンリスト
- `ignorePatterns`: (オプション) カンマ区切りの除外パターンリスト
**例：**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
このツールはGitHubリポジトリを取得、クローン、パッケージ化してAI分析用の単一ファイルを作成します。
**パラメータ：**
- `remote`: (必須) GitHubリポジトリURLまたはuser/repo形式（例：yamadashy/repomix）
- `compress`: (オプション、デフォルト: true) トークン数を削減するためのインテリジェントなコード抽出を実行するかどうか
- `includePatterns`: (オプション) カンマ区切りの包含パターンリスト
- `ignorePatterns`: (オプション) カンマ区切りの除外パターンリスト
**例：**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### read_repomix_output
このツールは直接ファイルアクセスできない環境でRepomix出力ファイルの内容を読み込みます。
**パラメータ：**
- `outputId`: (必須) 読み込むRepomix出力ファイルのID
**機能：**
- ウェブベース環境やサンドボックスアプリケーション向けに特別に設計
- IDを使用して以前に生成された出力の内容を取得
- ファイルシステムアクセスを必要とせずにパッケージ化されたコードベースへの安全なアクセスを提供
**例：**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### file_system_read_file と file_system_read_directory
RepomixのMCPサーバーは、AIアシスタントがローカルファイルシステムと安全にやり取りするための2つのファイルシステムツールを提供しています：
1. `file_system_read_file`
- 絶対パスを使用してファイルの内容を読み取り
- [Secretlint](https://github.com/secretlint/secretlint)を使用したセキュリティ検証を実装
- 機密情報を含むファイルへのアクセスを防止
- 無効なパスやセキュリティの問題に対する明確なエラーメッセージを返す
2. `file_system_read_directory`
- 絶対パスを使用してディレクトリの内容を一覧表示
- ファイルとディレクトリを明確な指標（`[FILE]`または`[DIR]`）で表示
- 適切なエラー処理による安全なディレクトリ走査を提供
- パスの検証と絶対パスの確認を実施
両ツールは堅牢なセキュリティ対策を組み込んでいます：
- ディレクトリトラバーサル攻撃を防ぐための絶対パス検証
- 適切なアクセス権を確保するための権限チェック
- 機密情報検出のためのSecretlintとの統合
- デバッグとセキュリティ認識のための明確なエラーメッセージ
**例：**
```typescript
// ファイルの読み取り
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// ディレクトリの内容一覧
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
これらのツールは、AIアシスタントが以下のような操作を必要とする場合に特に有用です：
- コードベース内の特定のファイルを分析
- ディレクトリ構造をナビゲート
- ファイルの存在とアクセス可能性を確認
- 安全なファイルシステム操作を確保
## MCPサーバーの設定
RepomixをMCPサーバーとしてClaudeなどのAIアシスタントで使用するには、MCP設定を構成する必要があります：
### Cline（VS Code拡張機能）の場合
`cline_mcp_settings.json`ファイルを編集します：
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### Claude Desktopの場合
`claude_desktop_config.json`ファイルをClineの設定と同様に編集します。
## RepomixをMCPサーバーとして使用する利点
RepomixをMCPサーバーとして使用すると、いくつかの利点があります：
1. **直接統合**: AIアシスタントが手動でファイルを準備することなく、コードベースを直接分析できます。
2. **効率的なワークフロー**: ファイルを手動で生成してアップロードする必要がなくなり、コード分析のプロセスが効率化されます。
3. **一貫した出力**: AIアシスタントが一貫性のある最適化された形式でコードベースを受け取ることができます。
4. **高度な機能**: コード圧縮、トークンカウント、セキュリティチェックなど、Repomixのすべての機能を活用できます。
設定が完了すると、AIアシスタントはRepomixの機能を直接使用してコードベースを分析できるようになり、コード分析ワークフローがより効率的になります。
# MCP 서버
Repomix는 [Model Context Protocol (MCP)](https://modelcontextprotocol.io)를 지원하며, AI 어시스턴트가 코드베이스와 직접 상호작용할 수 있게 해줍니다. MCP 서버로 실행하면 Repomix는 AI 어시스턴트가 수동 파일 준비 없이 로컬 또는 원격 저장소를 분석용으로 패키징할 수 있는 도구를 제공합니다.
> [!NOTE]
> 이것은 실험적인 기능으로, 사용자 피드백과 실제 사용 사례를 바탕으로 지속적으로 개선해 나갈 예정입니다
## Repomix를 MCP 서버로 실행하기
Repomix를 MCP 서버로 실행하려면 `--mcp` 플래그를 사용하세요:
```bash
repomix --mcp
```
이렇게 하면 Repomix가 MCP 서버 모드로 시작되어 Model Context Protocol을 지원하는 AI 어시스턴트에서 사용할 수 있게 됩니다.
## 사용 가능한 MCP 도구
MCP 서버로 실행할 때 Repomix는 다음 도구를 제공합니다:
### pack_codebase
이 도구는 로컬 코드 디렉토리를 AI 분석용 통합 파일로 패키징합니다.
**매개변수:**
- `directory`: (필수) 패키징할 디렉토리의 절대 경로
- `compress`: (선택, 기본값: true) 토큰 수를 줄이기 위해 지능형 코드 추출을 수행할지 여부
- `includePatterns`: (선택) 쉼표로 구분된 포함 패턴 목록
- `ignorePatterns`: (선택) 쉼표로 구분된 제외 패턴 목록
**예시:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
이 도구는 GitHub 저장소를 가져와 클론하고 AI 분석용 통합 파일로 패키징합니다.
**매개변수:**
- `remote`: (필수) GitHub 저장소 URL 또는 사용자/저장소 형식(예: yamadashy/repomix)
- `compress`: (선택, 기본값: true) 토큰 수를 줄이기 위해 지능형 코드 추출을 수행할지 여부
- `includePatterns`: (선택) 쉼표로 구분된 포함 패턴 목록
- `ignorePatterns`: (선택) 쉼표로 구분된 제외 패턴 목록
**예시:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### read_repomix_output
이 도구는 직접 파일 접근이 불가능한 환경에서 Repomix 출력 파일의 내용을 읽습니다.
**매개변수:**
- `outputId`: (필수) 읽을 Repomix 출력 파일의 ID
**기능:**
- 웹 기반 환경이나 샌드박스 애플리케이션을 위해 특별히 설계됨
- ID를 사용하여 이전에 생성된 출력의 내용을 검색
- 파일 시스템 접근 없이 패키징된 코드베이스에 안전하게 접근 제공
**예시:**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### file_system_read_file 및 file_system_read_directory
Repomix의 MCP 서버는 AI 어시스턴트가 로컬 파일 시스템과 안전하게 상호 작용할 수 있는 두 가지 파일 시스템 도구를 제공합니다:
1. `file_system_read_file`
- 절대 경로를 사용하여 파일 내용 읽기
- [Secretlint](https://github.com/secretlint/secretlint)를 사용한 보안 검증 구현
- 민감한 정보가 포함된 파일에 대한 접근 방지
- 잘못된 경로나 보안 문제에 대한 명확한 오류 메시지 반환
2. `file_system_read_directory`
- 절대 경로를 사용하여 디렉토리 내용 나열
- 파일과 디렉토리를 명확한 지표(`[FILE]` 또는 `[DIR]`)로 표시
- 안전한 디렉토리 탐색과 적절한 오류 처리 제공
- 경로 검증 및 절대 경로 확인
두 도구 모두 강력한 보안 조치를 포함하고 있습니다:
- 디렉토리 순회 공격을 방지하기 위한 절대 경로 검증
- 적절한 접근 권한을 보장하기 위한 권한 검사
- 민감한 정보 감지를 위한 Secretlint 통합
- 디버깅과 보안 인식을 위한 명확한 오류 메시지
**예시:**
```typescript
// 파일 읽기
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// 디렉토리 내용 나열
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
이러한 도구는 AI 어시스턴트가 다음과 같은 작업을 수행해야 할 때 특히 유용합니다:
- 코드베이스의 특정 파일 분석
- 디렉토리 구조 탐색
- 파일 존재 여부 및 접근 가능성 확인
- 안전한 파일 시스템 작업 보장
## MCP 서버 구성하기
Claude와 같은 AI 어시스턴트와 함께 Repomix를 MCP 서버로 사용하려면 MCP 설정을 구성해야 합니다:
### Cline(VS Code 확장)의 경우
`cline_mcp_settings.json` 파일을 편집하세요:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### Claude Desktop의 경우
Cline의 구성과 유사하게 `claude_desktop_config.json` 파일을 편집하세요.
## Repomix를 MCP 서버로 사용하는 이점
Repomix를 MCP 서버로 사용하면 여러 이점이 있습니다:
1. **직접 통합**: AI 어시스턴트가 수동 파일 준비 없이 코드베이스를 직접 분석할 수 있습니다.
2. **효율적인 워크플로우**: 파일을 수동으로 생성하고 업로드할 필요가 없어 코드 분석 프로세스가 간소화됩니다.
3. **일관된 출력**: AI 어시스턴트가 일관되고 최적화된 형식으로 코드베이스를 받을 수 있습니다.
4. **고급 기능**: 코드 압축, 토큰 카운팅, 보안 검사와 같은 Repomix의 모든 기능을 활용할 수 있습니다.
구성이 완료되면 AI 어시스턴트가 Repomix의 기능을 직접 사용하여 코드베이스를 분석할 수 있어 코드 분석 워크플로우가 더 효율적이 됩니다.
# Servidor MCP
O Repomix suporta o [Model Context Protocol (MCP)](https://modelcontextprotocol.io), permitindo que assistentes de IA interajam diretamente com sua base de código. Quando executado como um servidor MCP, o Repomix fornece ferramentas que permitem aos assistentes de IA empacotar repositórios locais ou remotos para análise sem necessidade de preparação manual de arquivos.
> [!NOTE]
> Este é um recurso experimental que estaremos melhorando ativamente com base no feedback dos usuários e no uso no mundo real
## Executando o Repomix como um Servidor MCP
Para executar o Repomix como um servidor MCP, use a flag `--mcp`:
```bash
repomix --mcp
```
Isso inicia o Repomix no modo servidor MCP, tornando-o disponível para assistentes de IA que suportam o Model Context Protocol.
## Ferramentas MCP Disponíveis
Quando executado como um servidor MCP, o Repomix fornece as seguintes ferramentas:
### pack_codebase
Esta ferramenta empacota um diretório de código local em um arquivo consolidado para análise de IA.
**Parâmetros:**
- `directory`: (Obrigatório) Caminho absoluto para o diretório a ser empacotado
- `compress`: (Opcional, padrão: true) Se deve realizar extração inteligente de código para reduzir a contagem de tokens
- `includePatterns`: (Opcional) Lista separada por vírgulas de padrões de inclusão
- `ignorePatterns`: (Opcional) Lista separada por vírgulas de padrões de exclusão
**Exemplo:**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
Esta ferramenta busca, clona e empacota um repositório GitHub em um arquivo consolidado para análise de IA.
**Parâmetros:**
- `remote`: (Obrigatório) URL do repositório GitHub ou formato usuário/repo (ex: yamadashy/repomix)
- `compress`: (Opcional, padrão: true) Se deve realizar extração inteligente de código para reduzir a contagem de tokens
- `includePatterns`: (Opcional) Lista separada por vírgulas de padrões de inclusão
- `ignorePatterns`: (Opcional) Lista separada por vírgulas de padrões de exclusão
**Exemplo:**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### read_repomix_output
Esta ferramenta lê o conteúdo de um arquivo de saída do Repomix em ambientes onde o acesso direto a arquivos não é possível.
**Parâmetros:**
- `outputId`: (Obrigatório) ID do arquivo de saída do Repomix a ser lido
**Funcionalidades:**
- Projetado especificamente para ambientes baseados na web ou aplicações em sandbox
- Recupera o conteúdo de saídas geradas anteriormente usando seu ID
- Fornece acesso seguro à base de código empacotada sem requerer acesso ao sistema de arquivos
**Exemplo:**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### file_system_read_file e file_system_read_directory
O servidor MCP do Repomix fornece duas ferramentas de sistema de arquivos que permitem que os assistentes de IA interajam com segurança com o sistema de arquivos local:
1. `file_system_read_file`
- Lê conteúdo de arquivos usando caminhos absolutos
- Implementa validação de segurança usando [Secretlint](https://github.com/secretlint/secretlint)
- Previne acesso a arquivos contendo informações sensíveis
- Retorna mensagens de erro claras para caminhos inválidos e problemas de segurança
2. `file_system_read_directory`
- Lista conteúdos de diretórios usando caminhos absolutos
- Mostra arquivos e diretórios com indicadores claros (`[FILE]` ou `[DIR]`)
- Fornece navegação segura de diretórios com tratamento apropriado de erros
- Valida caminhos e garante que sejam absolutos
Ambas as ferramentas incorporam medidas de segurança robustas:
- Validação de caminhos absolutos para prevenir ataques de travessia de diretórios
- Verificações de permissões para garantir direitos de acesso apropriados
- Integração com Secretlint para detecção de informações sensíveis
- Mensagens de erro claras para depuração e consciência de segurança
**Exemplo:**
```typescript
// Ler um arquivo
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// Listar conteúdo do diretório
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
Essas ferramentas são particularmente úteis quando os assistentes de IA precisam:
- Analisar arquivos específicos no código-base
- Navegar estruturas de diretórios
- Verificar existência e acessibilidade de arquivos
- Garantir operações seguras do sistema de arquivos
## Configurando Servidores MCP
Para usar o Repomix como um servidor MCP com assistentes de IA como o Claude, você precisa configurar as definições do MCP:
### Para o Cline (extensão do VS Code)
Edite o arquivo `cline_mcp_settings.json`:
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### Para o Claude Desktop
Edite o arquivo `claude_desktop_config.json` com uma configuração similar à do Cline.
## Benefícios de Usar o Repomix como um Servidor MCP
Usar o Repomix como um servidor MCP oferece várias vantagens:
1. **Integração Direta**: Assistentes de IA podem analisar sua base de código diretamente sem preparação manual de arquivos.
2. **Fluxo de Trabalho Eficiente**: Otimiza o processo de análise de código eliminando a necessidade de gerar e carregar arquivos manualmente.
3. **Saída Consistente**: Garante que o assistente de IA receba a base de código em um formato consistente e otimizado.
4. **Recursos Avançados**: Aproveita todos os recursos do Repomix como compressão de código, contagem de tokens e verificações de segurança.
Uma vez configurado, seu assistente de IA pode usar diretamente as capacidades do Repomix para analisar bases de código, tornando os fluxos de trabalho de análise de código mais eficientes.
# MCP服务器
Repomix 支持 [Model Context Protocol (MCP)](https://modelcontextprotocol.io)，允许 AI 助手直接与您的代码库交互。当作为 MCP 服务器运行时，Repomix 提供了工具，使 AI 助手能够在无需手动准备文件的情况下打包本地或远程仓库进行分析。
> [!NOTE]
> 这是一个实验性功能，我们将根据用户反馈和实际使用情况积极改进
## 将 Repomix 作为 MCP 服务器运行
要将 Repomix 作为 MCP 服务器运行，请使用 `--mcp` 标志：
```bash
repomix --mcp
```
这会以 MCP 服务器模式启动 Repomix，使其可供支持 Model Context Protocol 的 AI 助手使用。
## 可用的 MCP 工具
当作为 MCP 服务器运行时，Repomix 提供以下工具：
### pack_codebase
此工具将本地代码目录打包成一个用于 AI 分析的整合文件。
**参数：**
- `directory`：（必需）要打包的目录的绝对路径
- `compress`：（可选，默认值：true）是否执行智能代码提取以减少令牌计数
- `includePatterns`：（可选）以逗号分隔的包含模式列表
- `ignorePatterns`：（可选）以逗号分隔的忽略模式列表
**示例：**
```json
{
"directory": "/path/to/your/project",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### pack_remote_repository
此工具获取、克隆并将 GitHub 仓库打包成一个用于 AI 分析的整合文件。
**参数：**
- `remote`：（必需）GitHub 仓库 URL 或用户/仓库格式（例如，yamadashy/repomix）
- `compress`：（可选，默认值：true）是否执行智能代码提取以减少令牌计数
- `includePatterns`：（可选）以逗号分隔的包含模式列表
- `ignorePatterns`：（可选）以逗号分隔的忽略模式列表
**示例：**
```json
{
"remote": "yamadashy/repomix",
"compress": true,
"includePatterns": "src/**/*.ts,**/*.md",
"ignorePatterns": "**/*.log,tmp/"
}
```
### read_repomix_output
此工具在无法直接访问文件的环境中读取Repomix输出文件的内容。
**参数：**
- `outputId`：（必需）要读取的Repomix输出文件的ID
**功能：**
- 专为基于Web的环境或沙箱应用程序设计
- 使用其ID检索先前生成的输出内容
- 无需文件系统访问权限即可安全访问打包的代码库
**示例：**
```json
{
"outputId": "8f7d3b1e2a9c6054"
}
```
### file_system_read_file 和 file_system_read_directory
Repomix的MCP服务器提供了两个文件系统工具，允许AI助手安全地与本地文件系统交互：
1. `file_system_read_file`
- 使用绝对路径读取文件内容
- 使用[Secretlint](https://github.com/secretlint/secretlint)实现安全验证
- 防止访问包含敏感信息的文件
- 对无效路径和安全问题返回清晰的错误消息
2. `file_system_read_directory`
- 使用绝对路径列出目录内容
- 使用清晰的指示符（`[FILE]`或`[DIR]`）显示文件和目录
- 提供安全的目录遍历和适当的错误处理
- 验证路径并确保使用绝对路径
这两个工具都包含了强大的安全措施：
- 绝对路径验证以防止目录遍历攻击
- 权限检查以确保适当的访问权限
- 与Secretlint集成以检测敏感信息
- 清晰的错误消息以便于调试和安全意识
**示例：**
```typescript
// 读取文件
const fileContent = await tools.file_system_read_file({
path: '/absolute/path/to/file.txt'
});
// 列出目录内容
const dirContent = await tools.file_system_read_directory({
path: '/absolute/path/to/directory'
});
```
这些工具在AI助手需要执行以下操作时特别有用：
- 分析代码库中的特定文件
- 导航目录结构
- 验证文件存在性和可访问性
- 确保安全的文件系统操作
## 配置 MCP 服务器
要将 Repomix 作为 MCP 服务器与 Claude 等 AI 助手一起使用，您需要配置 MCP 设置：
### 对于 Cline（VS Code 扩展）
编辑 `cline_mcp_settings.json` 文件：
```json
{
"mcpServers": {
"repomix": {
"command": "npx",
"args": [
"-y",
"repomix",
"--mcp"
]
}
}
}
```
### 对于 Claude Desktop
使用与 Cline 类似的配置编辑 `claude_desktop_config.json` 文件。
## 将 Repomix 作为 MCP 服务器使用的好处
将 Repomix 作为 MCP 服务器使用提供了几个优势：
1. **直接集成**：AI 助手可以直接分析您的代码库，无需手动文件准备。
2. **高效工作流**：通过消除手动生成和上传文件的需求，简化了代码分析过程。
3. **一致输出**：确保 AI 助手以一致、优化的格式接收代码库。
4. **高级功能**：利用 Repomix 的所有功能，如代码压缩、令牌计数和安全检查。
配置完成后，您的 AI 助手可以直接使用 Repomix 的功能来分析代码库，使代码分析工作流更加高效。
{{ errorMessage }}
Selected: {{ selectedFolder }}
Drop your folder here or click to browse (max 10MB)
Need discussion? Join us on Discord! Share your experience and tips Stay updated on new features Get help with configuration and usage
[](https://github.com/yamadashy/repomix/actions?query=workflow%3A"ci")
[](https://www.npmjs.com/package/repomix)
[](https://www.npmjs.com/package/repomix)
[](https://github.com/yamadashy/repomix/blob/main/LICENSE)
[](https://www.npmjs.com/package/repomix)
[](https://codecov.io/github/yamadashy/repomix)
📦 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.
## 🎉 New: Repomix Website & Discord Community!
- Try Repomix in your browser at [repomix.com](https://repomix.com/)
- Join our [Discord Server](https://discord.gg/wNYzTwZFku) 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` files and `.git/info/exclude`.
- **Security-Focused**: Incorporates [Secretlint](https://github.com/secretlint/secretlint) for robust security checks to detect and prevent inclusion of sensitive information.
- **Code Compression**: The `--compress` option uses [Tree-sitter](https://github.com/tree-sitter/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:
```bash
npx repomix
```
Or install globally for repeated use:
```bash
# Install using npm
npm install -g repomix
# Alternatively using yarn
yarn global add 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](https://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 VSCode Extension ⚡️
A community-maintained VSCode extension 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](https://marketplace.visualstudio.com/items?itemName=DorianMassoulier.repomix-runner)!
Source code is available on [GitHub](https://github.com/massdo/repomix-runner).
### 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:
```bash
repomix
```
To pack a specific directory:
```bash
repomix path/to/directory
```
To pack specific files or directories
using [glob patterns](https://github.com/mrmlnc/fast-glob?tab=readme-ov-file#pattern-syntax):
```bash
repomix --include "src/**/*.ts,**/*.md"
```
To exclude specific files or directories:
```bash
repomix --ignore "**/*.log,tmp/"
```
To pack a remote repository:
```bash
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 compress the output:
```bash
repomix --compress
# You can also use it with remote repositories:
repomix --remote yamadashy/repomix --compress
```
To initialize a new configuration file (`repomix.config.json`):
```bash
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):
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix
```
To pack a specific directory:
```bash
docker run -v .:/app -it --rm ghcr.io/yamadashy/repomix path/to/directory
```
Process a remote repository and output to a `output` directory:
```bash
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](https://github.com/yamadashy/repomix/discussions/154) 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:
```xml
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`)
```
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:
```bash
repomix --style markdown
```
The Markdown format structures the content in a hierarchical manner:
````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
```
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.
#### Plain Text Format
To generate output in plain text format, use the `--style plain` option:
```bash
repomix --style plain
```
```text
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 tool version
#### Output Options
- `-o, --output `: Specify the output file name
- `--style
