# AI Code Assistant

Ein modularer KI-gestützter Coding-Assistent mit Tool-Ausführung, Datei-Kontextverwaltung und optionaler selbstreflektierender Agentenlogik.

---

# Übersicht

Dieses Projekt ist ein erweiterbarer AI-Code-Assistent, der entwickelt wurde, um:

* Code zu verstehen und zu erklären
* Dateien zu bearbeiten und zu verwalten
* Code auszuführen und Fehler zu analysieren
* Dynamisch Tools zu verwenden
* Antworten iterativ zu verbessern

Die Anwendung kombiniert einen agentischen Workflow mit einer Reflexions-Engine, um qualitativ hochwertige Antworten und Code-Verbesserungen zu erzeugen.

---

# Projektstruktur

```text
main.py

src/
│
├── backend/
│   ├── chat_manager.py
│   ├── reflection_engine.py
│   ├── execution_engine.py
│   ├── file_manager.py
│   ├── llm_client.py
│   ├── system_prompter.py
│   ├── tools.py
│   └── ...weitere Backend-Module
│
└── ui/
    └── ...Frontend- und UI-Dateien
```

---

# Architektur

## `main.py`

Der Einstiegspunkt der Anwendung.

Verantwortlich für:

* Initialisierung der Anwendung
* Starten der Streamlit-Oberfläche
* Verbinden aller Backend-Komponenten
* Laden der UI

---

# Backend (`src/backend`)

Enthält die gesamte Kernlogik der Anwendung.

---

## `chat_manager.py`

Zentrale Steuerungseinheit des Assistenten.

Aufgaben:

* Verwaltung der Konversation
* Agentischer Tool-Loop
* Datei-Kontextverwaltung
* Integration der Reflection Engine
* Tool-Ausführung
* Kommunikation zwischen UI und Backend

Der `ChatManager` bildet das Herzstück der Anwendung.

---

## `reflection_engine.py`

Implementiert den selbstreflektierenden Agenten-Workflow.

Funktionen:

* Bewertung von Antworten
* Analyse von Schwächen
* Iterative Verbesserung von Antworten
* Qualitätsbewertung über Score-System
* Automatisches Stoppen bei erreichter Qualität
* Unterstützung von Tool-Aufrufen während der Verbesserung

---

## `execution_engine.py`

Verantwortlich für:

* Ausführen von Dateien
* Ausführen von Code-Snippets
* Erfassen von `stdout` und `stderr`
* Rückgabe von Debug-Logs

---

## `file_manager.py`

Verwaltet:

* Lesen von Dateien
* Schreiben von Dateien
* Aktive Datei-Kontexte

---

## `tools.py`

Definiert verfügbare Tools und das Tool-Registry-System.

Beispiele:

* `read_file`
* `edit_file`
* `execute_file`
* `execute_code`
* `search`

---

## `llm_client.py`

Kommunikation mit dem verwendeten LLM/API.

---

## `system_prompter.py`

Erstellt dynamische Systemprompts inklusive:

* Datei-Kontext
* Tool-Beschreibungen
* Laufzeitinformationen

---

# UI (`src/ui`)

Enthält sämtliche Frontend- und Benutzeroberflächen-Komponenten.

Mögliche Funktionen:

* Chat-Oberfläche
* Dateiansicht
* Tool-Aktivitätsanzeige
* Reflection-Status
* Ausgabe von Logs und Fehlern

---

# Reflection-System

Der Assistent kann Antworten automatisch analysieren und verbessern.

Ablauf:

1. Initiale Antwort erzeugen
2. Antwort bewerten
3. Schwächen identifizieren
4. Antwort verbessern
5. Wiederholen bis Qualitätsziel erreicht ist

---

## Reflection Workflow

```text
Benutzeranfrage
        ↓
Erste Antwort
        ↓
Kritik & Analyse
        ↓
Qualitätsbewertung
        ↓
Verbesserung
        ↓
Optimierte Antwort
```

---

## Reflection-Konfiguration

Im `ChatManager`:

```python
self.reflection_enabled = True
self.reflection_max_rounds = 3
self.reflection_threshold = 8.5
```

---

## Reflection aktivieren/deaktivieren

```python
chat_manager.set_reflection(
    enabled=True,
    max_rounds=3,
    threshold=8.5
)
```

---

# Features

* Tool-basierter KI-Agent
* Iterative Antwortverbesserung
* Selbstreflektierende Analyse
* Datei-Kontextintegration
* Code-Ausführung
* Modulare Architektur
* Streamlit-UI
* Dynamische Tool-Registry
* Debug- und Fehleranalyse
* JSON-basierte Agent-Kommunikation

---

# Installation

## 1. Repository klonen

```bash
git clone <repository-url>
cd <projektname>
```

---

## 2. Virtuelle Umgebung erstellen

### Windows

```bash
python -m venv venv
venv\Scripts\activate
```

### Linux / macOS

```bash
python3 -m venv venv
source venv/bin/activate
```

---

## 3. Abhängigkeiten installieren

```bash
pip install -r requirements.txt
```

---

# Anwendung starten

Die Anwendung wird über Streamlit gestartet:

```bash
streamlit run main.py
```

---

# Beispielanfragen

## Code erklären

```text
Was macht diese Funktion?
```

---

## Datei bearbeiten

```text
Füge Kommentare zu dieser Datei hinzu
```

---

## Datei ausführen

```text
Führe die aktuelle Datei aus
```

---

## Fehler analysieren

```text
Warum tritt dieser Fehler auf?
```

---