contextshrinker

contextshrinker ist ein in Go geschriebener, headless MCP-Server (Model Context Protocol) ohne externe Abhängigkeiten. Er indiziert lokale Codebasen in eine eingebettete Kùzu-Graphdatenbank, um die Token-Aufblähung für LLMs bei autonomen KI-Agenten (wie Claude Code, Cursor, Antigravity IDE, Aider und Claude Desktop) drastisch zu reduzieren.

Statt KI-Agenten zu zwingen, rohe Quelldateien zu lesen oder unhandliche grep-basierte Suchen auszuführen, erlaubt contextshrinker den Agenten, einen semantischen Graphen der architektonischen Abhängigkeiten, Funktionsaufrufketten und Klassenvererbungsstrukturen Ihres Projekts abzufragen – und reduziert den Eingabekontext-Verbrauch um 90 % bis 98 %.

🚀 Hauptfunktionen

• Universelle Agent-Kompatibilität: Integration in jedes MCP-konforme Coding-Tool oder jede IDE über Standard-/E/A (stdio).

• Keine externen Datenbanken: Völlig autark. Eine prozessintegrierte Graphdatenbank (Kùzu) läuft im lokalen .contextshrinker/-Verzeichnis Ihres Projekts.

• Automatisch verwaltete LSP-Daemons: Erkennt Projektsprachen, stellt fehlende Sandbox-Sprachserver programmatisch bereit (z. B. gopls für Go oder pyright für Python) und fragt deren RPC-Schnittstellen im Hintergrund ab, um Aufrufgraphen zu erstellen.

• Mehrsprachige Unterstützung: Vollständiges AST-Syntax-Parsing und semantische Indizierung für Go, Python, JavaScript, TypeScript und Java.

• Saubere Projektisolation: Jeder Workspace verwaltet ein eigenes .contextshrinker/-Verzeichnis mit isolierten Konfigurationsregeln (.contextshrinker/ignore) und Graphdatenbank-Dateien (.contextshrinker/db/).

• Live-State-Sync: Setzt auf fsnotify, um Ihre Dateien rekursiv zu beobachten. Beim Speichern entfernt ein debounced Delta-Update alte Knoten und indiziert geänderte Dateien in Echtzeit.

• Interaktive Graphenvisualisierung: Erzeugt bei Bedarf eine beeindruckende, Vis.js-basierte HTML-Darstellung der Codebase im Dark Mode (.contextshrinker/contextshrinker_graph.html).

Related MCP server: code-graph-mcp

🛠️ Architektur: Der Zwei-Phasen-Ingest

Um Ihren Code sauber zu indexieren, führt contextshrinker den Ingest in zwei Durchläufen durch:

graph TD
    A[Walk Workspace] -->|Filter via .contextshrinker/ignore| B[Pass 1: Tree-sitter Syntax]
    B -->|Create Nodes| C[(Kùzu Graph DB)]
    C --> D[Pass 2: LSP Semantic Cross-References]
    D -->|Create CALLS / IMPLEMENTS Edges| C

1. Durchgang 1 (Tree-sitter-AST-Extraktion): Scannt Quelldateien schnell und extrahiert Entitäten (Funktionen/Methoden, Klassen/Strukturen, Variablen) samt zugehöriger Docstrings; diese werden als Knoten eingefügt.

2. Durchgang 2 (LSP-semantische Auflösung): Fragt Hintergrund-Daemons des Language Server Protocol (LSP) nach Kreuzreferenzen ab, um Aufrufe (CALLS), Importe (IMPORTS) und Klassenvererbungen (IMPLEMENTS / EXTENDS) zu identifizieren und zu verbinden.

📥 Installation

Option 1: Vorkompilierte Binaries (am schnellsten)

Wenn Sie Go nicht installieren möchten, können Sie eine vorkompilierte Paket / portable binaries für Ihre Plattform herunterladen:

1. Gehen Sie auf der Seite Releases.

2. Laden Sie dort das Archiv für Ihr Betriebsssystemif vorhanden herunter (.tar.gz oder .zip).

3. Entpacken Sie das Archiv. Behalten Sie die ausführbare Datei (contextshrinker) und ihre dynamische Bibliothek (libkuzu / kuzu_shared) nebeneinander im selben Ordner.

4. Führen Sie die ausführbare Datei aus diesem Verzeichnis aus:

macOS / Linux:

chmod +x contextshrinker
./contextshrinker --help

Windows:

contextshrinker.exe --help

Option 2: Aus dem Quellcode bauen (Go erforderlich)

Voraussetzungen

• Go (1.21 oder neuer)

• Node.js & npm (für die automatische Installation von JS/TS- und Python-LSPs)

Kompilieren

Klonen Sie das Repository und führen Sie aus:

go build -o contextshrinker

Für die direkte Installation in Ihren System-PATH:

go install

🔌 Integration in Coding-Agenten

contextshrinker läuft auf Abruf als Kindprozess Ihres Coding-Agenten. Registrieren Sie den absoluten Pfad zur kompilierten Binärdatei in Ihrem Client:

1. Antigravity IDE (Gemini-Agent-Panel)

1. Öffnen Sie die Antigravity IDE.

2. Klicken Sie im Agent-Panel auf das Menü ... (Weitere Optionen).

3. Wählen Sie „Manage MCP Servers“ $\rightarrow$ „View raw config“.

4. Registrieren Sie den Server in Ihrer mcp_config.json:

   {
     "mcpServers": {
       "contextshrinker": {
         "command": "/absolute/path/to/contextshrinker"
       }
     }
   }

2. Claude Code (CLI)

Fügen Sie den Server automatisch hinzu:

claude mcp add contextshrinker /absolute/path/to/contextshrinker

3. Cursor IDE

1. Gehen Sie zu Settings $\rightarrow$ Features $\rightarrow$ MCP.

2. Klicken Sie auf + Add New MCP Server.

3. Konfiguration setzen:

   • Name: contextshrinker

   • Type: command

   • Command: /absolute/path/to/contextshrinker

4. Claude Desktop

Fügen Sie es in Ihre ~/Library/Application Support/Claude/claude_desktop_config.json ein:

{
  "mcpServers": {
    "contextshrinker": {
      "command": "/absolute/path/to/contextshrinker"
    }
  }
}

🧰 Bereitgestellte Tools

Nach der Konfiguration stehen Ihren KI-Coding-Agenten automatisch die folgenden Werkzeuge zur Verfügung:

1. search_codebase

   • Argumente: query (Zeichenkette)

   • Beschreibung: Führt Volltextsuche und Cypher-Abfragen aus, um passende Strukturen (ut Docstrings) bei Klassen, Funktionen and Variablen zu finden.

2. get_call_chain

   • Argumente: target_function (Zeichenkette), depth (Ganzzahl, max. 5)

   • Beschreibung: Löst vorgelagerte Aufruferketten mittels Cypher-Pfadabfragen variabler Länge auf, um Aufrufabhängigkeiten abzubilden.

3. get_file_structure

   • Argumente: file_path (Zeichenkette)

   • Beschreibung: Ruft die vollständige abstrakte Knotenstruktur (Klassen, Interfaces, Methoden, Variablen) einer einzelnen Datei ab, ohne die rohen Textinhalte ins Kontextfenster zu laden.

4. visualize_codebase

   • Beschreibung: Triggert einen HTML-Export auf Abruf und speichert contextshrinker_graph.html in Ihrem .contextshrinker/-Verzeichnis.

5. get_architecture_report

   • Beschreibung: Ruft den vollständigen Codebase-Architektur-Gesundheitsbericht ab – inklusive Metriken zu God Objects, Kopplungs-Hotspots, Zyklen, toten unexportierten Funktionen, KI-Metriken (SCR, DCR, BVI, AOI, Call Chain Depth Index – CDI) sowie umsetzbaren Code-Qualitätsrichtlinien (Jeff-Dean-Prinzipien) mit Systemangaben für KI-Prompt-Anweisungen. Systempotenzial.

🏛️ Codebase- und Architektur-Optimierung

Sie können mit contextshrinker die Kopplung systematisch prüfen, Domänengrenzen (DDD) analysieren lassen und die Umstrukturierung des Codes (z. B. Aufteilung eines Monolithen in Module) mithilfe von LLMs steuern.

Optimierungs-Workflow

1. Metriken und Richtlinien generieren: Führen Sie den Analysebefehl in Ihrem Terminal aus, um den Codebase-Graphen zu inspizieren und einen Report zu erzeugen:

   ./contextshrinker analyze

   Das erzeugt contextshrinker-report.md mit Metriken für God Objects (hohe ausgehende Kopplung), Black Holes (viele eingehende Aufrufe), zyklische Import-Pfade, verzeichnet wî Dead Code (unbenutzte private Funktionen), KI-Metriken (einschließlich Call Chain Depth Index – CDI) und handlungsorientierte Code-Qualitäts- sowie LLM-Architektur-Richtlinien (Jeff-The 먼–). (Jeff-Dean-Prinzipien)

2. System-Prompt abrufen: Rufen Sie den Principal-Systems-Architect- Systemprompt über die CLI ab:

   ./contextshrinker prompt architect

3. Analyse mit LLMs:

   • Setzen Sie die Ausgabe des Befehls prompt architect als System-Prompt für Ihr LLM ein.

   • Geben Sie den Inhalt der generierten contextshrinker-report.md als Kontext / Input an.

   • Bitten Sie das LLM, Vorschläge für Bounded-Context-Abgrenzungen oder Interface-Grenzen zu machen.

4. Mit agentic / Tool-Use Workflows: Falls Sie einen MCP-kompatiblen Agenten verwenden (z. B. Antigravity IDE, Claude Code oder Cursor), können Sie ihn direkt beauftragen:

   "Führen Sie den contextshrinker-Analysebericht aus, lesen Sie das generierte Markdown und handeln Sie als Systems Architect für ein Prüfen unserer Design-Hotspots. Setz Sie die Tools get_call_chain und get_file_structure ein, um die Kopplung zu prüfen, bevor Sie konkrete Modulextraktionen vorschlagen."

⚙️ Konfiguration & .csignore

Um Graph-Aufblähung im Workspace zu vermeiden, werden Standardbibliotheks- und Abhängigkeitsordner (wie node_modules/, vedor/, .git/ etc.) standardmäßig ausgelassen.

Fügen Sie zusätzliche, benutzerdefinierte Ignore-Regeln hinzu, indem Sie das Projekt initialisieren und eine .csignore-Datei an Ihrer Workspace-Wurzel erzeugen:

contextshrinker init

Jede Zeile in .csignore wird rekursiviert mit dem Verzeichnis abgeglichen:

# Custom project ignores
*.log
tmp-output/
dist/
.vitepress

💡 Best-Practices für große Projekte

Wenn Sie contextshrinker in einem mittleren bis großen Projekt (z. B. einige hundert bzw. sehr tausend Dateien) einsetzen, kann die initiale Erfassung der Codebase direkt aus einem LLM-/Agenten-Prompt (wie Claude Code oder Cursor) zu Timeout-Problemen führen. Das passiert, weil Amazenda der Agenten ein enges Zeitlimit (typischerweise 60 Sekunden) hat, während er auf die Erstverarbeitung des Workspace und die Auflösung der LSP-Referenzen wartet.

Und damit das nicht passiert:

1. Workspace initialisieren: Führen Sie den Initialisierungsbefehl aus, um das Konfigurationsverzeichnis und die Standard-Ignoreliste zu erstellen:

   contextshrinker init

2. Ignorierregeln konfigurieren: Öffnen Sie die generierte .csignore-Datei am Workspace-Root und ergänzen Sie große Verzeichnisse, die ausgeschlossen werden sollen (z. B. Dokumentationssites, Test-Assets, Build-Ordner).

3. Datenbank offline aufbauen: Um den initialen Graphen zu erst, führen Sie den Den Analyse-Befehl einmal im Terminal aus:

   contextshrinker analyze

   Das übernimmt das schwere Lifting (verbunden mit Parsevorg. des Tree-sitter-Parsing und der LSP-Semantikvernetzung) bereits offline. Sobald die Datenbank befüllt ist, laufen spätere Agentenplauder und Live-Syncs nur in Sekunden(s) inkrementell ab – damit sind künftige Timeouts vermieden!

📊 Kommandozeilenschnitttypen-Modus (CLI)

Sie können den Codebase-Graphen abfragen, das MCP-Server Daemon explizit starten, Systems-Architekt-Prompt abrufen oder auch ganz direkt Health-/Analyse-Reports aus dem Terminal Ihre erzeugen.

1. MCP-Server starten

Standardmäßig startet – ./contextshrinker mit ohne Argumente Ausführungen des MCP-Daemon. Optional auch explizit:

./contextshrinker start

2. Architectural-Analyse ausführen

Analysieren Sie die Codebase-Struktur (God Objects, eingehende Call-Hotspots, cycImport-Zyklen, Dead Code, Call Chain Depth Index–= CDI und LLM-Code-Qualitätsrichtlinien) und schreiben Sie ¿/ einen Report nach contextshrinker-report.md:

./contextshrinker analyze

3. Principal-Systems-Architect-Prompt ausgeben

Geben Sie den Prompt des Principal Systems Architect für Domain-Driven Design (DDD) auf stdout:

./contextshrinker prompt architect

4. Codebase durchsuchen

Finden Sie Funktionen, Klassen und Variablen zu einer Suchabfrage:

./contextshrinker search "IngestWorkspace"

5. Aufrufketten nachzeichnen

Verfolgen Sie Upstream-Callers einer Ziel und Funktion (Standardtiefe ist 3, Maximum 5):

./contextshrinker call-chain "IngestWorkspace" --depth 3

6. Dateistruktur abrufen

Holen Sie die Struktur einer Datei, ohne den Inhalt komplett textuell zu lesen:

./contextshrinker structure "main.go"

7. Interaktive Visualisierung erzeugen

Erstellen Sie eine Vis.js-basierte Graphen-Repräsentation der Codebase:

./contextshrinker visualize

Öffnen Sie danach die erzeugte .contextshrinker/contextshrinker_graph.html in einem Browser, um die Architektur Ihres Projekts interaktiv zu erkunden.

Gültige Optionen (globale Flags)

• --workspace <path>: Gibt das Projektverzeichnis an (Standard: .).

• --db <path>: Dient für das Datenbank-Speicherverzeichnis (Standard: .contextshrinker/db).

• --reindex: Erzwingt eine vollständige Workspace-Erfassung (Erneues Parsen von Quellcode + Mapping der LSP-Beziehungen), bevor die Abfrage ausgeführt wird. Ist die Datenbank leer, läuft der Ingest automatisch ab.

• Hinweis: Weil Kuzu DB eine exklusive Sperre auf Dateiebene einrichtet das exclusive nicht-file-lock-Verfahren, müssen Sie beim Verwendung des CLI auf der aktiven Datenbank unbedingt sind MCP-Client Ihrer IDE pausieren/die gestoppte Stummit intakt zu ehemaligen Dauer – oder nützen Sie im Zweifel ein anderes als DB-Verzeichnis über die CLI-Flagge.

📄 Lizenz

Dieses Projekt wird unter der MIT-Lizenz lizenziert.

contextshrinker

contextshrinker ist ein in Go geschriebener, headless MCP-Server (Model Context Protocol) ohne externe Abhängigkeiten. Er indiziert lokale Codebasen in eine eingebettete Kùzu-Graphdatenbank, um die Token-Last für LLMs bei autonomen KI-Agenten (wie Claude Code, Cursor, Antigravity IDE, Aider und Claude Desktop) drastisch zu reduzieren.

Statt KI-Agenten zu zwingen, rohe Quelldateien zu lesen oder unbeholfene grep-basierte Suchen auszuführen, erlaubt contextshrinker Agenten, einen semantischen Graphen der architektonischen Abhängigkeiten, Aufrufketten und Klassenvererbungsstrukturen Ihres Projekts abzufragen – und reduziert den Eingabekontext-Verbrauch um 90 bis 98 Prozent.

🚀 Hauptfunktionen

• Universelle Agent-Kompatibilität: Fügt sich nahtlos in jedes MCP-konforme Coding-Tool oder jede IDE über Standard-stdio ein.

• Keine externen Datenbanken: Völlig autark. Eine prozessintegrierte Graphdatenbank (Kùzu) läuft im lokalen .contextshrinker/-Verzeichnis Ihres Projekts.

• Automatisch verwaltete LSP-Daemons: Erkennt Projektsprachen, stellt fehlende Sandbox-Sprachserver (z. B. gopls für Go oder pyright für Python) automatisch per Skript bereit und fragt deren RPC-Schnittstellen im Hintergrund ab, um Aufrufgraphen zu erzeugen.

• Multi-Language-Support: Vollständiges AST-Syntax-Parsing und semantische Indizierung für Go, Python, JavaScript, TypeScript und Java.

• Klare Projekt-Isolation: Jeder Workspace führt sein eigenes .contextshrinker/-Verzeichnis mit isolierten Regeln (.contextshrinker/ignore) und Graphdatenbank-Dateien (.contextshrinker/db/).

• Live-State-Sync: Setzt auf fsnotify, um Dateien rekursiv zu überwachen. Beim Speichern entfernt ein debounced Delta-Update abgelaufene Nodes und re-indexiert geänderte Dateien in Echtzeit.

• Interaktive Graph-Visualisierung: Erzeugt auf Abruf eine ansprechende, Vis.js-basierte HTML-Darstellung der Codebase im Dark Mode (.contextshrinker/contextshrinker_graph.html).

🛠️ Architektur: Der Zwei-Pass-Ingest

Zur sauberen Indexierung Ihres Codes führt contextshrinker eine Aufnahme in zwei Durchläufen durch:

graph TD
    A[Walk Workspace] -->|Filter via .contextshrinker/ignore| B[Pass 1: Tree-sitter Syntax]
    B -->|Create Nodes| C[(Kùzu Graph DB)]
    C --> D[Pass 2: LSP Semantic Cross-References]
    D -->|Create CALLS / IMPLEMENTS Edges| C

1. Pass 1 (Tree-sitter-AST-Extraktion): Scannt Quelldateien schnell und extrahiert Entitäten (Funktionen/Methoden, Klassen/Strukturen, Variablen) und ihre Docstrings; diese werden als Knoten eingefügt.

2. Pass 2 (LSP-semantische Auflösung): Fragt Hintergrunddaemons des Language Server Protocol (LSP) nach Kreuzreferenzen ab, um Aufrufe (CALLS), Importe (IMPORTS) und Klassenvererbungen (IMPLEMENTS / EXTENDS) zu identifizieren und Verbindungen herzustellen.

📥 Installation

Option 1: Vorkompilierte Binaries (am schnellsten)

Falls Sie kein Go installieren ud, laden Sie einfach ein vorkompiliertes portables Paket für Ihre Plattform herunter:

1. Gehen Sie zur Seite Releases.

2. Laden Sie das Archiv für Ihr OS herunter (.tar.gz oder .zip).

3. Entpacken Sie das Archiv. Behalten Sie die ausführbare Datei (contextshrinker) und die dynamische Bibliothek (libkuzu / kuzu_shared) im selben Ordner.

4. Führen Sie die ausführbare Note script von diesem Verzeichnis aus aus:

macOS / Linux:

chmod +x contextshrinker
./contextshrinker --help

Windows:

contextshrinker.exe --help

Option 2: Aus Quelltext bauen (Go erforderlich)

Voraussetzungen

• Go (1.21 oder neuer)

• Node.js & npm (für die automatische Installation der JS/TS- und Python-LSPs)

Kompilieren

Repository klonen und ausführen:

go build -o contextshrinker

Zur direkten Installation in Ihrem System-PATH:

go install

🔌 Integration in Coding-Agenten

contextshrinker wird bei Bedarf als Kindprozess Ihres Coding-Agenten gestartet. Registrieren Sie den absoluten Pfad der kompilierten Binaries in Ihrem Client:

1. Antigravity IDE (Gemini-Agent Panel)

1. Öffnen Sie die Antigravity IDE.

2. Klicken Sie auf das ... Menü (Weitere Optionen) im Agent Panel.

3. Wählen Sie "Manage MCP Servers" $\rightarrow$ "View raw config".

4. Registrieren Sie den Server in Ihrem mcp_config.json:

   {
     "mcpServers": {
       "contextshrinker": {
         "command": "/absolute/path/to/contextshrinker"
       }
     }
   }

2. Claude Code (CLI)

Server automatisch hinzufügen:

claude mcp add contextshrinker /absolute/path/to/contextshrinker

3. Cursor IDE

1. Gehen Sie zu Settings $\rightarrow$ Features $\rightarrow$ MCP.

2. Klicken Sie auf + Add New MCP Server.

3. Konfiguration setzen:

   • Name: contextshrinker

   • Type: command

   • Command: /absolute/path/to/contextshrinker

4. Claude Desktop

Fügen Sie diese Zeile zu Ihrer ~/Library/Application Support/Claude/claude_desktop_config.json hinzu:

{
  "mcpServers": {
    "contextshrinker": {
      "command": "/absolute/path/to/contextshrinker"
    }
  }
}

🧲 Bereitgestellte Werkzeuge

So konfiguriert stehen Ihren KI-Coding-Agenten automatisch diese Werkzeuge zur Verfügung:

1. search_codebase

   • Argumente: query (string)

   • Beschreibung: Führt Volltextsuche und Cypher-Queries durch, um übereinstimmende Struks und Docstrings bei Klassen, Funktionen und Variablen zu finden.

2. get_call_chain

   • Argumente: target_function (string), depth (integer, max. 5)

   • Beschreibung: Löst Upstream-Caller-Ketten mittels Cypher-Pfaden variabler Länge auf, um Aufrufabhängigkeit-Ingenzen zu kartieren.

3. get_file_structure

   • Argumente: file_path (string)

   • Beschreibung: Ruft die vollständige abstrakte Knotenstruktur (Klassen, Interfaces, Methoden, Variablen) einer Datei ab, ohne die rohe Textwelt ins Kontextfenster zu zwischenzuspeichern.

4. visualize_codebase

   • Beschreibung: Stößt einen HTML-Export an und speichert contextshrinker_graph.html in Ihrem .contextshrinker/-Verzeichnis.

5. get_architecture_report

   • Beschreibung: Liefert den vollständigen Architektur-Gesundheitsbericht der Codebase mit Metriken zu God Objects, Kopplungshotspots, Zyklen, toten nicht exportierten Funktionen, KI-Metrikken (SCR, DCR, BVI, AOI, Call Chain Depth Index – CDI) und umsetzbaren Best Practices für Code-Qualität („Jeff in the Dean"- / nach Jeff Dean) mit KI-System-Prompt-Direktiven.

🏛️ Codebase- & Architektur-Optimierung

Sie können contextshrinker nutzen, um Kopplung gezielt zu prüfen, Domain-Behälter (DDD) zu analysieren und die Code-Umstrukturierung (z. B. Splitting eines Monolithen in Module) mit LLMs zu steuern.

Optimierungs-Workflow

1. Architektur-Metriken & Richtlinien generieren: Führen Sie den Analysebefehl im Terminal aus, um den Codebase-Graph zu inspizieren und einen Report zu erzeugen:

   ./contextshrinker analyze

   Daraus entsteht contextshrinker-report.md mit Metriken für God Objects (hohe ausgehende Kopplung), Black Holes (hohe eingehende Aufrufe), Zyklische Import-Pfade, Tote nicht-expository exportierte Funktionen anderweit: und Dead Code (ungenutzt private Funktionen), KI-Metriken (Tan auch Call Chain Depth Index – CDI) und umsetzbare Hinweise zu Codequalität und LLM-Architektur (Jeff-Dean-Prinzipien).

2. System-Prompt holen: Den Haupt-Systemarchitekten-Prompt über die CLI abrufen:

   ./contextshrinker prompt architect

3. Mit LLM analysieren:

   • Setzen Sie die Ausgabe des prompt architect-Befehls als System-Prompt für Ihr LLM ein.

   • Geben Sie den Inhalt des erzeugten contextshrinker-report.md als Kontext / Input.

   • Beauftragen Sie das LLM, Bound-Context-Grenzen oder Interface-Grenzen vorzuschlagen.

4. Agentic-/Tool-Nutzung: Wenn Sie einen MCP-kompatiblen Agenten (z. B. Antigravity IDE, Claude Code oder Cursor) verwenden, können Sie direkt anweisen:

   "Führen Sie den contextshrinker-Analysebericht aus, lesen Sie das generierte Markdown und arbeiten Sie als Systems Architect, um unsere Design-Hotspots zu prüfen. Verwenden Sie die Tools get_call_chain und get_file_structure, um die Kopplung zu untersuchen, bevor Sie Modul-Extraktionen vorschlagen ."

⚙️ Konfiguration & Ignore-Listen

Um Workspace-Graphen nicht zu zumutbarer Lug zu erweiten, werden Standard-Library und Dependency-Verzeichnisse (node_modules/, vendor/, .git/, usw.) standardmäßig ignoriert.

Für zusätzliche Ignore-Filters initialisieren Sie das Projekt und erzeugen eine .csignore-Datei an der Root des Workspacees:

contextshrinker init

Jede Zeile in .csignore wird rekursiv abgeglichen:

# Custom project ignores
*.log
tmp-output/
dist/
.vitepress

💡 Best Practices bei großen Projekten

Wenn Sie contextshrinker auf einem maßigen bis großen Projekt einsetzen (z. B. einige hundert oder tausend Dateien), kann das initiale Indizieren direkt aus einer LLM-/Agent-Prompt (wie Claude Code oder Cursor) zu Timeout-Fehlern des Agents führen. Der Grund ist das enge Timeout-Limit des Agents (meist 60 Sekunden) beim Warten auf die Ersteinlesung des Workspace und die LSP-Referenzauflösung.

Verwenden Sie deshalb vor Agentstart den folgenden optimierten Ablauf im Terminal:

1. Workspace initialisieren: Führen Sie den Initialisierungsbefehl aus, um das Konfigurationsverzeichnis und die Standard-Ignoreliste anzulegen:

   contextshrinker init

2. Ignorier-/Filter einrichten: Öffnen Sie die erzeugte .csignore-Datei im Workspace-Wurzelverzeichnis und tragen Sie große zu ignorierende Verzeichnisse ein (Doku-Sites, Test-Assets, Build-Ordner etc.).

3. Datenbank offline aufbauen: Lassen Sie den Analyse-Befehl einmal im Terminal laufen, um die initiale Graphdatenbank zu erzeugen:

   contextshrinker analyze

   Damit werden Tree-sitter-Parsen und LSP-semantische Referenzauflösung der sauere Vorarbeit bereits verrichten. Sobald die Datenbank proppet gefüllt ist, laufen spätere Agent-Anfragen & Live-State-Syncs inkrementell nur noch in Sekundenze the – no future Timeouts!

📟 CLI-Modus (Kommandozeile)

Sie können den Codebase-Graphen abfragen, den MCP-Server-Daemon explizit starten, Systemarchitecken-Prompts abrufen oder den Health-Report direkt im Terminal erzeugen.

1. MCP-Server starten

Standle instrastärwe ./contextshrinker ohne Argumente den MCP-Server-Daemon. Sie können ihn aber auch explizit auslösen:

./contextshrinker start

2. Architekturanalysis ausführen

Die Struktur der Codebase analysieren (God Objects, eingehende Aufruf-Hotspots, zyklische Pfade, Dead Code, Call Chain Depth Index – CDI und LLM-Code-Qualitätsempfehlungen) und Report nach contextshrinker-report.md schreiben:

./contextshrinker analyze

3. Principal-System-Architect-Prompt drucken

Den System-Prompt des DDD-Prinzipalarchitekten (Domain-Driven Design) auf stdout ausgeben:

./contextshrinker prompt architect

4. Codebase durchsuchen

Funktionen, Klassen oder Variablen passend zu einem Suchbeg...

./contextshrinker search "IngestWorkspace"

5. Aufrufketten verfolgen

Upstream-Caller für eine Ziel-Funktion nachverfolgen (Standardtiefe 3, Maximum 5):

./contextshrinker call-chain "IngestWorkspace" --depth 3

6. Dateistruktur abrufen

Struktur einer Datei holen, ohne den vollen Text zu lesen:

./contextshrinker structure "main.go"

7. Interaktive Visualisierung erzeugen

Vis.js-Ansicht als GrapheneRepräsentation erzeugen:

./contextshrinker visualize

Die generierte Datei .contextshrinker/contextshrinker_graph.html im Browser öffnen, um die Architektur des Projekts interaktiv zu erkunden.

Globale Flags-Optionen

• --workspace <Pfad>: Gibt des Projektpfad an (statt .).

• --db <Pfad>: Zielort für die DB-Speicherlage (Standard: .contextshrinker/db).

• --reindex: Erzwingt den Full-Ingest-Scan (Parsen und LSP-Mapping) vor der eigentlichen Anfrage. Bei leerer DB wird die Erfassung automatisch für nötig.

• Hinweis: Da KuzuDB eine exklusive Sperre auf Dateiebene errichtet, sollte Ihre IDE MCP-Client pausieren oder anhalten, wenn Sie mit diesen CLI-Befehlen against that DB called bundled. Alternativ set you andere Workspace/DB-Pfade über die Flags.

📄 Lizenz

MIT-Lizenz.