cline-sdk/DOCUMENTATION.md

Comprehensive SDK for Cline - AI-powered development assistant with database integration, execution modes, and custom functions

# Cline SDK - Vollständige Dokumentation

Eine umfassende SDK für die Integration von KI-gestützter Entwicklungsautomatisierung mit PostgreSQL-Datenbankunterstützung, flexiblen Ausführungsmodi und benutzerdefinierten Funktionen.

## 🚀 Überblick

Die Cline SDK ermöglicht es Ihnen, KI-Assistenten nahtlos in Ihre Anwendungen zu integrieren. Mit Unterstützung für verschiedene Ausführungsmodi, Datenbankoperationen und benutzerdefinierte Funktionen können Sie alles von einfachen Frage-Antwort-Systemen bis hin zu vollständigen Automatisierungsworkflows erstellen.

### Hauptfunktionen

- **🤖 KI-Integration**: Anthropic Claude API mit vollem Funktionsumfang
- **🔧 Prompt-Optimierung**: Weltweit erste integrierte Prompt-Analyse und Verbesserung mit automatischer Bewertung (Klarheit, Spezifität, Vollständigkeit, Struktur)
- **🔄 Ausführungsmodi**: Ask/Plan/Act Modi für verschiedene Anwendungsfälle mit intelligenter Modusumschaltung
- **📡 Event-System**: Echtzeit-Events für KI-Denken, Chat-Antworten und Ausführungszustände (wie original Cline)
- **🔄 Auto-Retry**: Intelligente Wiederholungsmechanismen mit konfigurierbaren Verzögerungen und Fehlerklassifizierung
- **🐘 PostgreSQL Integration**: Vollständige Datenbankunterstützung mit Row Level Security (RLS)
- **📚 Tabellen-Wissen**: Registrierung von Geschäftskontext für Datenbanktabellen mit GDPR-Unterstützung
- **🎯 Benutzerdefinierte Funktionen**: Erweitern Sie die KI mit Ihren eigenen Geschäftsfunktionen
- **☁️ Cloud-Speicher**: Supabase Integration für verteilte Dateioperationen mit transparentem projectPath
- **🛡️ Sicherheit**: Umfassende Berechtigungen und Zugriffskontrollen mit feingranulärer Tool-Beschränkung
- **💰 Kostenüberwachung**: Integrierte API-Kostenüberwachung und -optimierung mit Real-time Tracking

## 📦 Installation

```bash
npm install cline-sdk
# oder
yarn add cline-sdk 
```

### Abhängigkeiten

- Node.js 18+ 
- PostgreSQL 12+ (optional, für Datenbankfunktionen)
- Anthropic API Key

## 🎯 Schnellstart

### Grundlegende Verwendung

```javascript
const { CompleteClineSDK } = require('cline-sdk')

const sdk = new CompleteClineSDK({
    apiProvider: "anthropic",
    apiKey: process.env.ANTHROPIC_API_KEY,
    enabledTools: ["Write", "Read", "Bash"],
    workingDirectory: process.cwd(),
    storageType: "local"
})

// Einfache Aufgabe erstellen
await sdk.createTask("Erstelle eine README.md Datei für mein Projekt")
```

### Mit Datenbank

```javascript
const sdk = new CompleteClineSDK({
    apiProvider: "anthropic",
    apiKey: process.env.ANTHROPIC_API_KEY,
    enabledTools: ["Write", "Read"],
    enableDatabase: true,
    database: {
        host: "localhost",
        port: 5432,
        database: "meine_db",
        username: "user",
        password: "password",
        permissions: {
            allowRead: true,
            allowWrite: true,
            allowDelete: false
        }
    }
})
```

## 🔄 Ausführungsmodi

Die SDK unterstützt drei verschiedene Ausführungsmodi für maximale Flexibilität:

### ASK-Modus ❓
**Nur Fragen beantworten - keine Aktionen ausführen**

```javascript
sdk.setExecutionMode("ask")
await sdk.createTask("Erkläre mir, wie REST APIs funktionieren")
```

**Anwendungsfälle:**
- Lernen und Erklärungen
- Beratung und Best Practices
- Sichere Umgebung für Fragen
- Code-Reviews ohne Änderungsrisiko

### PLAN-Modus 📋
**Analysieren und planen - nur Lese-Operationen**

```javascript
sdk.setExecutionMode("plan")
await sdk.createTask("Analysiere meine Datenbankstruktur und erstelle einen Optimierungsplan")
```

**Anwendungsfälle:**
- Code-Analyse und Reviews
- Refactoring-Planung
- Datenbankschema-Analyse
- Sicherheitsüberprüfungen

### ACT-Modus ⚡
**Vollständige Ausführung - alle Tools verfügbar**

```javascript
sdk.setExecutionMode("act")
await sdk.createTask("Implementiere die geplanten Datenbankoptimierungen")
```

**Anwendungsfälle:**
- Vollständige Automatisierung
- CI/CD-Integration
- Produktive Entwicklung
- Datenmigration

### Dynamischer Moduswechsel

```javascript
// Programmatisch
sdk.setExecutionMode("ask")

// Via Kommandos
await sdk.createTask("/plan")  // Wechselt zu PLAN-Modus

// Natürliche Sprache
await sdk.createTask("Wechsle in den Ask-Modus und erkläre mir...")

// Automatische Erkennung
await sdk.createTask("Erkläre nur") // → ASK-Modus
await sdk.createTask("Erstelle einen Plan") // → PLAN-Modus  
await sdk.createTask("Führe es aus") // → ACT-Modus
```

## 🎯 Benutzerdefinierte Funktionen

Erweitern Sie die KI mit Ihren eigenen Geschäftsfunktionen:

```javascript
// Funktion registrieren
sdk.registerFunction(
    {
        name: "validateEmail",
        description: "Validiert E-Mail-Adressen nach Geschäftsregeln",
        category: "validation",
        parameters: [
            {
                name: "email",
                type: "string",
                required: true,
                description: "E-Mail-Adresse zum Validieren"
            },
            {
                name: "checkDomain",
                type: "boolean",
                optional: true,
                default: false,
                description: "Domain-Validierung aktivieren"
            }
        ]
    },
    async (email, checkDomain = false) => {
        // Ihre Validierungslogik
        const isValid = /^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$/.test(email)
        
        let domainCheck = null
        if (checkDomain && isValid) {
            const domain = email.split('@')[1]
            domainCheck = await validateDomain(domain)
        }
        
        return {
            email,
            isValid,
            domainCheck,
            timestamp: new Date().toISOString()
        }
    }
)

// KI kann die Funktion nun verwenden
await sdk.createTask("Validiere die E-Mail 'test@beispiel.de' mit Domain-Check")
```

### Funktionskategorien

- **validation**: Datenvalidierung und Qualitätskontrolle
- **business**: Geschäftslogik und Berechnungen
- **external**: API-Aufrufe und externe Integrationen
- **utility**: Hilfsfunktionen und Tools
- **analysis**: Datenanalyse und Reporting

## 🐘 PostgreSQL Integration

### Datenbankverbindung

```javascript
const sdk = new CompleteClineSDK({
    enableDatabase: true,
    database: {
        host: "localhost",
        port: 5432,
        database: "meine_app",
        username: "app_user",
        password: "sicheres_passwort",
        ssl: true, // Für Produktionsumgebungen
        maxConnections: 10,
        permissions: {
            allowRead: true,
            allowWrite: true,
            allowDelete: false,
            allowSchemaChanges: false,
            allowRLSManagement: true,
            restrictedTables: ["admin_logs", "sensitive_data"],
            allowedTables: ["users", "products", "orders"]
        }
    }
})
```

### Datenbankoperationen

```javascript
// Schema-Introspection
await sdk.createTask("Zeige mir alle Tabellen in der Datenbank")

// Sichere Abfragen
await sdk.createTask("Finde alle Benutzer mit mehr als 5 Bestellungen")

// Row Level Security
await sdk.createTask("Erstelle RLS-Richtlinien für die users-Tabelle")
```

### Berechtigungssystem

```javascript
const permissions = {
    allowRead: true,           // SELECT-Abfragen erlauben
    allowWrite: true,          // INSERT/UPDATE erlauben
    allowDelete: false,        // DELETE-Operationen verbieten
    allowSchemaChanges: false, // DDL-Operationen verbieten
    allowRLSManagement: true,  // Row Level Security Management
    
    // Tabellen-spezifische Kontrolle
    restrictedTables: [        // Vollständig gesperrte Tabellen
        "admin_logs",
        "payment_details",
        "sensitive_data"
    ],
    allowedTables: [           // Explizit erlaubte Tabellen (leer = alle außer restricted)
        "users",
        "products", 
        "orders"
    ]
}
```

## 📚 Tabellen-Wissen System

Registrieren Sie Geschäftskontext für Ihre Datenbanktabellen:

```javascript
// Tabellenwissen registrieren
sdk.addTable({
    schemaName: "public",
    tableName: "customers",
    businessName: "Kundendatenbank",
    description: "Zentrale Kundenverwaltung für E-Commerce",
    businessPurpose: "Speichert Kundendaten für Bestellungen und Marketing",
    domain: "customer-management",
    
    columns: [
        {
            name: "id",
            dataType: "uuid",
            description: "Eindeutige Kunden-ID",
            businessPurpose: "Primärschlüssel für Kundenreferenzen",
            validation: { required: true },
            privacy: { isPII: false, accessLevel: "internal" },
            businessRules: ["UUID v4 Format", "Unveränderlich nach Erstellung"],
            examples: ["123e4567-e89b-12d3-a456-426614174000"]
        },
        {
            name: "email",
            dataType: "varchar",
            description: "Kunden-E-Mail-Adresse",
            businessPurpose: "Authentifizierung und Kommunikation",
            validation: { 
                required: true, 
                pattern: "^[\\w-\\.]+@([\\w-]+\\.)+[\\w-]{2,4}$",
                maxLength: 255
            },
            privacy: {
                isPII: true,
                accessLevel: "restricted", 
                gdprRelevant: true
            },
            businessRules: [
                "Muss eindeutig sein",
                "Für Login erforderlich",
                "Für Passwort-Reset verwendet"
            ],
            commonQueries: [
                "SELECT * FROM customers WHERE email = ?",
                "SELECT COUNT(*) FROM customers WHERE email = ?"
            ]
        }
    ],
    
    relationships: {
        childTables: ["orders", "customer_addresses", "reviews"],
        description: "Kunden haben Bestellungen, Adressen und Bewertungen"
    },
    
    businessRules: [
        {
            rule: "E-Mail-Eindeutigkeit",
            description: "Jede E-Mail kann nur einem aktiven Konto zugeordnet sein",
            sqlConstraint: "UNIQUE(email) WHERE active = true"
        }
    ],
    
    commonUseCases: [
        {
            useCase: "Kundensuche",
            description: "Kunde für Support finden",
            frequency: "täglich",
            exampleQuery: "SELECT * FROM customers WHERE email = $1"
        }
    ],
    
    security: {
        accessLevel: "restricted",
        requiresRLS: true,
        auditingRequired: true
    },
    
    tags: ["core", "pii", "gdpr", "customer-management"]
})

// Wissen durchsuchen
const piiTables = sdk.searchTableKnowledge({ tags: ["pii"] })
const customerTables = sdk.searchTableKnowledge({ domain: "customer-management" })

// KI-Kontext generieren
const context = sdk.generateKnowledgeContext()
```

### Datenschutz und Compliance

```javascript
// GDPR-relevante Spalten markieren
{
    name: "personal_data",
    privacy: {
        isPII: true,                    // Personenbezogene Daten
        gdprRelevant: true,            // GDPR-relevant
        accessLevel: "confidential",   // Zugriffslevel
        isEncrypted: true              // Verschlüsselt gespeichert
    }
}
```

## ☁️ Supabase Cloud-Speicher

```javascript
const sdk = new CompleteClineSDK({
    storageType: "supabase",
    supabase: {
        url: process.env.SUPABASE_URL,
        anonKey: process.env.SUPABASE_ANON_KEY,
        bucket: "meine-dateien",
        basePath: "sdk-files/"
    }
})

// Dateien werden automatisch in die Cloud hochgeladen
await sdk.createTask("Erstelle eine Konfigurationsdatei und lade sie hoch")
```

## 🛡️ Sicherheit und Berechtigungen

### Tool-Beschränkungen

```javascript
// Tools pro Modus beschränken
const restrictions = sdk.getCurrentModeRestrictions()
console.log(restrictions)
// {
//   canExecuteTools: true,
//   canWriteFiles: false,     // Im PLAN-Modus
//   canRunCommands: false,
//   canModifyDatabase: false,
//   maxToolsPerTask: 5
// }
```

### Datenbankberechtigungen

```javascript
// Feingranuläre Kontrolle
const dbPermissions = {
    allowRead: true,
    allowWrite: true,
    allowDelete: false,           // Keine Löschungen erlauben
    allowSchemaChanges: false,    // Keine DDL-Operationen
    allowRLSManagement: true,     // RLS-Verwaltung erlauben
    restrictedTables: [           // Gesperrte Tabellen
        "admin_users",
        "payment_logs", 
        "audit_trail"
    ]
}
```

## 🎨 Beispiele und Anwendungsfälle

### 1. Grundlegende Verwendung
```bash
npm run example:basic
```
Zeigt die grundlegenden SDK-Funktionen und einfache Dateioperationen.

### 2. Ausführungsmodi
```bash
npm run example:modes  
```
Demonstriert Ask/Plan/Act-Modi und dynamisches Mode-Switching.

### 3. Benutzerdefinierte Funktionen
```bash
npm run example:functions
```
Zeigt die Registrierung und Verwendung eigener Geschäftsfunktionen.

### 4. Datenbankintegration
```bash
npm run example:database
```
PostgreSQL-Integration mit Schema-Exploration und sicheren Abfragen.

### 5. Tabellen-Wissen
```bash
npm run example:knowledge
```
Registrierung von Geschäftskontext für Datenbanktabellen.

### 6. Supabase Cloud-Speicher
```bash
npm run example:supabase
```
Cloud-basierte Dateioperationen mit Supabase.

### 7. Vollständiger Workflow
```bash
npm run example:workflow
```
End-to-End-Workflow: Ask → Plan → Act mit allen Funktionen.

### 8. Event-Überwachung
```bash
npm run example:events
```
Echzeit-Events für KI-Denken, Chat-Antworten und Ausführungszustände.

### 9. Auto-Retry System
```bash
npm run example:retry
```
Automatische Wiederholung bei Fehlern mit konfigurierbaren Verzögerungen.

### 10. Prompt-Optimierung
```bash
npm run example:optimization
```
Weltweit erste integrierte Prompt-Analyse und Verbesserungssystem.

## 📊 Event-System

```javascript
// Aufgaben-Events
sdk.on("task:created", (task) => {
    console.log(`Neue Aufgabe: ${task.id}`)
})

sdk.on("task:completed", (task) => {
    console.log(`Aufgabe abgeschlossen: ${task.id}`)
})

// KI-Denken Events (wie original Cline)
sdk.on("ai:thinking", (event) => {
    console.log(`🧠 KI denkt: ${event.stage} - ${event.content}`)
})

// Chat-Antworten Events
sdk.on("chat:response", (event) => {
    console.log(`💬 Antwort: ${event.content}`)
})

// Ausführungszustände Events
sdk.on("execution:state", (event) => {
    console.log(`⚡ Zustand: ${event.state}`)
})

// Tool-Ausführung Events
sdk.on("tool:starting", (event) => {
    console.log(`🔧 Starte: ${event.toolName}`)
})

sdk.on("tool:completed", (event) => {
    console.log(`✅ Abgeschlossen: ${event.toolName} (${event.executionTime}ms)`)
})

// Retry-Events
sdk.on("retry:attempt", (event) => {
    console.log(`🔄 Versuch ${event.attemptNumber}: ${event.error}`)
    console.log(`   Warte ${event.waitTime}ms vor nächstem Versuch...`)
})

// Prompt-Optimierung Events
sdk.on("prompt:optimization:started", (prompt) => {
    console.log(`🔧 Optimiere: ${prompt.substring(0, 50)}...`)
})

sdk.on("prompt:optimization:completed", (result) => {
    console.log(`✨ Optimierung fertig: ${result.analysis.overall}/10 Punkte`)
})

// Modus-Events
sdk.on("mode:changed", (newMode, oldMode) => {
    console.log(`Modus geändert: ${oldMode} → ${newMode}`)
})
```

## 🔧 Prompt-Optimierung

**Weltweit erste SDK mit integrierter Prompt-Optimierung!**

### Automatische Prompt-Analyse

```javascript
const { PromptOptimizer } = require('cline-sdk')

const optimizer = new PromptOptimizer()
const result = optimizer.optimizePrompt("hilf mir das zu reparieren")

console.log(`Klarheit: ${result.analysis.clarity}/10`)
console.log(`Spezifität: ${result.analysis.specificity}/10`)
console.log(`Vollständigkeit: ${result.analysis.completeness}/10`)
console.log(`Struktur: ${result.analysis.structure}/10`)
console.log(`Gesamtbewertung: ${result.analysis.overall}/10`)

// Verbesserter Prompt
console.log(`Verbesserung: ${result.improvedPrompt}`)

// Konkrete Verbesserungsvorschläge
result.suggestions.forEach(suggestion => {
    console.log(`💡 ${suggestion}`)
})
```

### SDK-Integration

```javascript
// Direkte Analyse mit dem SDK
const optimization = sdk.analyzePrompt("erstelle eine website")
console.log(sdk.formatOptimizationResults(optimization))

// Event-basierte Optimierung
sdk.on('prompt:optimization:started', (prompt) => {
    console.log(`🔧 Analysiere: ${prompt.substring(0, 50)}...`)
})

sdk.on('prompt:optimization:completed', (result) => {
    console.log(`✨ Optimierung abgeschlossen: ${result.analysis.overall}/10 Punkte`)
})
```

### Optimierungs-Kommandos

```javascript
// Kommandos für automatische Optimierung
await sdk.createTask("/optimize erstelle eine REST API")
await sdk.createTask("/improve hilf mir beim programmieren")
await sdk.createTask("optimize: mache eine datenbank")
await sdk.createTask("improve prompt: zeige mir den code")
```

**Unterstützte Kommandos:**
- **`/optimize <prompt>`** - Prompt analysieren und verbessern
- **`/improve <prompt>`** - Verbesserungsvorschläge erstellen
- **`optimize: <prompt>`** - Alternative Syntax
- **`improve prompt: <prompt>`** - Ausführliche Syntax

### Bewertungskriterien

Die Prompt-Optimierung bewertet folgende Kriterien (Skala 1-10):

**Klarheit (Clarity)**
- Sind die Anweisungen eindeutig und verständlich?
- Werden Fachbegriffe angemessen erklärt?
- Ist der gewünschte Kontext klar definiert?

**Spezifität (Specificity)**
- Sind die Anforderungen konkret und messbar?
- Werden gewünschte Ausgabeformate spezifiziert?
- Sind Einschränkungen und Parameter klar definiert?

**Vollständigkeit (Completeness)**
- Enthält der Prompt alle notwendigen Informationen?
- Sind Kontext und Hintergrundinformationen ausreichend?
- Werden Beispiele oder Referenzen bereitgestellt?

**Struktur (Structure)**
- Ist der Prompt logisch aufgebaut und organisiert?
- Werden wichtige Punkte hervorgehoben?
- Ist die Reihenfolge der Informationen sinnvoll?

### Praktische Beispiele

```javascript
// Schwacher Prompt
const weak = "hilf mir"
const result1 = optimizer.optimizePrompt(weak)
console.log(`Bewertung: ${result1.analysis.overall}/10`)
// Ausgabe: Bewertung: 2/10

// Verbesserter Prompt
console.log(result1.improvedPrompt)
// "Ich benötige Unterstützung bei einer spezifischen Aufgabe. 
//  Könnten Sie mir bitte helfen, indem Sie [spezifische Aufgabe] 
//  mit [gewünschtem Ausgabeformat] lösen?"

// Starker Prompt
const strong = "Erstelle eine REST API in Node.js mit Express für ein E-Commerce-System. Die API soll Endpunkte für Benutzer, Produkte und Bestellungen enthalten. Verwende TypeScript, implementiere Validierung mit Joi und erstelle Swagger-Dokumentation."
const result2 = optimizer.optimizePrompt(strong)
console.log(`Bewertung: ${result2.analysis.overall}/10`)
// Ausgabe: Bewertung: 9/10
```

### Event-System für Optimierung

```javascript
// Überwachung der Optimierungs-Pipeline
sdk.on('prompt:optimization:started', (prompt) => {
    console.log(`🔍 Starte Analyse: "${prompt.substring(0, 100)}..."`)
})

sdk.on('prompt:optimization:completed', (result) => {
    console.log(`📊 Analyse abgeschlossen:`)
    console.log(`   Klarheit: ${result.analysis.clarity}/10`)
    console.log(`   Spezifität: ${result.analysis.specificity}/10`)
    console.log(`   Vollständigkeit: ${result.analysis.completeness}/10`)
    console.log(`   Struktur: ${result.analysis.structure}/10`)
    console.log(`   Gesamt: ${result.analysis.overall}/10`)
    
    if (result.analysis.overall < 7) {
        console.log(`💡 Verbesserungsvorschläge:`)
        result.suggestions.forEach(s => console.log(`   - ${s}`))
    }
})

// Automatische Verwendung verbesserter Prompts
sdk.on('prompt:optimization:completed', async (result) => {
    if (result.analysis.overall < result.originalAnalysis?.overall) {
        console.log(`✨ Verwende verbesserten Prompt automatisch`)
        await sdk.createTask(result.improvedPrompt)
    }
})
```

### Integration in Workflows

```javascript
// Prompt-Optimierung als Teil des Entwicklungsworkflows
class OptimizedWorkflow {
    constructor(sdk) {
        this.sdk = sdk
        this.promptHistory = []
    }
    
    async executeWithOptimization(prompt) {
        // Prompt analysieren
        const optimization = this.sdk.analyzePrompt(prompt)
        this.promptHistory.push({
            original: prompt,
            optimized: optimization.improvedPrompt,
            score: optimization.analysis.overall,
            timestamp: new Date()
        })
        
        // Verbesserten Prompt verwenden wenn Score zu niedrig
        const finalPrompt = optimization.analysis.overall < 7 
            ? optimization.improvedPrompt 
            : prompt
            
        console.log(`📝 Verwende Prompt (Score: ${optimization.analysis.overall}/10)`)
        return await this.sdk.createTask(finalPrompt)
    }
    
    getOptimizationStats() {
        const improvements = this.promptHistory.filter(h => 
            h.optimized !== h.original
        ).length
        
        const avgScore = this.promptHistory.reduce((sum, h) => 
            sum + h.score, 0
        ) / this.promptHistory.length
        
        return {
            totalPrompts: this.promptHistory.length,
            optimized: improvements,
            averageScore: avgScore.toFixed(1)
        }
    }
}

// Verwendung
const workflow = new OptimizedWorkflow(sdk)
await workflow.executeWithOptimization("mache mir eine app")
console.log(workflow.getOptimizationStats())
```

## 💰 Kosten-Tracking

```javascript
// Aktuelle Aufgabenkosten
const costs = sdk.getCurrentTaskCost()
console.log(`Kosten: $${costs.reduce((sum, c) => sum + c.total_cost_usd, 0)}`)

// Gesamtkosten
const totalCosts = sdk.getTotalCosts()
console.log(`Gesamtkosten: $${totalCosts.totalCost}`)
console.log(`Durchschnitt pro Aufgabe: $${totalCosts.averageCostPerTask}`)

// Preise anpassen
sdk.setCustomPricing(0.001, 0.002) // Input/Output pro 1k Tokens
```

## 🔧 Konfigurationsoptionen

### Vollständige Konfiguration

```javascript
const config = {
    // API-Konfiguration
    apiProvider: "anthropic",              // "anthropic" 
    apiKey: "sk-ant-...",                 // API-Schlüssel
    model: "claude-3-5-sonnet-20241022",  // Modell-Name
    
    // Tools
    enabledTools: [                       // Verfügbare Tools
        "Write",           // Dateien schreiben
        "Read",            // Dateien lesen  
        "Bash",            // Kommandos ausführen
        "CustomFunction"   // Benutzerdefinierte Funktionen
    ],
    
    // Ausführung
    executionMode: "act",                 // "ask", "plan", "act"
    workingDirectory: "/pfad/zum/projekt",
    
    // Speicher
    storageType: "local",                 // "local" oder "supabase"
    
    // Supabase (optional)
    supabase: {
        url: "https://xyz.supabase.co",
        anonKey: "eyJ...",
        bucket: "dateien",
        basePath: "uploads/"
    },
    
    // Datenbank (optional)  
    enableDatabase: true,
    database: {
        host: "localhost",
        port: 5432,
        database: "meine_db",
        username: "user",
        password: "pass",
        ssl: true,
        maxConnections: 10,
        idleTimeoutMillis: 30000,
        connectionTimeoutMillis: 5000,
        permissions: {
            allowRead: true,
            allowWrite: true,
            allowDelete: false,
            allowSchemaChanges: false,
            allowRLSManagement: true,
            restrictedTables: ["admin_data"],
            allowedTables: []
        }
    },
    
    // Funktionen
    enableCustomFunctions: true,
    
    // Erweitert
    customInstructions: "Zusätzliche Anweisungen für die KI...",
    maxRetries: 3,
    timeoutMs: 30000
}
```

## 🚨 Fehlerbehandlung

```javascript
try {
    const task = await sdk.createTask("Aufgabe mit möglichem Fehler")
    
    sdk.on("task:error", (task, error) => {
        console.error(`Aufgabe ${task.id} fehlgeschlagen:`, error.message)
        
        // Automatische Wiederholung oder Fallback-Logic
        if (error.message.includes("Berechtigung")) {
            sdk.setExecutionMode("plan") // Fallback zu Nur-Lesen
        }
    })
    
} catch (error) {
    console.error("SDK-Fehler:", error.message)
}
```

## 🧪 Tests

```bash
# PostgreSQL-Tests
npm run test:postgres

# Integrationstests
npm run test:integration

# Testdatenbank einrichten
npm run db:setup
npm run db:cleanup
npm run db:reset
```

## 🔍 Debugging

```javascript
// Debug-Modus aktivieren
const sdk = new CompleteClineSDK({
    debug: true,
    logLevel: "verbose"
})

// Status-Informationen
console.log("Aktueller Status:", sdk.getState())
console.log("Datenbankstatus:", sdk.getDatabaseStatus())
console.log("Funktionsstatistiken:", sdk.getFunctionStats())
console.log("Tabellenwissen:", sdk.getTableKnowledgeStats())
```

## 🚀 Produktionsbereitschaft

### Umgebungsvariablen

```bash
# .env Datei
ANTHROPIC_API_KEY=sk-ant-...
DB_HOST=produktions-db.beispiel.com
DB_PORT=5432
DB_NAME=produktions_db
DB_USER=app_user
DB_PASSWORD=sicheres_passwort
SUPABASE_URL=https://xyz.supabase.co
SUPABASE_ANON_KEY=eyJ...
```

### Produktionskonfiguration

```javascript
const produktionsConfig = {
    apiProvider: "anthropic",
    apiKey: process.env.ANTHROPIC_API_KEY,
    enabledTools: ["Write", "Read", "DatabaseQuery"],
    executionMode: "act",
    
    database: {
        host: process.env.DB_HOST,
        port: parseInt(process.env.DB_PORT),
        database: process.env.DB_NAME,
        username: process.env.DB_USER,
        password: process.env.DB_PASSWORD,
        ssl: true,
        maxConnections: 20,
        permissions: {
            allowRead: true,
            allowWrite: true,
            allowDelete: false,              // Sicherheit: keine Löschungen
            allowSchemaChanges: false,       // Sicherheit: keine Schema-Änderungen
            allowRLSManagement: false,       // Sicherheit: keine RLS-Änderungen
            restrictedTables: [              // Kritische Tabellen sperren
                "admin_users",
                "payment_logs",
                "audit_trail"
            ]
        }
    },
    
    // Monitoring
    enableTelemetry: true,
    errorReporting: true
}
```

## 📋 Best Practices

### 1. Sicherheit
- Verwenden Sie Umgebungsvariablen für Credentials
- Beschränken Sie Datenbankberechtigungen auf das Minimum
- Implementieren Sie Row Level Security (RLS)
- Überwachen Sie alle Datenbankoperationen

### 2. Performance
- Verwenden Sie Connection Pooling für Datenbanken
- Setzen Sie angemessene Timeouts
- Monitoren Sie API-Kosten
- Implementieren Sie Caching wo möglich

### 3. Wartbarkeit
- Dokumentieren Sie benutzerdefinierte Funktionen
- Registrieren Sie Tabellenwissen für bessere KI-Verständnis
- Verwenden Sie aussagekräftige Event-Handler
- Strukturieren Sie Konfiguration modular

### 4. Entwicklung
- Starten Sie mit ASK-Modus für Exploration
- Verwenden Sie PLAN-Modus für Code-Reviews
- Testen Sie in ACT-Modus vor Produktionsfreigabe
- Implementieren Sie umfassende Fehlerbehandlung

## 📖 Weitere Ressourcen

- [API-Referenz](./API_REFERENCE.md)
- [Beispielsammlung](./examples/)
- [Troubleshooting](./TROUBLESHOOTING.md)
- [Contributing](./CONTRIBUTING.md)

## 📞 Support

Bei Fragen oder Problemen:
1. Konsultieren Sie die Dokumentation
2. Prüfen Sie die Beispiele
3. Überprüfen Sie die Tests
4. Erstellen Sie ein Issue im Repository

---

*Die Cline SDK ist darauf ausgelegt, KI-Entwicklung zugänglich, sicher und produktiv zu machen. Von einfachen Automatisierungsaufgaben bis hin zu komplexen Datenbankoperationen - die SDK wächst mit Ihren Anforderungen.*