centicodehelp 0.2.0__py3-none-any.whl

centicodehelp/cli/commands/analyze.py

@@ -0,0 +1,389 @@
+import os
+import sys
+from pathlib import Path
+from typing import List, Optional
+import click
+from rich.table import Table
+from rich.panel import Panel
+from rich.progress import Progress, SpinnerColumn, BarColumn, TextColumn
+from rich.syntax import Syntax
+
+from centicodehelp.core.models import Finding, Severity, AnalysisResult
+from centicodehelp.core.config import load_config
+from centicodehelp.analysis.detector import detect_language, is_binary_file
+from centicodehelp.analysis.static_analyzer import StaticAnalyzer
+from centicodehelp.analysis.binary_analyzer import BinaryAnalyzer
+from centicodehelp.ai.llm_client import LLMClient
+from centicodehelp.ai.reviewer import AIReviewer, AIReviewResult
+from centicodehelp.ai.prompts import FIX_PROMPT_TEMPLATE
+from centicodehelp.fixer.patcher import PatchGenerator
+from centicodehelp.fixer.applier import PatchApplier
+from centicodehelp.cli.theme import (
+    console,
+    COLOR_PURPLE,
+    COLOR_BLUE,
+    COLOR_INDIGO,
+    COLOR_CRITICAL,
+    COLOR_HIGH,
+    COLOR_MEDIUM,
+    COLOR_LOW,
+    COLOR_INFO,
+    COLOR_SUCCESS,
+    COLOR_ERROR,
+    COLOR_TEXT,
+)
+
+# Dark Theme Severity Styles
+SEVERITY_STYLES = {
+    Severity.CRITICAL: (COLOR_CRITICAL, "🔴 CRITICAL"),
+    Severity.HIGH: (f"bold {COLOR_HIGH}", "🟠 HIGH"),
+    Severity.MEDIUM: (f"bold {COLOR_MEDIUM}", "🟡 MEDIUM"),
+    Severity.LOW: (f"{COLOR_LOW}", "🔵 LOW"),
+    Severity.INFO: (f"{COLOR_INFO}", "⚪ INFO"),
+}
+
+@click.command(name="analyze", help="Quellcode oder Binärdateien mit statischen Regeln und KI analysieren.")
+@click.argument("target", type=click.Path(exists=False), required=False)
+@click.option("-f", "--file", "file_opt", type=click.Path(exists=False), help="Zu analysierende Datei.")
+@click.option("-d", "--dir", "dir_opt", type=click.Path(exists=False), help="Zu analysierendes Verzeichnis.")
+@click.option("--lang", type=str, help="Programmiersprache erzwingen (z. B. python, cpp, csharp, java).")
+@click.option("--ai", is_flag=True, default=False, help="KI-gestützte Tiefenanalyse aktivieren.")
+@click.option("--fix", is_flag=True, default=False, help="Gefundene Probleme automatisch mit KI beheben.")
+@click.option("--provider", type=str, help="KI-Anbieter (openai, anthropic, ollama, deepseek, groq, etc.).")
+@click.option("--model", type=str, help="Modellname (z. B. gpt-4o, claude-3-5-sonnet, llama3.2).")
+@click.option("--output", type=click.Choice(["terminal", "json", "diff"], case_sensitive=False), default="terminal", help="Ausgabeformat.")
+@click.option("--yes", "-y", is_flag=True, default=False, help="Korrekturen ohne manuelle Bestätigung anwenden.")
+@click.option("--debug", is_flag=True, default=False, help="Debug-Informationen (Roh-Antwort der KI, Tokens, Latenz) anzeigen.")
+def analyze_cmd(
+    target: Optional[str],
+    file_opt: Optional[str],
+    dir_opt: Optional[str],
+    lang: Optional[str],
+    ai: bool,
+    fix: bool,
+    provider: Optional[str],
+    model: Optional[str],
+    output: str,
+    yes: bool,
+    debug: bool,
+):
+    """Hauptbefehl zur Code- und Binäranalyse mit modernem Centi09-Dark-Theme."""
+    target_str = file_opt or dir_opt or target or "."
+    target_path = Path(target_str)
+
+    if not target_path.exists():
+        console.print(f"\n[bold {COLOR_ERROR}]❌ Ziel nicht gefunden:[/bold {COLOR_ERROR}] [white]{target_path}[/white]\n")
+        return
+
+    # Sammle alle Dateien
+    files_to_analyze: List[Path] = []
+    if target_path.is_file():
+        files_to_analyze.append(target_path)
+    else:
+        for root, dirs, files in os.walk(target_path):
+            dirs[:] = [
+                d for d in dirs
+                if not d.startswith(".")
+                and d not in ("node_modules", "target", "build", "dist", "__pycache__", "venv", ".venv", "env")
+            ]
+            for f in files:
+                files_to_analyze.append(Path(root) / f)
+
+    if not files_to_analyze:
+        console.print(f"\n[bold {COLOR_MEDIUM}]⚠️ Keine analysierbaren Dateien im Verzeichnis gefunden.[/bold {COLOR_MEDIUM}]\n")
+        return
+
+    config = load_config()
+    selected_provider = provider or config.default_provider
+    selected_model = model or config.default_model
+
+    # Info Header
+    mode_text = "[bold #38BDF8]Statische Analyse[/bold #38BDF8]"
+    if ai and fix:
+        mode_text = f"[bold {COLOR_PURPLE}]Statisch + KI-Audit & Auto-Fix[/bold {COLOR_PURPLE}] ({selected_provider}/{selected_model})"
+    elif ai:
+        mode_text = f"[bold {COLOR_PURPLE}]Statisch + KI-Tiefenanalyse[/bold {COLOR_PURPLE}] ({selected_provider}/{selected_model})"
+    elif fix:
+        mode_text = f"[bold {COLOR_PURPLE}]Statisch + Auto-Fix[/bold {COLOR_PURPLE}] ({selected_provider}/{selected_model})"
+
+    header_panel = Panel(
+        f"[bold]Ziel:[/bold] [yellow]{target_path}[/yellow] ({len(files_to_analyze)} Datei(en))\n"
+        f"[bold]Modus:[/bold] {mode_text}",
+        title=f"[bold {COLOR_PURPLE}]âš¡ centicodehelp ANALYSE[/bold {COLOR_PURPLE}]",
+        border_style=COLOR_INDIGO,
+        expand=False,
+    )
+    console.print()
+    console.print(header_panel)
+    console.print()
+
+    static_analyzer = StaticAnalyzer()
+    binary_analyzer = BinaryAnalyzer()
+    llm_client = None
+    ai_reviewer = None
+
+    if ai or fix:
+        try:
+            llm_client = LLMClient(provider=selected_provider, model=selected_model)
+            ai_reviewer = AIReviewer(llm_client)
+        except Exception as e:
+            console.print(f"[bold {COLOR_ERROR}]❌ KI-Initialisierungsfehler:[/bold {COLOR_ERROR}] {e}")
+            if ai:
+                return
+
+    total_findings: List[Finding] = []
+
+    # Fortschrittsanzeige bei mehreren Dateien
+    if len(files_to_analyze) > 1:
+        with Progress(
+            SpinnerColumn(spinner_name="dots", style=COLOR_PURPLE),
+            TextColumn("[bold #818CF8]{task.description}"),
+            BarColumn(complete_style=COLOR_BLUE, finished_style=COLOR_SUCCESS),
+            TextColumn("[dim]{task.completed}/{task.total} Dateien[/dim]"),
+            console=console,
+        ) as progress:
+            scan_task = progress.add_task("Dateien scannen...", total=len(files_to_analyze))
+            for f_path in files_to_analyze:
+                progress.update(scan_task, description=f"Analysiere [cyan]{f_path.name}[/cyan]...")
+                file_lang = lang or detect_language(f_path)
+                if file_lang:
+                    if file_lang == "binary":
+                        findings = binary_analyzer.analyze_binary(f_path)
+                    else:
+                        findings = static_analyzer.analyze_file(f_path, file_lang)
+                    total_findings.extend(findings)
+                progress.advance(scan_task)
+    else:
+        # Einzelne Datei
+        f_path = files_to_analyze[0]
+        file_lang = lang or detect_language(f_path)
+        if file_lang:
+            if file_lang == "binary":
+                findings = binary_analyzer.analyze_binary(f_path)
+            else:
+                findings = static_analyzer.analyze_file(f_path, file_lang)
+            total_findings.extend(findings)
+
+    # 1. Statische Findings anzeigen
+    _render_results(total_findings, output, title_prefix="STATISCHE CODE-ANALYSE")
+
+    # 2. KI-Tiefenanalyse (falls aktiviert)
+    ai_review_results: List[AIReviewResult] = []
+    if ai and ai_reviewer:
+        target_files = files_to_analyze[:3]  # KI-Review für Zieldateien
+        for target_file in target_files:
+            f_lang = lang or detect_language(target_file)
+            if not f_lang or f_lang == "binary":
+                continue
+
+            with console.status(
+                f"[bold {COLOR_PURPLE}]🤖 Analysiere {target_file.name} mit {selected_provider}/{selected_model}...[/bold {COLOR_PURPLE}]",
+                spinner="dots12",
+            ):
+                review_res = ai_reviewer.review_with_details(target_file, f_lang, total_findings)
+                ai_review_results.append(review_res)
+
+        # Rendere KI-Tiefenanalyse-Abschnitt
+        _render_ai_section(ai_review_results, selected_provider, selected_model, debug=debug)
+
+        # Neue KI-Findings mit Gesamtergebnis verschmelzen
+        for r in ai_review_results:
+            if r.findings:
+                total_findings = ai_reviewer._merge_findings(total_findings, r.findings)
+
+    # Automatischer Fix falls angefordert
+    if fix and total_findings and llm_client:
+        for f_path in files_to_analyze:
+            f_lang = lang or detect_language(f_path)
+            if f_lang and f_lang != "binary":
+                file_findings = [f for f in total_findings if Path(f.file_path).name == f_path.name]
+                if file_findings:
+                    _handle_fix(f_path, f_lang, file_findings, llm_client, yes, selected_provider, selected_model)
+
+
+def _render_results(findings: List[Finding], output_format: str, title_prefix: str = "GEFUNDENE PROBLEME"):
+    if output_format == "json":
+        import json
+        out_list = [f.model_dump() for f in findings]
+        console.print(json.dumps(out_list, indent=2))
+        return
+
+    if not findings:
+        clean_panel = Panel(
+            f"[bold {COLOR_SUCCESS}]✅ Keine statischen Probleme gefunden![/bold {COLOR_SUCCESS}]\n"
+            f"[dim]Der Code entspricht allen statischen Sicherheits- und Qualitätsregeln.[/dim]",
+            border_style=COLOR_SUCCESS,
+            expand=False,
+        )
+        console.print(clean_panel)
+        console.print()
+        return
+
+    table = Table(
+        title=f"\n[bold {COLOR_PURPLE}]🔍 {title_prefix}[/bold {COLOR_PURPLE}] ({len(findings)} Finding(s))",
+        show_header=True,
+        header_style=f"bold {COLOR_BLUE}",
+        border_style=COLOR_INDIGO,
+        expand=True,
+    )
+    table.add_column("Schweregrad", width=14, justify="left")
+    table.add_column("Datei:Zeile", style="cyan", width=26)
+    table.add_column("Regel", style="bold #818CF8", width=14)
+    table.add_column("Beschreibung & Fix-Empfehlung", style=COLOR_TEXT)
+
+    for f in findings:
+        style_color, badge = SEVERITY_STYLES.get(f.severity, ("white", str(f.severity.value)))
+        loc = f"{Path(f.file_path).name}:{f.line if f.line is not None else '-'}"
+        desc_text = f"[{style_color}]{f.description}[/{style_color}]"
+        if f.suggested_fix:
+            desc_text += f"\n[dim italic]💡 Fix: {f.suggested_fix}[/dim italic]"
+
+        table.add_row(
+            f"[{style_color}]{badge}[/{style_color}]",
+            loc,
+            f.rule_id,
+            desc_text,
+        )
+
+    console.print(table)
+    console.print()
+
+
+def _render_ai_section(
+    ai_results: List[AIReviewResult],
+    provider: str,
+    model: str,
+    debug: bool = False,
+):
+    """Rendert den sichtbaren Abschnitt für die KI-Tiefenanalyse."""
+    console.print()
+    section_title = f"🤖 KI-TIEFENANALYSE ({provider}/{model})"
+
+    if not ai_results:
+        console.print(
+            Panel(
+                f"[bold {COLOR_ERROR}]❌ Keine Antwort von der KI-Engine ({provider}/{model}) erhalten.[/bold {COLOR_ERROR}]",
+                title=f"[bold {COLOR_PURPLE}]{section_title}[/bold {COLOR_PURPLE}]",
+                border_style=COLOR_ERROR,
+                expand=False,
+            )
+        )
+        return
+
+    for res in ai_results:
+        telemetry = (
+            f"[dim]Dauer: [bold cyan]{res.duration_seconds}s[/bold cyan] • "
+            f"Tokens: [bold cyan]{res.total_tokens}[/bold cyan] (Prompt: {res.prompt_tokens}, Completion: {res.completion_tokens}) • "
+            f"Modell: [bold cyan]{res.model}[/bold cyan][/dim]"
+        )
+
+        content_lines = []
+        if res.error:
+            content_lines.append(f"[bold {COLOR_ERROR}]❌ KI-Fehler:[/bold {COLOR_ERROR}] {res.error}")
+        else:
+            if res.summary:
+                content_lines.append(f"[bold white]Zusammenfassung:[/bold white] {res.summary}")
+
+            if res.findings:
+                content_lines.append(f"\n[bold {COLOR_PURPLE}]Gefundene KI-Hinweise & Empfehlungen ({len(res.findings)}):[/bold {COLOR_PURPLE}]")
+                for idx, f in enumerate(res.findings, 1):
+                    style_color, badge = SEVERITY_STYLES.get(f.severity, ("white", f.severity.value))
+                    line_str = f"Zeile {f.line}" if f.line else "Allgemein"
+                    content_lines.append(f"  {idx}. [{style_color}]{badge}[/{style_color}] [cyan]({line_str})[/cyan]: {f.description}")
+                    if f.suggested_fix:
+                        content_lines.append(f"     [dim italic]💡 Empfehlung: {f.suggested_fix}[/dim italic]")
+            else:
+                content_lines.append(f"\n[bold {COLOR_SUCCESS}]✅ Keine zusätzlichen Probleme durch KI gefunden.[/bold {COLOR_SUCCESS}]")
+
+        content_lines.append(f"\n{telemetry}")
+
+        console.print(
+            Panel(
+                "\n".join(content_lines),
+                title=f"[bold {COLOR_PURPLE}]{section_title}[/bold {COLOR_PURPLE}]",
+                border_style=COLOR_INDIGO,
+                expand=False,
+            )
+        )
+
+        # Debug Panel (falls --debug aktiviert oder Rohantwort gewünscht)
+        if debug and res.raw_response:
+            syntax_raw = Syntax(res.raw_response, "json", theme="monokai", line_numbers=True)
+            console.print(
+                Panel(
+                    syntax_raw,
+                    title=f"[bold #fb923c]🛠️ DEBUG: Rohtext-Antwort von {provider}/{model}[/bold #fb923c]",
+                    border_style="#fb923c",
+                    expand=False,
+                )
+            )
+
+    console.print()
+
+
+def _handle_fix(
+    file_path: Path,
+    language: str,
+    findings: List[Finding],
+    llm_client: LLMClient,
+    auto_confirm: bool,
+    provider: str,
+    model: str,
+):
+    try:
+        source_code = file_path.read_text(encoding="utf-8", errors="replace")
+    except Exception as e:
+        console.print(f"[bold {COLOR_ERROR}]❌ Fehler beim Lesen von {file_path.name}:[/bold {COLOR_ERROR}] {e}")
+        return
+
+    findings_text = "\n".join(
+        [f"- Line {f.line or '?'}: {f.description} (Suggested fix: {f.suggested_fix or 'N/A'})" for f in findings]
+    )
+    fix_prompt = FIX_PROMPT_TEMPLATE.format(
+        file_path=str(file_path),
+        language=language,
+        findings_text=findings_text,
+        source_code=source_code,
+    )
+
+    clean_code = ""
+    with console.status(
+        f"[bold {COLOR_PURPLE}]Generiere KI-Korrektur mit {provider}/{model}...[/bold {COLOR_PURPLE}]",
+        spinner="dots12",
+    ):
+        try:
+            raw_fixed = llm_client.complete(
+                fix_prompt,
+                system="Du bist ein Sicherheitsexperte. Ersetze eval() IMMER durch ast.literal_eval(). Entferne alle print() Debug-Meldungen. Gib NUR den korrigierten Code zurück."
+            )
+            clean_code = PatchGenerator.extract_code_from_markdown(raw_fixed)
+        except Exception as e:
+            console.print(f"\n[bold {COLOR_ERROR}]❌ KI-Fix Fehler:[/bold {COLOR_ERROR}] {e}\n")
+            return
+
+    diff = PatchGenerator.generate_diff(source_code, clean_code, file_path=file_path.name)
+    if not diff:
+        console.print(f"[dim]Keine Diff-Änderung von der KI für {file_path.name} vorgeschlagen.[/dim]")
+        return
+
+    syntax_diff = Syntax(diff, "diff", theme="monokai", line_numbers=True)
+    console.print(
+        Panel(
+            syntax_diff,
+            title=f"[bold {COLOR_SUCCESS}]Vorgeschlagener Patch für {file_path.name}[/bold {COLOR_SUCCESS}]",
+            border_style=COLOR_INDIGO,
+            expand=False,
+        )
+    )
+
+    should_apply = auto_confirm
+    if not auto_confirm:
+        should_apply = click.confirm(f"Diesen Patch auf {file_path.name} anwenden?", default=True)
+
+    if should_apply:
+        applier = PatchApplier(backup=True)
+        if applier.apply_fix(file_path, clean_code):
+            console.print(f"\n[bold {COLOR_SUCCESS}]✅ Patch erfolgreich angewendet![/bold {COLOR_SUCCESS}] [dim](Backup: {file_path.name}.bak)[/dim]\n")
+        else:
+            console.print(f"\n[bold {COLOR_ERROR}]❌ Fehler beim Schreiben des Patches auf {file_path.name}[/bold {COLOR_ERROR}]\n")
+

centicodehelp/cli/commands/check.py

@@ -0,0 +1,91 @@
+from pathlib import Path
+import click
+from rich.table import Table
+from rich.panel import Panel
+
+from centicodehelp.analysis.detector import detect_language
+from centicodehelp.analysis.static_analyzer import StaticAnalyzer
+from centicodehelp.analysis.binary_analyzer import BinaryAnalyzer
+from centicodehelp.core.models import Finding, Severity
+from centicodehelp.cli.theme import (
+    console,
+    COLOR_PURPLE,
+    COLOR_BLUE,
+    COLOR_INDIGO,
+    COLOR_SUCCESS,
+    COLOR_ERROR,
+    COLOR_CRITICAL,
+    COLOR_HIGH,
+    COLOR_MEDIUM,
+    COLOR_LOW,
+    COLOR_INFO,
+    COLOR_TEXT,
+)
+
+SEVERITY_STYLES = {
+    Severity.CRITICAL: (COLOR_CRITICAL, "🔴 CRITICAL"),
+    Severity.HIGH: (f"bold {COLOR_HIGH}", "🟠 HIGH"),
+    Severity.MEDIUM: (f"bold {COLOR_MEDIUM}", "🟡 MEDIUM"),
+    Severity.LOW: (f"{COLOR_LOW}", "🔵 LOW"),
+    Severity.INFO: (f"{COLOR_INFO}", "⚪ INFO"),
+}
+
+@click.command(name="check", help="Schnellcheck einer einzelnen Datei (statisch).")
+@click.argument("file_path", type=click.Path(exists=False), required=True)
+def check_cmd(file_path: str):
+    """
+    ct check <datei> - Schnelle, kinderleichte Dateiüberprüfung.
+    """
+    path = Path(file_path)
+    if not path.exists() or not path.is_file():
+        console.print(f"\n[bold {COLOR_ERROR}]❌ Datei nicht gefunden:[/bold {COLOR_ERROR}] [white]{file_path}[/white]\n")
+        return
+
+    lang = detect_language(path)
+    if not lang:
+        console.print(f"\n[bold {COLOR_MEDIUM}]⚠️ Dateityp von {path.name} wird nicht unterstützt.[/bold {COLOR_MEDIUM}]\n")
+        return
+
+    static_analyzer = StaticAnalyzer()
+    binary_analyzer = BinaryAnalyzer()
+
+    with console.status(f"[bold {COLOR_PURPLE}]Prüfe {path.name}...[/bold {COLOR_PURPLE}]", spinner="dots"):
+        if lang == "binary":
+            findings = binary_analyzer.analyze_binary(path)
+        else:
+            findings = static_analyzer.analyze_file(path, lang)
+
+    console.print()
+    if not findings:
+        console.print(
+            Panel(
+                f"[bold {COLOR_SUCCESS}]✅ Keine Probleme gefunden![/bold {COLOR_SUCCESS}]\n"
+                f"[white]Die Datei [bold cyan]{path.name}[/bold cyan] ({lang}) ist sauber.[/white]",
+                title=f"[bold {COLOR_PURPLE}]âš¡ centicodehelp CHECK[/bold {COLOR_PURPLE}]",
+                border_style=COLOR_SUCCESS,
+                expand=False,
+            )
+        )
+        console.print()
+        return
+
+    table = Table(
+        title=f"[bold {COLOR_PURPLE}]âš¡ DATEICHECK:[/bold {COLOR_PURPLE}] [yellow]{path.name}[/yellow] ({len(findings)} Problem(e))",
+        show_header=True,
+        header_style=f"bold {COLOR_BLUE}",
+        border_style=COLOR_INDIGO,
+    )
+    table.add_column("Schweregrad", width=14)
+    table.add_column("Zeile", width=8, justify="right")
+    table.add_column("Was ist falsch?", style=COLOR_TEXT)
+    table.add_column("Tipp / Lösung", style="italic dim cyan")
+
+    for f in findings:
+        color, badge = SEVERITY_STYLES.get(f.severity, ("white", f.severity.value))
+        line_str = str(f.line) if f.line is not None else "-"
+        fix_str = f.suggested_fix or "Prüfen und korrigieren"
+        table.add_row(f"[{color}]{badge}[/{color}]", line_str, f.description, fix_str)
+
+    console.print(table)
+    console.print(f"[dim]Tipp: Repariere die Datei automatisch mit [bold {COLOR_BLUE}]ct fix {path}[/bold {COLOR_BLUE}][/dim]\n")
+

centicodehelp/cli/commands/config.py

@@ -0,0 +1,67 @@
+import click
+from rich.table import Table
+from rich.panel import Panel
+
+from centicodehelp.core.config import load_config, save_config, get_config_path
+from centicodehelp.cli.theme import (
+    console,
+    COLOR_PURPLE,
+    COLOR_BLUE,
+    COLOR_INDIGO,
+    COLOR_SUCCESS,
+    COLOR_ERROR,
+    COLOR_TEXT,
+)
+
+@click.group(name="config", help="centicodehelp Einstellungen und API-Schlüssel verwalten.")
+def config_cmd():
+    """Konfiguration für centicodehelp."""
+    pass
+
+@config_cmd.command(name="show", help="Aktuelle Konfiguration übersichtlich anzeigen.")
+def show_config():
+    config = load_config()
+    cfg_path = get_config_path()
+
+    table = Table(
+        title=f"\n[bold {COLOR_PURPLE}]⚙️ centicodehelp KONFIGURATION[/bold {COLOR_PURPLE}]",
+        caption=f"[dim]Speicherort: {cfg_path}[/dim]",
+        show_header=True,
+        header_style=f"bold {COLOR_BLUE}",
+        border_style=COLOR_INDIGO,
+        expand=True,
+    )
+    table.add_column("Einstellung", style=f"bold {COLOR_PURPLE}", width=24)
+    table.add_column("Wert", style=COLOR_TEXT)
+
+    table.add_row("Standard-Anbieter", f"[bold {COLOR_BLUE}]{config.default_provider}[/bold {COLOR_BLUE}]")
+    table.add_row("Standard-Modell", f"[cyan]{config.default_model}[/cyan]")
+    table.add_row("Ollama API URL", config.ollama_base_url)
+    table.add_row("Automatisches Backup (.bak)", f"[{COLOR_SUCCESS}]Aktiviert[/{COLOR_SUCCESS}]" if config.auto_backup else "[dim]Deaktiviert[/dim]")
+
+    if config.api_keys:
+        keys_summary = ", ".join([f"[bold {COLOR_BLUE}]{k}[/bold {COLOR_BLUE}]: [dim]••••{v[-4:] if len(v)>4 else '••••'}[/dim]" for k, v in config.api_keys.items()])
+        table.add_row("Konfigurierte API-Keys", keys_summary)
+    else:
+        table.add_row("Konfigurierte API-Keys", "[dim italic]Keine (Verwende Umgebungsvariablen wie OPENAI_API_KEY)[/dim italic]")
+
+    console.print(table)
+    console.print()
+
+@config_cmd.command(name="set-key", help="API-Schlüssel für einen Anbieter hinterlegen.")
+@click.argument("provider")
+@click.argument("api_key")
+def set_key(provider: str, api_key: str):
+    config = load_config()
+    config.api_keys[provider.lower()] = api_key
+    save_config(config)
+    console.print(f"\n[bold {COLOR_SUCCESS}]✅ API-Schlüssel für[/bold {COLOR_SUCCESS}] [bold {COLOR_PURPLE}]{provider}[/bold {COLOR_PURPLE}] [bold {COLOR_SUCCESS}]gespeichert![/bold {COLOR_SUCCESS}]\n")
+
+@config_cmd.command(name="set-default-model", help="Standardmodell festlegen.")
+@click.argument("model")
+def set_default_model(model: str):
+    config = load_config()
+    config.default_model = model
+    save_config(config)
+    console.print(f"\n[bold {COLOR_SUCCESS}]✅ Standardmodell geändert auf:[/bold {COLOR_SUCCESS}] [bold {COLOR_BLUE}]{model}[/bold {COLOR_BLUE}]\n")
+