72832f4ef2259d5c0fb3513e6af528220387435e

Docker

@@ -1,11 +0,0 @@
-docker run -it -p 7860:7860 --platform=linux/amd64 \
-	-e HF_READ_TOKEN="YOUR_VALUE_HERE" \
-	-e HF_TOKEN="YOUR_VALUE_HERE" \
-	-e WP_APP_PASSWORD="YOUR_VALUE_HERE" \
-	-e DIGITAL_PRODUCT_CSV_URL="https://docs.google.com/spreadsheets/d/1ARXP9Oh5dp0uS0N09ymGJMDsLaAbzcWihb-jaaUwIuI/export?format=csv&gid=2026061006" \
-	-e DEEPSEEK_MEMORY_CSV_URL="https://docs.google.com/spreadsheets/d/14XwhyeMxZJbEKUcWfa4_D4fajnzMTgoblVz4lTXFRpE/export?format=csv&gid=419179114" \
-	-e DEFAULT_LANGUAGE="de" \
-	-e APP_ENV="production" \
-	-e WORDPRESS_AUTH_MODE="mcp" \
-	-e WORDPRESS_MCP_URL="https://public-api.wordpress.com/wpcom/v2/mcp/v1" \
-	registry.hf.space/sky-meilin-skyosfullcore:cpu-0040161-9lwc09te python app.py

README.md

@@ -1,70 +1,13 @@
 ---
 title: SkyOSFullCore
-emoji: 🌌
-colorFrom: blue
-colorTo: indigo
+emoji: 👁
+colorFrom: gray
+colorTo: blue
 sdk: gradio
-sdk_version: 6.19.0
+sdk_version: 6.14.0
+python_version: '3.13'
 app_file: app.py
 pinned: false
 ---
 
-# SkyOS – Universal Control Center & Creator OS
-**Version:** `skyos_v3_core_2026_06_28`  
-**Plattform-Kompatibilität:** Optimiert für Android 15 (Redmi 13) & Hugging Face Spaces Runtime
-
----
-
-## 🏢 System-Architektur
-
-SkyOS ist ein modular aufgebautes Betriebssystem zur Automatisierung von Agentur-Prozessen, Lead-Verarbeitung, Trend-Vorhersagen und Content-Infrastrukturen. Die Architektur trennt strikt die Benutzeroberfläche von der Verarbeitungslogik und den Daten-Gateways.
-
-### 📁 Modul-Übersicht
-
-* **`app.py` (v3_audio):** Das zentrale Steuerpult. Eine schlanke Gradio-Oberfläche, die vollständig dynamisch geladen wird und sowohl Textbefehle als auch native Audio-Direktaufnahmen verarbeitet.
-* **`agency_core.py`:** Die Single Source of Truth für das Agentur-Grid. Verwaltet 15 Fachabteilungen, aufgeteilt in 5 strategische Cluster. Jede Abteilung entspricht einer isolierten Location (Tabellenplatz) im Google Sheets Backend.
-* **`audio_core.py`:** Das Sprachverarbeitungs-Modul. Verarbeitet `.wav`/`.mp3`-Streams aus dem UI-Mikrofon, transkribiert diese über Whisper und speist die Text-Intents direkt in den Core-Router ein.
-* **`router.py`:** Nimmt universale Befehle entgegen, validiert System-Status und verteilt die Aufgaben an die Sub-Module. Enthält eine abgesicherte Fehlerbehandlung (`safe_status_query`), um JSON-Parse-Fehler im Frontend zu verhindern.
-* **`extractor.py` / `crm_core.py`:** Analysiert eingehende Nachrichten auf Intents, extrahiert Kontakt- und Prioritätsdaten für die Lead-Pipeline.
-* **`trend_predictor.py`:** Mathematische Engine zur Berechnung des *Virality Index* basierend auf Share-Rate, Interaktionstiefe, Hook-Stärke und Marktsättigung.
-* **`worklog.py`:** Protokolliert jede System-Aktion im JSONL-Stream zur lückenlosen Diagnose.
-* **`sheets_gateway.py`:** Die Schnittstelle zur persistenten Live-Datenbank (`best_practice`), die Änderungen direkt in das korrespondierende Tabellenblatt einträgt.
-
----
-
-## 🗂️ Multidimensionales Agentur-Grid
-
-Die Zuweisung und Speicherung erfolgt automatisiert über die in `agency_core.py` definierten Cluster und deren Tabellenplätze:
-
-### 1. Management & Operations
-* **Executive Leadership (CEO, Managing Director):** `executive_leadership`
-* **Operations / Administration (HR, Finance, Legal):** `operations_admin`
-* **Project Management:** `project_management`
-
-### 2. Client & Strategy
-* **Account Management / Client Services:** `account_management`
-* **Strategy & Planning:** `strategy_planning`
-
-### 3. Creation & Content
-* **Creative Department (Design, Copywriting):** `creative_department`
-* **Content Marketing:** `content_marketing`
-* **Social Media Management:** `social_media`
-* **Community Management:** `community_management`
-
-### 4. Technical & Performance Marketing
-* **SEO / Technical SEO:** `seo_technical`
-* **Paid Media / PPC:** `paid_media`
-* **Media Buying:** `media_buying`
-* **Email Marketing:** `email_marketing`
-
-### 5. Tech & Data
-* **Development / Engineering / Web Development:** `development_engineering`
-* **Analytics & Data / Business Intelligence:** `analytics_bi`
-
----
-
-## 🚀 Installation & Start
-
-### Voraussetzungen
-```bash
-pip install gradio openai-whisper
+Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

SKYOS_BLUEPRINT_PHASE_1.md

@@ -1,22 +1,24 @@
-# Sky - Die Lösung: Phase 1 - Ökosystem-Setup Blueprint
+Kann meine Nummer# Sky - Die Lösung: Phase 1 - Ökosystem-Setup Blueprint
 
 ## 1. Startpunkt für die Verbindungen festlegen (Der Gateway)
-* **Komponente:** Layer 1: Hugging Face Space (Gradio UI & Core Engine).
-* **Rolle:** Zentrale Steuereinheit und Schnittstelle.
-* **Funktion:** Verarbeitet alle eingehenden Anfragen (z. B. via Webhooks von Telegram, WordPress oder Zapier) direkt im Space.
-* **Aktion:** `app.py` als primären API-Endpoint und Interface definieren.
+- **Komponente:** Layer 2: Firebase Functions (Backend Logic).
+- **Rolle:** Unüberwindbarer Gateway und zentrale Schleuse.
+- **Funktion:** Alle Anfragen vom Hugging Face Space (Layer 1) werden an einen verschlüsselten Firebase Endpoint gesendet.
+- **Aktion:** Firebase Function als Haupt-API-Endpoint definieren.
 
 ## 2. API bereitstellen (Die Proprietäre Schnittstelle)
-* **Public/Private Routing:**
-    * Der `SkyOrchestrator` fängt Anfragen ab und routet sie intern an die spezifischen Module (`hermes`, `deepseek`, `joyai`).
-    * Der `router_publish.py` übernimmt die direkte, gesicherte Kommunikation mit externen APIs (WordPress MCP, Telegram).
-* **IP-Schutz:** Die Logik und die Prompts werden innerhalb des privaten Hugging Face Spaces gekapselt. Die sensiblen Endpunkte und Keys werden ausschließlich über geschützte Umgebungsvariablen (Secrets) im Container geladen.
+- **Public API (Layer 1 zu Layer 2):**
+    - Gradio App konfiguriert, um Benutzeranfrage via **HTTP POST** an den Firebase Function Endpoint zu senden.
+- **Private API (Layer 2 zu Layer 3):**
+    - Firebase führt **Validierungen** durch (Rate Limiting, Usage Tracking).
+    - Ruft die **Layer 3: Core Logic** auf (Proprietary Prompt Engineering).
+- **IP-Schutz:** Sicherstellen, dass Layer 3 nur **intern** von Firebase aufgerufen werden kann und die eigentliche Logik niemals exponiert wird.
 
 ## 3. Daten einspeisen (Context Injection)
-* **Datenquelle:** 200 Assets des generischen KI-Influencer-Assets (gestreamt via Google Sheets CSV-URLs und Hugging Face Datasets).
-* **Format:** Strukturierte Metadaten und bereinigte Kontext-Vektoren (durchgeführt via `cleaner.py`, `chunker.py` und `embeddings.py`).
-* **Integration:** Die extrahierten Chunks bilden den **"Context Injection"**-Teil des internen Workflows:
-    1. **Base Prompt Template:** System-Anweisungen für die Persona.
-    2. **Context Injection:** Dynamisch geladene Chunks der 200 Assets (z. B. aus dem Contentplan, Fanvue-Guide oder den Produkt-Tabellen).
-    3. **Style Transfer Layer:** Anpassung des Outputs an das gewünschte Ziel-Format (z. B. WordPress-Post, Telegram-Nachricht).
-* **Ziel:** Maximale Relevanz ohne Kontext-Overhead zur Vorbereitung des Custom Model Fine-tunings für den unfairen Vorteil.
+- **Datenquelle:** 200 Assets des generischen KI-Influencer-Assets.
+- **Format:** Strukturierte Metadaten und Kontext-Vektoren.
+- **Integration:** Die Vektoren bilden den **"Context Injection"**-Teil des internen Workflows:
+    1. Base Prompt Template
+    2. Context Injection (Deine 200 Assets)
+    3. Style Transfer Layer
+- **Ziel:** Optimales Informieren des Custom Model Fine-tunings für den unfairen Vorteil.

agency_core.py

@@ -1,176 +0,0 @@
-"""
-agency_core.py
-SkyOS Agency Architecture Core
-Version: skyos_agency_core_v1_2026_06_28
-Verwaltet die Abteilungsstrukturen, Rollen-Mappings und Berechtigungen separat von app.py.
-"""
-
-from __future__ import annotations
-from typing import Any, Dict, List, Optional
-
-AGENCY_CORE_VERSION = "skyos_agency_core_v1_2026_06_28"
-
-# Definition der exakten Abteilungsstruktur (Single Source of Truth)
-DEPARTMENTS: Dict[str, Dict[str, Any]] = {
-    "executive_leadership": {
-        "name": "Executive Leadership (CEO, Managing Director)",
-        "cluster": "Management & Operations",
-        "description": "Gesamtstrategie, Vision, Skalierung und finale Freigaben.",
-        "allowed_routers": ["router.py", "router_publish.py"]
-    },
-    "account_management": {
-        "name": "Account Management / Client Services",
-        "cluster": "Client & Strategy",
-        "description": "Kundenbetreuung, Onboarding, Upselling und primäre Schnittstelle für Leads.",
-        "allowed_routers": ["router.py"]
-    },
-    "strategy_planning": {
-        "name": "Strategy & Planning",
-        "cluster": "Client & Strategy",
-        "description": "Konzeption, Marktanalysen, Zielgruppendefinition und Kampagnenausrichtung.",
-        "allowed_routers": ["router.py"]
-    },
-    "creative_department": {
-        "name": "Creative Department (Design, Copywriting)",
-        "cluster": "Creation & Content",
-        "description": "Visuelle Assets, Werbetexte, Branding, Layouts und Skripte.",
-        "allowed_routers": ["router.py"]
-    },
-    "content_marketing": {
-        "name": "Content Marketing",
-        "cluster": "Creation & Content",
-        "description": "Langfristige Content-Strategien, Blog-Artikel, Whitepaper und SEO-Inhalte.",
-        "allowed_routers": ["router.py"]
-    },
-    "seo_technical": {
-        "name": "SEO / Technical SEO",
-        "cluster": "Technical & Performance Marketing",
-        "description": "Organische Reichweite, OnPage-/OffPage-Optimierung, Core Web Vitals.",
-        "allowed_routers": ["router.py"]
-    },
-    "paid_media": {
-        "name": "Paid Media / PPC",
-        "cluster": "Technical & Performance Marketing",
-        "description": "Bezahlte Werbekampagnen auf Google Ads, Meta Ads, TikTok Ads.",
-        "allowed_routers": ["router.py"]
-    },
-    "social_media": {
-        "name": "Social Media Management",
-        "cluster": "Creation & Content",
-        "description": "Kanalkuration, Redaktionspläne, Posting-Taktung (TikTok, Instagram).",
-        "allowed_routers": ["router.py", "router_publish.py"]
-    },
-    "email_marketing": {
-        "name": "Email Marketing",
-        "cluster": "Technical & Performance Marketing",
-        "description": "Newsletter, automatisierte E-Mail-Funnel, Lead-Nurturing.",
-        "allowed_routers": ["router.py"]
-    },
-    "analytics_bi": {
-        "name": "Analytics & Data / Business Intelligence",
-        "cluster": "Tech & Data",
-        "description": "Tracking-Infrastruktur, Live-Dashboards, ROI-Berechnung.",
-        "allowed_routers": ["router.py"]
-    },
-    "development_engineering": {
-        "name": "Development / Engineering / Web Development",
-        "cluster": "Tech & Data",
-        "description": "WordPress-Setups, API-Anbindungen, SkyOS Core-Entwicklung.",
-        "allowed_routers": ["router.py", "router_publish.py"]
-    },
-    "operations_admin": {
-        "name": "Operations / Administration (HR, Finance, Legal)",
-        "cluster": "Management & Operations",
-        "description": "Verträge, Rechnungsstellung, HR-Prozesse, interne Compliance.",
-        "allowed_routers": ["router.py"]
-    },
-    "media_buying": {
-        "name": "Media Buying",
-        "cluster": "Technical & Performance Marketing",
-        "description": "Einkauf von Werbeplätzen, Budget-Verwaltung, Verhandlungen.",
-        "allowed_routers": ["router.py"]
-    },
-    "community_management": {
-        "name": "Community Management",
-        "cluster": "Creation & Content",
-        "description": "Interaktion mit Followern, Kommentar-Moderation, DM-Automations.",
-        "allowed_routers": ["router.py"]
-    },
-    "project_management": {
-        "name": "Project Management",
-        "cluster": "Management & Operations",
-        "description": "Terminplanung, Ressourcenverteilung, Task-Monitoring.",
-        "allowed_routers": ["router.py"]
-    }
-}
-
-
-def get_agency_status() -> Dict[str, Any]:
-    """Gibt den Status und die Version des Agency-Moduls zurück."""
-    return {
-        "module": "agency_core",
-        "version": AGENCY_CORE_VERSION,
-        "status": "active",
-        "department_count": len(DEPARTMENTS)
-    }
-
-
-def get_department_details(dept_key: str) -> Optional[Dict[str, Any]]:
-    """Holt die Metadaten einer spezifischen Abteilung über ihren System-Key."""
-    return DEPARTMENTS.get(str(dept_key or "").lower().strip(), None)
-
-
-def get_departments_by_cluster(cluster_name: str) -> List[Dict[str, Any]]:
-    """Filtert alle Abteilungen, die zu einem bestimmten Cluster gehören."""
-    target_cluster = str(cluster_name or "").lower().strip()
-    result = []
-    for _, data in DEPARTMENTS.items():
-        if target_cluster in data["cluster"].lower():
-            result.append(data)
-    return result
-
-
-def route_task_to_department(task_description: str) -> Dict[str, Any]:
-    """
-    Heuristische Intent-Erkennung, um eine Aufgabe automatisch 
-    der passenden Abteilung zuzuweisen.
-    """
-    text = str(task_description or "").lower().strip()
-    
-    if any(w in text for w in ["code", "bug", "api", "server", "datenbank", "plugin", "wordpress"]):
-        dept = "development_engineering"
-    elif any(w in text for w in ["rechnung", "vertrag", "geld", "finance", "legal", "mitarbeiter"]):
-        dept = "operations_admin"
-    elif any(w in text for w in ["seo", "keywords", "ranking", "search", "vitals"]):
-        dept = "seo_technical"
-    elif any(w in text for w in ["ads", "ppc", "google ads", "meta ads", "kampagne"]):
-        dept = "paid_media"
-    elif any(w in text for w in ["newsletter", "mail", "funnel", "automation"]):
-        dept = "email_marketing"
-    elif any(w in text for w in ["tracking", "dashboard", "analytics", "daten", "report"]):
-        dept = "analytics_bi"
-    elif any(w in text for w in ["design", "logo", "copy", "texten", "werbetext", "grafik"]):
-        dept = "creative_department"
-    elif any(w in text for w in ["posting", "instagram", "tiktok", "reel", "shorts", "planen"]):
-        dept = "social_media"
-    elif any(w in text for w in ["kommentar", "dm", "nachricht", "interaktion", "community"]):
-        dept = "community_management"
-    elif any(w in text for w in ["termin", "deadline", "zeitplan", "board", "task"]):
-        dept = "project_management"
-    elif any(w in text for w in ["kunde", "onboarding", "absprache", "call"]):
-        dept = "account_management"
-    elif any(w in text for w in ["strategie", "analyse", "ausrichtung", "konzept"]):
-        dept = "strategy_planning"
-    else:
-        dept = "project_management"  # Default-Fallback
-        
-    return {
-        "status": "assigned",
-        "assigned_department_key": dept,
-        "department_name": DEPARTMENTS[dept]["name"],
-        "cluster": DEPARTMENTS[dept]["cluster"]
-    }
-
-
-if __name__ == "__main__":
-    print(get_agency_status())

app.py

@@ -1,89 +1,32 @@
-"""
-app.py
-SkyOS Dashboard Control Center – Simple Studio Edition
-Komplett fokussiert auf Streaming, Chat & Direktnavigation
-"""
-
 import gradio as gr
-from datetime import datetime
-import zoneinfo
-from persona_sky_meilin import (
-    AVATAR_PERSONA, AVATAR_JOBTITEL, COMPANY_NAME, SYSTEM_NAME,
-    LIGHTING_PROFILES, MATERIAL_PROFILES, build_studio_manifest
-)
-
-try:
-    from modules.avatar_streamer import AvatarStreamer
-    streamer = AvatarStreamer()
-    streamer.set_avatar(AVATAR_PERSONA)
-    AVATAR_READY = True
-except Exception as e:
-    AVATAR_READY = False
-
-tz_berlin = zoneinfo.ZoneInfo("Europe/Berlin")
+from fastapi import FastAPI, Request
+from pydantic import BaseModel
+from router import route, status
+from state_store import init_db
+from sheets_gateway import get_sheet_answer
 
-def handle_interaction(text, audio, lighting, material):
-    if not AVATAR_READY:
-        return "Eingabe registriert. Render-Pipeline wird vorbereitet.", None
-    
-    # Nutzt Text-Eingabe, fällt auf Audio-Verarbeitung zurück, falls Text leer ist
-    input_source = text if text else "Sprachbefehl verarbeitet."
-    manifest = build_studio_manifest(input_source, lighting, material)
-    
-    streamer.start_stream()
-    streamer.send_message(f"Execute: {manifest}")
-    
-    response = "Ich starte das Live-Streaming mit den gewünschten visuellen Anpassungen."
-    return [(input_source, response)], None
+app = FastAPI()
 
-with gr.Blocks(theme=gr.themes.Soft(), title=f"{SYSTEM_NAME} Dashboard") as demo:
-    
-    # ================= HEADER =================
-    with gr.Row():
-        gr.Markdown(f"# 🌌 {SYSTEM_NAME} – {AVATAR_PERSONA} Studio")
+class MessageRequest(BaseModel):
+    message: str
+    level: str = "fully_open"
 
-    # ================= CORE INTERFACE =================
-    with gr.Row():
-        # Linke Spalte: Streaming-Fenster (9:16)
-        with gr.Column(scale=1):
-            avatar_video_output = gr.Video(
-                label="Studio Stream (9:16)",
-                interactive=False
-            )
-        
-        # Rechte Spalte: Chat & Steuerung
-        with gr.Column(scale=2):
-            chat_feed = gr.Chatbot(label="Chat-Interface (Aktiv wenn kein Stream)")
-            
-            with gr.Row():
-                msg_input = gr.Textbox(placeholder="Nachricht oder Skript eingeben...", label="Texteingabe", scale=3)
-                audio_input = gr.Audio(sources=["microphone"], type="filepath", label="Spracheingabe", scale=2)
-            
-            with gr.Row():
-                lighting_profile = gr.Dropdown(choices=list(LIGHTING_PROFILES.keys()), value="Golden Hour", label="☀️ Licht")
-                material_profile = gr.Dropdown(choices=list(MATERIAL_PROFILES.keys()), value="Lack & Leder (High-Gloss)", label="🧥 Outfit")
-            
-            submit_btn = gr.Button("Senden & Streamen", variant="primary")
+@app.post("/process")
+@app.post("/webhook/zapier")
+async def handle_request(req: MessageRequest):
+    result = route(message=req.message, level=req.level)
+    return {"success": True, "response": str(result.get("response", result))}
 
-    gr.HTML("<hr style='border: 1px solid #e5e7eb; margin: 20px 0;'>")
+@app.get("/")
+def root():
+    return {"status": "online", "router": status()}
 
-    # ================= NAVIGATION (Ziele) =================
-    gr.Markdown("### 🏢 Bereiche öffnen")
-    with gr.Row():
-        # Die Buttons nutzen target="_blank" im HTML-Kontext, um isolierte Tabs zu öffnen
-        gr.HTML(f'<a href="/management" target="_blank"><button style="width:100%; padding:15px; background-color:#f3f4f6; border:1px solid #d1d5db; border-radius:8px; cursor:pointer;">💼 1. Management & Operations</button></a>')
-        gr.HTML(f'<a href="/client" target="_blank"><button style="width:100%; padding:15px; background-color:#f3f4f6; border:1px solid #d1d5db; border-radius:8px; cursor:pointer;">🤝 2. Client & Strategy</button></a>')
-        gr.HTML(f'<a href="/creation" target="_blank"><button style="width:100%; padding:15px; background-color:#f3f4f6; border:1px solid #d1d5db; border-radius:8px; cursor:pointer;">🎨 3. Creation & Content</button></a>')
-    with gr.Row():
-        gr.HTML(f'<a href="/technical" target="_blank"><button style="width:100%; padding:15px; background-color:#f3f4f6; border:1px solid #d1d5db; border-radius:8px; cursor:pointer;">📊 4. Technical & Performance</button></a>')
-        gr.HTML(f'<a href="/data" target="_blank"><button style="width:100%; padding:15px; background-color:#f3f4f6; border:1px solid #d1d5db; border-radius:8px; cursor:pointer;">⚡ 5. Tech & Data</button></a>')
+init_db()
 
-    # Event-Verknüpfung
-    submit_btn.click(
-        fn=handle_interaction,
-        inputs=[msg_input, audio_input, lighting_profile, material_profile],
-        outputs=[chat_feed, avatar_video_output]
-    )
+with gr.Blocks() as demo:
+    gr.Markdown("# SkyOS MCP Server v2")
+    gr.ChatInterface(fn=lambda m, h: str(route(m).get("response", "Error")))
 
 if __name__ == "__main__":
-    demo.launch(server_name="0.0.0.0", server_port=7860)
+    import uvicorn
+    uvicorn.run(app, host="0.0.0.0", port=7860)

audio_core.py

@@ -1,16 +0,0 @@
-import os
-import subprocess
-import sys
-from typing import Dict, Any
-
-# Erzwingt die Installation der Pakete direkt im laufenden Container
-try:
-    import whisper
-except ImportError:
-    subprocess.check_call([sys.executable, "-m", "pip", "install", "openai-whisper", "torch"])
-    import whisper
-
-try:
-    _model = whisper.load_model("base")
-except Exception:
-    _model = None

code_runner.py

@@ -4,44 +4,24 @@ from diffusers import AutoPipelineForText2Image, LCMScheduler
 model_id = "stabilityai/stable-diffusion-xl-base-1.0"
 lcm_lora_id = "latent-consistency/lcm-lora-sdxl"
 
-# Dynamische Geräte-Erkennung (CPU vs. CUDA)
-device = "cuda" if torch.cuda.is_available() else "cpu"
-torch_dtype = torch.float16 if device == "cuda" else torch.float32
+pipe = AutoPipelineForText2Image.from_pretrained(
+    model_id,
+    torch_dtype=torch.float16,
+    variant="fp16"
+)
 
-print(f"CodeRunner initialisiert. Nutze Gerät: {device} mit {torch_dtype}")
+pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
+pipe.to("cuda")
 
-try:
-    pipe = AutoPipelineForText2Image.from_pretrained(
-        model_id,
-        torch_dtype=torch_dtype,
-        variant="fp16" if device == "cuda" else None  # fp16-Variante läuft auf reinem CPU-Torch oft instabil
-    )
+pipe.load_lora_weights(lcm_lora_id)
+pipe.fuse_lora()
 
-    pipe.scheduler = LCMScheduler.from_config(pipe.scheduler.config)
-    
-    # Sicherer Transfer auf das verfügbare Gerät
-    if device == "cuda":
-        pipe.to("cuda")
-    else:
-        # Überlebenswichtig für CPU Spaces: Reduziert den RAM-Verbrauch drastisch
-        print("Optimiere Speicher für CPU-Betrieb...")
-        pipe.enable_attention_slicing()
+prompt = "Sky Meilin, consistent AI persona, creator system, cinematic portrait"
 
-    # LoRA Gewichte laden und fusionieren für maximalen Speedup
-    pipe.load_lora_weights(lcm_lora_id)
-    pipe.fuse_lora()
+image = pipe(
+    prompt=prompt,
+    num_inference_steps=4,
+    guidance_scale=1.5
+).images[0]
 
-    prompt = "Sky Meilin, consistent AI persona, creator system, cinematic portrait"
-
-    # Generierung starten
-    image = pipe(
-        prompt=prompt,
-        num_inference_steps=4,
-        guidance_scale=1.5
-    ).images[0]
-
-    image.save("sky_output.png")
-    print("Bild erfolgreich generiert und als 'sky_output.png' gespeichert.")
-
-except Exception as e:
-    print(f"Fehler bei der Bildgenerierung in code_runner: {str(e)}")
+image.save("sky_output.png")

core/chunker.py

@@ -1,5 +1,6 @@
 from typing import List, Dict, Any, Optional
 
+
 class Chunker:
     """
     Splits raw text into chunks for:
@@ -17,6 +18,7 @@ class Chunker:
         Simple character-based chunking with overlap.
         Stable baseline for RAG pipelines.
         """
+
         if not text:
             return []
 
@@ -24,18 +26,14 @@ class Chunker:
         start = 0
         text_length = len(text)
 
-        # Absicherung: Schrittweite berechnen und Endlosschleife verhindern
-        step = self.chunk_size - self.overlap
-        if step <= 0:
-            step = 1
-
         while start < text_length:
             end = start + self.chunk_size
             chunk = text[start:end]
+
             chunks.append(chunk)
 
-            # Sicherer Vorwärtsschritt
-            start += step
+            # move forward with overlap
+            start += self.chunk_size - self.overlap
 
         return chunks
 
@@ -50,10 +48,12 @@ class Chunker:
         Returns:
             list of chunked documents with metadata
         """
+
         chunked_output = []
 
         for doc in documents:
             text = doc.get(field, "")
+
             chunks = self.chunk_text(text)
 
             for i, chunk in enumerate(chunks):
@@ -71,6 +71,7 @@ class Chunker:
         Optional smarter fallback:
         paragraph-aware chunking.
         """
+
         paragraphs = text.split("\n\n")
         chunks = []
         buffer = ""
@@ -86,4 +87,4 @@ class Chunker:
         if buffer:
             chunks.append(buffer.strip())
 
-        return chunks
+        return chunks

core/cleaner.py

@@ -2,20 +2,18 @@
 
 import re
 
+
 class Cleaner:
     def clean_text(self, text: str) -> str:
-        if not text:
-            return ""
-            
         text = text.lower()
 
-        # URLs entfernen (korrigiert auf \S+)
-        text = re.sub(r"http\S+", "", text)
+        # URLs entfernen
+        text = re.sub(r"http\\S+", "", text)
 
-        # Sonderzeichen reduzieren (korrigiert auf \s)
-        text = re.sub(r"[^a-zA-Z0-9äöüÄÖÜß\s]", " ", text)
+        # Sonderzeichen reduzieren
+        text = re.sub(r"[^a-zA-Z0-9äöüÄÖÜß\\s]", " ", text)
 
-        # Mehrfachspaces entfernen (korrigiert auf \s+)
-        text = re.sub(r"\s+", " ", text)
+        # Mehrfachspaces entfernen
+        text = re.sub(r"\\s+", " ", text)
 
-        return text.strip()
+        return text.strip()

core/deepseek.py

@@ -5,7 +5,7 @@ def process(message: str) -> str:
     Später kann hier eine echte API- oder Modell-Anbindung eingebaut werden.
     """
 
-    if message is None or not str(message).strip():
+    if not message or not str(message).strip():
         return "DeepSeek: Keine Eingabe erhalten."
 
     message = str(message).strip()
@@ -15,4 +15,4 @@ def process(message: str) -> str:
         f"Eingabe empfangen:\n{message}\n\n"
         "Analyse-Modus: aktiviert.\n"
         "Status: process() funktioniert."
-    )
+    )

core/embeddings.py

@@ -1,13 +1,11 @@
 from sentence_transformers import SentenceTransformer
 from typing import List, Union
-import numpy as np
 
 class Embedder:
     def __init__(self, model_name: str = "all-MiniLM-L6-v2"):
-        # Nutzt verfügbare Hardware (Cuda/CPU) automatisch
         self.model = SentenceTransformer(model_name)
 
-    def encode(self, texts: Union[str, List[str]], normalize: bool = True) -> np.ndarray:
+    def encode(self, texts: Union[str, List[str]], normalize: bool = True):
         """
         Encodes text(s) into embeddings.
 
@@ -18,16 +16,9 @@ class Embedder:
         Returns:
             numpy.ndarray embeddings
         """
-        if not texts:
-            return np.array([])
-
         if isinstance(texts, str):
-            if not texts.strip():
-                return np.array([])
             texts = [texts]
 
-        # Konvertiert leere Strings in der Liste, um Crashs zu vermeiden
-        texts = [t if t.strip() else " " for t in texts]
-
         embeddings = self.model.encode(texts, normalize_embeddings=normalize)
         return embeddings
+

core/hermes.py

@@ -4,7 +4,7 @@ def process(message: str) -> str:
     Verarbeitet eingehende Nachrichten für SkyOSFullCore.
     """
 
-    if message is None or not str(message).strip():
+    if not message or not str(message).strip():
         return "Hermes: Keine Eingabe erhalten."
 
     message = str(message).strip()
@@ -13,4 +13,4 @@ def process(message: str) -> str:
         "Hermes Core ist aktiv.\n\n"
         f"Eingabe empfangen:\n{message}\n\n"
         "Status: process() funktioniert."
-    )
+    )

core/joyai.py

@@ -4,7 +4,7 @@ def process(message: str) -> str:
     Kreativ-/Personality-Modul für SkyOSFullCore.
     """
 
-    if message is None or not str(message).strip():
+    if not message or not str(message).strip():
         return "JoyAI: Keine Eingabe erhalten."
 
     message = str(message).strip()
@@ -14,4 +14,4 @@ def process(message: str) -> str:
         f"Eingabe empfangen:\n{message}\n\n"
         "Kreativ-Modus: aktiviert.\n"
         "Status: process() funktioniert."
-    )
+    )

core/loader.py

@@ -3,49 +3,51 @@
 from datasets import load_dataset
 import os
 
+
 class DatasetLoader:
+
     def __init__(self):
+
         print("DatasetLoader geladen")
+
         self.hf_token = os.getenv("HF_TOKEN", None)
+
         self.datasets = {
             "matrix_game": "Skywork/Matrix-Game-3.0",
             "framework_storage": "sky-meilin/SkyAiFramework-storage"
         }
 
     def list_datasets(self):
+
         return list(self.datasets.keys())
 
-    def load(self, dataset_name: str, name: str = None):
+    def load(self, dataset_name: str):
+
         if dataset_name not in self.datasets:
+
             raise ValueError(
                 f"Dataset '{dataset_name}' nicht registriert."
             )
 
         dataset_path = self.datasets[dataset_name]
-        try:
-            # name erlaubt das Laden von Unterordnern/Konfigurationen, falls nötig
-            dataset = load_dataset(
-                dataset_path,
-                name=name,
-                token=self.hf_token
-            )
-            return dataset
-        except Exception as e:
-            raise RuntimeError(f"Fehler beim Laden von {dataset_name}: {str(e)}")
 
-    def load_split(self, dataset_name: str, split: str = None, name: str = None):
-        dataset = self.load(dataset_name, name=name)
+        dataset = load_dataset(
+            dataset_path,
+            token=self.hf_token
+        )
+
+        return dataset
 
-        # Falls das Dataset direkt ein einzelnes Dataset ist (kein Dict mit Splits)
-        if not hasattr(dataset, "keys"):
-            return dataset
+    def load_split(
+        self,
+        dataset_name: str,
+        split: str = None
+    ):
+
+        dataset = self.load(dataset_name)
 
         if split is None:
-            split = list(dataset.keys())[0]
 
-        if split not in dataset:
-            raise ValueError(
-                f"Split '{split}' existiert nicht. Verfügbar: {list(dataset.keys())}"
-            )
+            split = list(dataset.keys())[0]
 
-        return dataset[split]
+        return dataset[split]

core/orchestrator.py

@@ -1,8 +1,7 @@
-from . import hermes, deepseek, joyai
+from core import hermes, deepseek, joyai
 
 
 class SkyOrchestrator:
-
     def __init__(self):
         self.modules = {
             "hermes": hermes,
@@ -21,25 +20,25 @@ class SkyOrchestrator:
 
         try:
             return str(module.process(message))
+
         except Exception as e:
             return f"{module_name}: Fehler in process(): {str(e)}"
 
     def detect_modules(self, message: str) -> list:
         text = str(message or "").lower()
+
         selected = []
 
-        # Content / SEO / Business / Knowledge Sources
+        # Content / SEO / Business
         content_keywords = [
             "blog",
             "seo",
             "artikel",
             "content",
-            "contentplan",
-            "backlog",
             "social",
             "post",
             "marketing",
-            "fanvue",
+            "fanvue"
         ]
 
         # Technik / System
@@ -52,7 +51,7 @@ class SkyOrchestrator:
             "python",
             "telegram",
             "wordpress",
-            "gravatar",
+            "gravatar"
         ]
 
         # Kreativ / Persona
@@ -62,77 +61,115 @@ class SkyOrchestrator:
             "persona",
             "sky",
             "charakter",
-            "creator",
+            "creator"
         ]
 
         # Direkte Modulaufrufe behalten
         if "hermes" in text:
             selected.append("hermes")
+
         if "deepseek" in text:
             selected.append("deepseek")
+
         if "joy" in text or "joyai" in text:
             selected.append("joyai")
 
         # Automatische Intent-Erkennung
         if any(word in text for word in content_keywords):
-            selected.extend(["hermes", "deepseek"])
+            selected.extend([
+                "hermes",
+                "deepseek"
+            ])
+
         elif any(word in text for word in system_keywords):
-            selected.append("hermes")
+            selected.append(
+                "hermes"
+            )
+
         elif any(word in text for word in creative_keywords):
-            selected.append("joyai")
+            selected.append(
+                "joyai"
+            )
 
         # Fallback
         if not selected:
-            selected.append("hermes")
+            selected.append(
+                "hermes"
+            )
 
         return list(dict.fromkeys(selected))
 
     def process(self, message: str) -> str:
+
         if not message or not str(message).strip():
             return "SkyOrchestrator: Keine Eingabe erhalten."
 
-        selected_modules = self.detect_modules(message)
+        selected_modules = self.detect_modules(
+            message
+        )
+
         results = []
 
         for module_name in selected_modules:
-            results.append(self.safe_process(module_name, message))
-
-        # Hier wird vermerkt, falls nach Inhalten gesucht wurde, um das für den Router sichtbar zu machen
-        knowledge_note = ""
-        if any(
-            k in str(message).lower()
-            for k in ["contentplan", "backlog", "template", "storage"]
-        ):
-            knowledge_note = (
-                "ℹ️ Info: Anfrage betrifft Knowledge Sources / Contentplan.\n\n"
+
+            results.append(
+                self.safe_process(
+                    module_name,
+                    message
+                )
             )
 
         return (
             "SkyOrchestrator aktiv\n\n"
+
             f"Ausgewählte Module:\n"
             f"{', '.join(selected_modules)}\n\n"
-            f"{knowledge_note}"
+
             "Antworten:\n\n"
-            + "\n\n-------------------\n\n".join(results)
+
+            + "\n\n-------------------\n\n".join(
+                results
+            )
         )
 
     def status(self) -> str:
+
         active_modules = []
+
         for name, module in self.modules.items():
-            if module is not None and hasattr(module, "process"):
-                active_modules.append(f"✅ {name}")
+
+            if (
+                module is not None
+                and hasattr(module, "process")
+            ):
+
+                active_modules.append(
+                    f"✅ {name}"
+                )
+
             else:
-                active_modules.append(f"❌ {name}")
 
-        return "SkyOSFullCore Orchestrator Status\n\n" + "\n".join(active_modules)
+                active_modules.append(
+                    f"❌ {name}"
+                )
+
+        return (
+            "SkyOSFullCore Orchestrator Status\n\n"
+
+            + "\n".join(
+                active_modules
+            )
+        )
 
 
 orchestrator = SkyOrchestrator()
 
 
 def process(message: str) -> str:
-    return orchestrator.process(message)
+    return orchestrator.process(
+        message
+    )
 
 
 def status() -> str:
-    return orchestrator.status()
+    return orchestrator.status()

core/router.py

@@ -1,17 +1,4 @@
-import os
-import sys
-
-# Stellt sicher, dass das Hauptverzeichnis im Suchpfad ist, damit router_publish gefunden wird
-main_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), ".."))
-if main_dir not in sys.path:
-    sys.path.insert(0, main_dir)
-
-# Initialisierung der Fallback-Variablen
-can_handle_publish_route = lambda msg: False
-handle_publish_route = lambda msg: "Publish Router nicht verfügbar."
-get_publish_router_status = lambda: "inaktiv (Import-Fehler)"
-PUBLISH_ROUTER_IMPORT_ERROR = None
-
+# /app/router.py - Dieser Block muss den alten Import ersetzen
 try:
     from router_publish import (
         can_handle_publish_route as _can_handle_publish_route,
@@ -22,7 +9,6 @@ try:
     can_handle_publish_route = _can_handle_publish_route
     handle_publish_route = _handle_publish_route
     get_publish_router_status = _get_publish_router_status
-    
 except ImportError as e:
     PUBLISH_ROUTER_IMPORT_ERROR = f"ImportError: {e}"
 except Exception as exc:

crm_core.py

@@ -1,22 +1,11 @@
-"""
-crm_core.py
-SkyOS CRM Core
-Version: skyos_crm_core_v2_2026_06_04
-Verarbeitet Leads, Kontakte, Kundenstatus und bereitet Daten für den Sheets-Sync vor.
-"""
+# crm_core.py
+# SkyOS CRM Core
+# Version: skyos_crm_core_v2_2026_06_04
 
 from datetime import datetime
-import json
 
-CRM_CORE_VERSION = "skyos_crm_core_v2_2026_06_04"
 
-# Sicheres Laden des State Stores zur persistenten Event-Verfolgung
-STATE_STORE_AVAILABLE = False
-try:
-    from state_store import log_event
-    STATE_STORE_AVAILABLE = True
-except Exception:
-    pass
+CRM_CORE_VERSION = "skyos_crm_core_v2_2026_06_04"
 
 
 def crm_status():
@@ -68,7 +57,6 @@ def parse_lead_from_text(message: str):
 
     lead = create_lead(notes=text)
 
-    # Plattformen-Erkennung
     if "instagram" in lower:
         lead["Platform"] = "Instagram"
     elif "tiktok" in lower:
@@ -82,7 +70,6 @@ def parse_lead_from_text(message: str):
     elif "gmail" in lower or "email" in lower:
         lead["Platform"] = "Email"
 
-    # Prioritäten-Erkennung
     if "priorität hoch" in lower or "prio hoch" in lower or "high" in lower:
         lead["Priority"] = "high"
     elif "priorität niedrig" in lower or "prio niedrig" in lower or "low" in lower:
@@ -90,7 +77,6 @@ def parse_lead_from_text(message: str):
     else:
         lead["Priority"] = "medium"
 
-    # Status-Erkennung
     if "interessiert" in lower:
         lead["Status"] = "interested"
     elif "kontaktiert" in lower or "contacted" in lower:
@@ -100,7 +86,6 @@ def parse_lead_from_text(message: str):
     else:
         lead["Status"] = "new"
 
-    # Angebots-Erkennung
     if "agency" in lower or "agentur" in lower:
         lead["Offer"] = "Agency Angebot"
     elif "crm" in lower:
@@ -110,16 +95,11 @@ def parse_lead_from_text(message: str):
     elif "fanvue" in lower:
         lead["Offer"] = "Fanvue / Creator Angebot"
 
-    # Abgesicherte Namens-Extraktion (ignoriert URLs wie http:// oder https://)
-    if ":" in text and "http:" not in lower and "https:" not in lower:
+    if ":" in text:
         after_colon = text.split(":", 1)[1].strip()
         possible_name = after_colon.split(",", 1)[0].strip()
         if possible_name:
             lead["Name"] = possible_name
-    elif ":" in text and ("http:" in lower or "https:" in lower):
-        parts = text.split()
-        if len(parts) > 1 and not parts[1].startswith("http"):
-            lead["Name"] = parts[1].replace(",", "")
 
     return lead
 
@@ -139,23 +119,11 @@ def process_crm_message(message: str):
         or "followup" in lower
         or "crm" in lower
     ):
-        parsed_lead = parse_lead_from_text(text)
-        
-        # KORRIGIERT: Daten-Sicherung über den State Store, falls verfügbar
-        if STATE_STORE_AVAILABLE:
-            log_event(
-                message=f"Lead-Generierung für {parsed_lead['Name']}",
-                context=parsed_lead,
-                route_target="crm_core -> sheets_pipeline",
-                response="Lead erfolgreich erfasst und im State hinterlegt."
-            )
-
         return {
             "success": True,
             "action": "create_lead",
             "crm_core": CRM_CORE_VERSION,
-            "lead": parsed_lead,
-            "sync_status": "state_logged" if STATE_STORE_AVAILABLE else "volatile_memory"
+            "lead": parse_lead_from_text(text)
         }
 
     return {
@@ -167,4 +135,4 @@ def process_crm_message(message: str):
 
 
 if __name__ == "__main__":
-    print(crm_status())
+    print(crm_status())

extractor.py

@@ -2,16 +2,7 @@ from typing import Dict, Any
 
 
 def analyze_context(message: str) -> Dict[str, Any]:
-    # Text normalisieren und für Wort-Splitting vorbereiten
-    text_raw = message.lower()
-    
-    # Satzzeichen entfernen für exaktes Word-Matching
-    clean_text = text_raw
-    for char in [".", ",", "!", "?", ";", ":", "-", "_", "(", ")", "[", "]", "\n", "\r"]:
-        clean_text = clean_text.replace(char, " ")
-        
-    # In einzelne Wörter splitten, um Sub-String-Fehler (z.B. "ich" in "sicherlich") zu vermeiden
-    words_set = set(clean_text.split())
+    text = message.lower()
 
     scores = {
         "Business": 0.0,
@@ -40,21 +31,20 @@ def analyze_context(message: str) -> Dict[str, Any]:
         "ziel", "entscheidung", "gedanke"
     ]
 
-    # Abgleich auf echte Wort-Treffer oder exakte Phrasen
     for word in business_words:
-        if word in words_set or (" " in word and word in text_raw):
+        if word in text:
             scores["Business"] += 1
 
     for word in tech_words:
-        if word in words_set or (" " in word and word in text_raw):
+        if word in text:
             scores["Technik"] += 1
 
     for word in creative_words:
-        if word in words_set or (" " in word and word in text_raw):
+        if word in text:
             scores["Kreativ"] += 1
 
     for word in personal_words:
-        if word in words_set:
+        if word in text:
             scores["Persönlich"] += 0.5
 
     total = sum(scores.values()) or 1
@@ -64,28 +54,24 @@ def analyze_context(message: str) -> Dict[str, Any]:
         for key, value in scores.items()
     }
 
-    raw_primary = max(distribution, key=distribution.get)
-    actual_confidence = distribution.get(raw_primary, 0.5)
+    primary = max(distribution, key=distribution.get)
 
-    # Wenn der stärkste Intent unter 40% liegt, deklarieren wir es als gemischten Kontext
-    if distribution[raw_primary] < 0.4:
+    if distribution[primary] < 0.4:
         primary = "Mixed"
-    else:
-        primary = raw_primary
 
-    intent = detect_intent(text_raw)
-    complexity = detect_complexity(text_raw)
+    intent = detect_intent(text)
+    complexity = detect_complexity(text)
 
     return {
         "primary_context": {
             "type": primary,
-            "confidence": actual_confidence if primary != "Mixed" else round(actual_confidence, 2)
+            "confidence": distribution.get(primary, 0.5) if primary != "Mixed" else 0.5
         },
         "context_distribution": distribution,
         "intent_layer": intent,
         "complexity_level": complexity,
         "routing_hint": build_routing_hint(primary, intent, complexity),
-        "reasoning": "Kontext wurde anhand exakter Schlüsselwörter und Signalgruppen bestimmt."
+        "reasoning": "Kontext wurde anhand erkannter Schlüsselwörter und Signalgruppen bestimmt."
     }
 
 
@@ -113,8 +99,10 @@ def detect_complexity(text: str) -> str:
 
     if length > 1500:
         return "high"
+
     if length > 500:
         return "medium"
+
     return "low"
 
 
@@ -136,4 +124,4 @@ def build_routing_hint(primary: str, intent: Dict[str, Any], complexity: str) ->
         "target_system": target,
         "priority": priority,
         "intent": intent["type"]
-    }
+    }

fanvue_guide.py

@@ -13,21 +13,6 @@ FANVUE_VERIFICATION = "https://fanvue.com/settings/verification"
 FANVUE_PAYOUTS = "https://fanvue.com/settings/payouts"
 
 
-def clean_username(name: str) -> str:
-    """Bereinigt den Namen für gültige Plattform-Usernames (keine Umlaute/Sonderzeichen)."""
-    username = name.lower().strip()
-    # Umlaute ersetzen
-    replacements = {"ä": "ae", "ö": "oe", "ü": "ue", "ß": "ss"}
-    for char, rep in replacements.items():
-        username = username.replace(char, rep)
-    
-    # Leerzeichen und Bindestriche durch Unterstriche ersetzen
-    username = username.replace(" ", "_").replace("-", "_")
-    
-    # Erlaubte Zeichen filtern (nur Alphanumerisch und Unterstriche)
-    return "".join(c for c in username if c.isalnum() or c == "_")
-
-
 def get_fanvue_guide(creator_name: str = "Creator") -> str:
     """
     Gibt eine vollständige, personalisierte Fanvue Setup-Anleitung zurück.
@@ -39,7 +24,6 @@ def get_fanvue_guide(creator_name: str = "Creator") -> str:
         Vollständige Schritt-für-Schritt Anleitung als String.
     """
     name = creator_name.strip() if creator_name else "Creator"
-    suggested_username = clean_username(name)
 
     guide = f"""Fanvue Setup Guide — {name}
 Version: {MODULE_VERSION}
@@ -60,7 +44,7 @@ SCHRITT 2 — Profil einrichten
 ━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━━
 
 1. Oben rechts auf Avatar klicken → "Edit Profile"
-2. Username eingeben: {suggested_username}
+2. Username eingeben: {name.lower().replace(" ", "_")}
 3. Display Name: {name}
 4. Bio: Dein Hook-Text (2 Sätze — wer du bist + was Subscriber erwartet)
 5. Profilbild hochladen (empfohlen: quadratisch, min. 400×400px)
@@ -140,6 +124,7 @@ def process(message: str) -> str:
         Fanvue Guide als String.
     """
     name = "Creator"
+
     msg = message.lower() if message else ""
 
     if "molina" in msg:
@@ -151,4 +136,4 @@ def process(message: str) -> str:
 
 
 if __name__ == "__main__":
-    print(get_fanvue_guide("Molina Hill"))
+    print(get_fanvue_guide("Molina Hill"))

mcp_server.py

@@ -1,40 +1,19 @@
-"""
-mcp_server.py
-SkyOS Model Context Protocol (MCP) Server
-Stellt LLM-Agenten (wie Claude oder DeepSeek) Werkzeuge für das Creator OS bereit.
-"""
-
-import json
 from mcp.server.fastmcp import FastMCP
-
-# Core-System-Imports
-from router import route, status
-from trend_predictor import skyos_trend_score
-from crm_core import process_crm_message
+from router import route, status, skyos_trend_score
 
 # Initialisierung des MCP-Servers
 mcp = FastMCP("SkyOS_MCP_Server")
 
-
 @mcp.tool()
 def route_request(message: str) -> str:
-    """
-    Leitet Anfragen durch den SkyOS Router.
-    Verarbeitet Text-Intents und steuert die Sub-Module an.
-    """
-    result = route(message)
-    # Falls das Ergebnis ein Dictionary/Objekt ist, sauber als JSON-String zurückgeben
-    if isinstance(result, (dict, list)):
-        return json.dumps(result, ensure_ascii=False)
-    return str(result)
-
+    """Leitet Anfragen durch den SkyOS Router."""
+    return str(route(message))
 
 @mcp.tool()
 def get_system_status() -> str:
     """Gibt den aktuellen Status des SkyOS-Systems zurück."""
     return status()
 
-
 @mcp.tool()
 def analyze_trend(
     name: str, 
@@ -44,28 +23,19 @@ def analyze_trend(
     narrative: float, 
     saturation: float
 ) -> dict:
-    """
-    Führt eine mathematische Trend-Analyse über den skyos_trend_score aus.
-    Berechnet Virality Index und Aufstiegswahrscheinlichkeiten für Contentpläne.
-    """
+    """Führt eine Trend-Analyse über den skyos_trend_score aus."""
     return skyos_trend_score(name, share_rate, comment_depth, hook_score, narrative, saturation)
 
-
 @mcp.tool()
-def crm_core_access(command: str) -> dict:
-    """
-    Schnittstelle zum CRM Core Modul. 
-    Erstellt Leads, filtert Prioritäten und analysiert Plattformen aus dem Text.
-    """
-    return process_crm_message(command)
-
+def crm_core_access(command: str) -> str:
+    """Schnittstelle zum CRM Core Modul."""
+    # Hier wird die direkte Anbindung an den CRM Core abgebildet
+    return f"CRM Core: Befehl '{command}' verarbeitet."
 
 @mcp.tool()
 def skyos_process_trigger(action: str) -> str:
-    """Trigger für skyos_process zum Starten von automatisierten Workflows."""
-    return f"SkyOS Process: Aktion '{action}' erfolgreich eingeleitet und im Hintergrund gestartet."
-
+    """Trigger für skyos_process zum Starten von Workflows."""
+    return f"SkyOS Process: Aktion '{action}' eingeleitet."
 
 if __name__ == "__main__":
-    # Startet den MCP Server im Standard-Transportmodus (stdio)
     mcp.run()

modules/adapters/base_adapter.py

@@ -1,33 +0,0 @@
-"""
-base_adapter.py
-
-Basisklasse aller Sync-Adapter.
-"""
-
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-
-
-class BaseAdapter(ABC):
-
-    @property
-    @abstractmethod
-    def name(self) -> str:
-        ...
-
-    @abstractmethod
-    def connect(self) -> bool:
-        ...
-
-    @abstractmethod
-    def pull(self):
-        ...
-
-    @abstractmethod
-    def push(self, data):
-        ...
-
-    @abstractmethod
-    def sync(self):
-        ...

modules/adapters/huggingface_adapter.py

@@ -1,154 +0,0 @@
-"""
-huggingface_adapter.py
-SkyOS Hugging Face Adapter
-
-Adapter für die Integration von Hugging Face
-Modellen und APIs in den SkyOS Sync Manager / Core.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-import os
-from ..logger import logger
-from .base_adapter import BaseAdapter
-
-# Offizielles Hugging Face SDK
-try:
-    from huggingface_hub import InferenceClient
-except ImportError:
-    InferenceClient = None
-
-
-class HuggingFaceAdapter(BaseAdapter):
-    """
-    Adapter zur Kommunikation mit Hugging Face APIs und Modellen.
-    """
-
-    def __init__(self, model_id: str = "meta-llama/Llama-3-8B-Instruct") -> None:
-        self._connected = False
-        self.model_id = model_id
-        self.client: InferenceClient | None = None
-
-    # ---------------------------------------------------------
-    # Eigenschaften
-    # ---------------------------------------------------------
-
-    @property
-    def name(self) -> str:
-        return "Hugging Face"
-
-    @property
-    def connected(self) -> bool:
-        return self._connected
-
-    # ---------------------------------------------------------
-    # Verbindung
-    # ---------------------------------------------------------
-
-    def connect(self) -> bool:
-        """
-        Initialisiert den Hugging Face Inference Client mit dem API-Token.
-        """
-        if InferenceClient is None:
-            logger.error(
-                "%s: 'huggingface_hub' Bibliothek ist nicht installiert. "
-                "Bitte installiere sie mit 'pip install huggingface_hub'.",
-                self.name
-            )
-            self._connected = False
-            return False
-
-        # Sucht das Token aus den Umgebungsvariablen (z.B. in deiner .env)
-        hf_token = os.getenv("HF_TOKEN") or os.getenv("HUGGINGFACE_CO_API_TOKEN")
-
-        try:
-            # Verbindung wird mit dem Client-Objekt aufgebaut
-            self.client = InferenceClient(model=self.model_id, token=hf_token)
-            self._connected = True
-            
-            logger.info(
-                "%s verbunden. Standard-Modell: %s (Token vorhanden: %s)",
-                self.name,
-                self.model_id,
-                "Ja" if hf_token else "Nein (Öffentliche API)"
-            )
-            return True
-
-        except Exception as error:
-            logger.exception(
-                "%s Verbindung fehlgeschlagen: %s",
-                self.name,
-                error
-            )
-            self._connected = False
-            return False
-
-    def disconnect(self) -> None:
-        """
-        Trennt die Verbindung zum Client.
-        """
-        self.client = None
-        self._connected = False
-        logger.info("%s getrennt.", self.name)
-
-    def is_connected(self) -> bool:
-        """
-        Gibt den Verbindungsstatus zurück.
-        """
-        return self._connected
-
-    # ---------------------------------------------------------
-    # Inference Funktionalität (Schnittstelle für den Core)
-    # ---------------------------------------------------------
-
-    def generate_text(self, prompt: str, **kwargs) -> str | None:
-        """
-        Sendet einen Prompt an das geladene Hugging Face Modell.
-        """
-        if not self._connected or not self.client:
-            logger.warning("%s: Textgenerierung nicht möglich – nicht verbunden.", self.name)
-            return None
-
-        try:
-            # Nutzt die Standard-Textgenerierung des Inference Clients
-            response = self.client.text_generation(prompt, **kwargs)
-            return response
-        except Exception as error:
-            logger.error("%s Fehler bei der Textgenerierung: %s", self.name, error)
-            return None
-
-    # ---------------------------------------------------------
-    # BaseAdapter (Synchronisation)
-    # ---------------------------------------------------------
-
-    def pull(self) -> dict | None:
-        """
-        Phase 2: Status-Check des Modells oder Abruf von Metadaten über das Repository.
-        """
-        if not self._connected or not self.client:
-            return None
-        
-        try:
-            # Beispielhafter Pull: Modell-Informationen abrufen
-            model_info = {"model_id": self.model_id, "status": "aktiv/bereit"}
-            return model_info
-        except Exception as error:
-            logger.error("%s Fehler beim Pull der Modell-Daten: %s", self.name, error)
-            return None
-
-    def push(self, data: dict) -> bool:
-        """
-        Phase 3: Falls nötig, Konfigurationen oder Logs an Hugging Face Repositories 
-        oder Spaces senden (Standardmäßig auf True gesetzt).
-        """
-        return True
-
-    def sync(self) -> bool:
-        """
-        Prüft die Erreichbarkeit des Modells.
-        """
-        logger.info("Starte Sync für %s...", self.name)
-        return self.connect()

modules/adapters/init.py

@@ -1,24 +0,0 @@
-"""
-SkyOS Sync Adapters
-"""
-
-from .sync_manager import SyncManager
-from .registry import SyncRegistry
-from .scheduler import SyncScheduler
-from .conflict_resolver import ConflictResolver
-
-from .adapters import (
-    BaseAdapter,
-    GoogleSheetsAdapter,
-    HuggingFaceAdapter,
-)
-
-__all__ = [
-    "SyncManager",
-    "SyncRegistry",
-    "SyncScheduler",
-    "ConflictResolver",
-    "BaseAdapter",
-    "GoogleSheetsAdapter",
-    "HuggingFaceAdapter",
-]

modules/adapters/sheets_adapter.py

@@ -1,175 +0,0 @@
-"""
-sheets_adapter.py
-SkyOS Google Sheets Adapter
-
-Adapter für die Anbindung von Google Sheets
-an den SkyOS Sync Manager.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-import logging
-
-from ..logger import logger
-from .base_adapter import BaseAdapter
-
-# Vorhandene Google-Module von SkyOS
-from ...Google.auth import GoogleAuth
-from ...Google.sheets_gateway import SheetsGateway
-
-
-class GoogleSheetsAdapter(BaseAdapter):
-    """
-    Adapter für Google Sheets.
-    """
-
-    def __init__(self, spreadsheet_id: str | None = None) -> None:
-        self._connected = False
-        self.auth = GoogleAuth()
-        self.gateway = SheetsGateway(self.auth)
-        # Die ID der Google Sheet-Datei, die synchronisiert werden soll
-        self.spreadsheet_id = spreadsheet_id
-
-    # ---------------------------------------------------------
-    # Eigenschaften
-    # ---------------------------------------------------------
-
-    @property
-    def name(self) -> str:
-        return "Google Sheets"
-
-    @property
-    def connected(self) -> bool:
-        return self._connected
-
-    # ---------------------------------------------------------
-    # Verbindung
-    # ---------------------------------------------------------
-
-    def connect(self) -> bool:
-        """
-        Baut die Verbindung zu Google auf.
-        """
-        try:
-            self.auth.authenticate()
-            self.gateway.connect()
-            self._connected = True
-
-            logger.info(
-                "%s verbunden.",
-                self.name,
-            )
-            return True
-
-        except Exception as error:
-            logger.exception(
-                "%s Verbindung fehlgeschlagen: %s",
-                self.name,
-                error,
-            )
-            self._connected = False
-            return False
-
-    def disconnect(self) -> None:
-        """
-        Trennt die Verbindung.
-        """
-        self._connected = False
-        logger.info(
-            "%s getrennt.",
-            self.name,
-        )
-
-    def is_connected(self) -> bool:
-        """
-        Verbindungsstatus.
-        """
-        return self._connected
-
-    # ---------------------------------------------------------
-    # Informationen
-    # ---------------------------------------------------------
-
-    def list_sheets(self) -> list[str]:
-        """
-        Gibt alle Tabellenblätter (Locations) zurück.
-        """
-        if not self._connected or not self.spreadsheet_id:
-            return []
-        
-        try:
-            # Holt alle Tabellenblatt-Namen der aktuellen Datei
-            return self.gateway.get_sheet_names(self.spreadsheet_id)
-        except Exception as error:
-            logger.error("Fehler beim Abrufen der Tabellenblätter: %s", error)
-            return []
-
-    # ---------------------------------------------------------
-    # BaseAdapter (Synchronisation)
-    # ---------------------------------------------------------
-
-    def pull(self) -> dict[str, list[list]] | None:
-        """
-        Phase 2: Daten aus den Google Sheets (nach Locations/Tabs aufgeteilt) abrufen.
-        Gibt ein Dictionary zurück: { "Location_Name": [[Zeile1], [Zeile2], ...] }
-        """
-        if not self._connected or not self.spreadsheet_id:
-            logger.warning("%s: Pull nicht möglich - keine Verbindung oder Spreadsheet-ID.", self.name)
-            return None
-
-        try:
-            sheets = self.list_sheets()
-            pulled_data = {}
-
-            for sheet_name in sheets:
-                # Liest alle Daten aus dem jeweiligen Tabellenblatt (der Location)
-                data = self.gateway.read_values(self.spreadsheet_id, range_name=f"'{sheet_name}'!A:Z")
-                pulled_data[sheet_name] = data
-                logger.debug("Daten für Location '%s' erfolgreich gepullt.", sheet_name)
-
-            return pulled_data
-
-        except Exception as error:
-            logger.exception("Fehler beim Pull der Google Sheets Daten: %s", error)
-            return None
-
-    def push(self, data: dict[str, list[list]]) -> bool:
-        """
-        Phase 3: Synchronisierte Daten zurück in die Google Sheets schreiben.
-        Erwartet Daten im Format: { "Location_Name": [[Zeile1], [Zeile2], ...] }
-        """
-        if not self._connected or not self.spreadsheet_id:
-            logger.warning("%s: Push nicht möglich - keine Verbindung oder Spreadsheet-ID.", self.name)
-            return False
-
-        try:
-            for sheet_name, rows in data.items():
-                # Überschreibt oder aktualisiert das Tabellenblatt für diese Location
-                self.gateway.write_values(
-                    self.spreadsheet_id, 
-                    range_name=f"'{sheet_name}'!A1", 
-                    values=rows
-                )
-                logger.debug("Daten für Location '%s' erfolgreich gepusht.", sheet_name)
-            
-            return True
-
-        except Exception as error:
-            logger.exception("Fehler beim Push der Google Sheets Daten: %s", error)
-            return False
-
-    def sync(self) -> bool:
-        """
-        Führt einen lokalen Test- oder Direktsync durch (Pull -> Push).
-        """
-        logger.info("Starte Sync für %s...", self.name)
-        data = self.pull()
-        if data is None:
-            return False
-        
-        # Hier könnte ein Verarbeitungs- oder Abgleichschritt stattfinden
-        
-        return self.push(data)

modules/avatar_streamer.py

@@ -3,49 +3,45 @@
 import time
 from typing import Dict, Any
 
+
 class AvatarStreamer:
-    # Klassen-Attribute verhindern den Zustandverlust bei Neu-Instanziierung
-    _avatar_name = "Sky Meilin"
-    _status = "idle"
 
     def __init__(self):
-        print("AvatarStreamer geladen")
-
-    @property
-    def avatar_name(self) -> str:
-        return AvatarStreamer._avatar_name
-
-    @avatar_name.setter
-    def avatar_name(self, name: str):
-        AvatarStreamer._avatar_name = name
 
-    @property
-    def status(self) -> str:
-        return AvatarStreamer._status
+        print("AvatarStreamer geladen")
 
-    @status.setter
-    def status(self, value: str):
-        AvatarStreamer._status = value
+        self.avatar_name = "Sky Meilin"
+        self.status = "idle"
 
     def set_avatar(self, name: str):
+
         self.avatar_name = name
 
-    def start_stream(self) -> Dict[str, Any]:
+    def start_stream(self):
+
         self.status = "streaming"
+
         return {
             "status": self.status,
             "avatar": self.avatar_name
         }
 
-    def stop_stream(self) -> Dict[str, Any]:
+    def stop_stream(self):
+
         self.status = "offline"
+
         return {
             "status": self.status,
             "avatar": self.avatar_name
         }
 
-    def send_message(self, text: str) -> Dict[str, Any]:
+    def send_message(
+        self,
+        text: str
+    ) -> Dict[str, Any]:
+
         if self.status != "streaming":
+
             return {
                 "error": "Avatar nicht aktiv"
             }
@@ -55,10 +51,15 @@ class AvatarStreamer:
             "message": text,
             "timestamp": time.time()
         }
+
         return payload
 
-    def emotion(self, emotion_name: str) -> Dict[str, Any]:
+    def emotion(
+        self,
+        emotion_name: str
+    ):
+
         return {
             "avatar": self.avatar_name,
             "emotion": emotion_name
-        }
+        }

modules/creator_os.py

@@ -1,18 +1,7 @@
 """
-modules/creator_os.py
-Creator OS — Paket-Initialisierung & Core-Metadaten
-Zentrale Definition der System-Rolle und Markenarchitektur.
+modules/__init__.py
+Creator OS — Paket-Initialisierung
+Macht den modules/ Ordner zu einem Python-Paket.
 """
 
-PACKAGE_VERSION = "modules_v1_3_2026_06_28"
-
-# Globale System-Eckpfeiler
-SYSTEM_AUTHORITY = {
-    "role": "Head of Automation",
-    "company": "Agency Level Up",
-    "focus": [
-        "KI-gestützte Creator-Workflows",
-        "Automatisierte Content-Systeme",
-        "Digitale Markenarchitekturen für skalierbare Projekte"
-    ]
-}
+PACKAGE_VERSION = "modules_v1_2026_06_02"

modules/crypto_engine.py

@@ -1,7 +1,6 @@
 # modules/crypto_engine.py
 
 import hashlib
-import json
 import secrets
 from typing import Dict, Any
 
@@ -9,33 +8,49 @@ from typing import Dict, Any
 class CryptoEngine:
 
     def __init__(self):
+
         print("CryptoEngine geladen")
+
         self.algorithm = "sha256"
 
     def hash_text(self, text: str) -> str:
-        if not text:
-            return ""
-        return hashlib.sha256(text.encode("utf-8")).hexdigest()
 
-    def generate_token(self, length: int = 32) -> str:
+        return hashlib.sha256(
+            text.encode("utf-8")
+        ).hexdigest()
+
+    def generate_token(
+        self,
+        length: int = 32
+    ) -> str:
+
         return secrets.token_hex(length)
 
-    def verify_hash(self, text: str, hashed: str) -> bool:
-        return self.hash_text(text) == hashed
+    def verify_hash(
+        self,
+        text: str,
+        hashed: str
+    ) -> bool:
 
-    def secure_payload(self, payload: Dict[str, Any]) -> Dict[str, Any]:
-        if not payload:
-            payload = {}
+        new_hash = self.hash_text(text)
+
+        return new_hash == hashed
+
+    def secure_payload(
+        self,
+        payload: Dict[str, Any]
+    ) -> Dict[str, Any]:
+
+        payload_string = str(payload)
 
-        # Sort_keys=True sorgt für eine deterministische und stabile String-Form
-        payload_string = json.dumps(payload, sort_keys=True)
         payload_hash = self.hash_text(payload_string)
 
         return {
             "payload": payload,
             "hash": payload_hash,
-            "algorithm": self.algorithm,
+            "algorithm": self.algorithm
         }
 
     def create_session_key(self) -> str:
-        return secrets.token_urlsafe(64)
+
+        return secrets.token_urlsafe(64)

modules/dashboard/__init__.py

@@ -1,112 +0,0 @@
-"""
-__init__.py
-SkyOS Dashboard Module
-
-Initialisiert das Armaturenbrett-Modul.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-
-# ---------------------------------------------------------
-# Modul Informationen
-# ---------------------------------------------------------
-
-__title__ = "SkyOS Armaturenbrett"
-__version__ = "0.1.0"
-__author__ = "Sky Meilin"
-
-
-# ---------------------------------------------------------
-# Konfiguration
-# ---------------------------------------------------------
-
-from .config import (
-    DASHBOARD,
-    UI,
-    BACKEND,
-    get_config,
-)
-
-
-# ---------------------------------------------------------
-# Theme
-# ---------------------------------------------------------
-
-from .theme import (
-    DashboardTheme,
-    DEFAULT_THEME,
-    get_theme,
-)
-
-
-# ---------------------------------------------------------
-# Icons
-# ---------------------------------------------------------
-
-from .icons import (
-    ICONS,
-    get_icon,
-)
-
-
-# ---------------------------------------------------------
-# Utilities
-# ---------------------------------------------------------
-
-from .utils import (
-    current_time,
-    current_timestamp,
-    format_status,
-    clean_text,
-)
-
-
-# ---------------------------------------------------------
-# Event Handler
-# ---------------------------------------------------------
-
-from .event_handler import (
-    register_events,
-    send_message,
-    refresh_status,
-    refresh_header,
-)
-
-
-# ---------------------------------------------------------
-# Public API
-# ---------------------------------------------------------
-
-__all__ = [
-
-    # Config
-    "DASHBOARD",
-    "UI",
-    "BACKEND",
-    "get_config",
-
-    # Theme
-    "DashboardTheme",
-    "DEFAULT_THEME",
-    "get_theme",
-
-    # Icons
-    "ICONS",
-    "get_icon",
-
-    # Utils
-    "current_time",
-    "current_timestamp",
-    "format_status",
-    "clean_text",
-
-    # Events
-    "register_events",
-    "send_message",
-    "refresh_status",
-    "refresh_header",
-]

modules/dashboard/chat_panel.py

@@ -1,41 +0,0 @@
-"""
-chat_panel.py
-SkyOS Chat
-"""
-
-from __future__ import annotations
-
-import gradio as gr
-
-
-def build_chat_panel() -> dict:
-
-    with gr.Column(scale=2):
-
-        chatbot = gr.Chatbot(
-            label="SkyOS Chat",
-            type="messages",
-        )
-
-        message = gr.Textbox(
-            label="Nachricht",
-            placeholder="Nachricht eingeben...",
-        )
-
-        audio = gr.Audio(
-            sources=["microphone"],
-            type="filepath",
-            label="Sprache",
-        )
-
-        send = gr.Button(
-            "Senden",
-            variant="primary",
-        )
-
-    return {
-        "chatbot": chatbot,
-        "message": message,
-        "audio": audio,
-        "send": send,
-    }

modules/dashboard/config.py

@@ -1,97 +0,0 @@
-"""
-config.py
-SkyOS Dashboard Configuration
-
-Zentrale Konfiguration für UI, Events und Backend-Verbindungen.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-# ---------------------------------------------------------
-# Dashboard Settings
-# ---------------------------------------------------------
-
-@dataclass(frozen=True)
-class DashboardConfig:
-    """
-    Globale Dashboard-Konfiguration.
-    """
-
-    title: str = "SkyOS Dashboard"
-    version: str = "0.1.0"
-
-    refresh_interval: int = 5000  # Millisekunden
-
-    enable_audio: bool = True
-    enable_stream: bool = True
-    enable_navigation: bool = True
-
-    debug_mode: bool = False
-
-
-# ---------------------------------------------------------
-# UI Settings
-# ---------------------------------------------------------
-
-@dataclass(frozen=True)
-class UIConfig:
-    """
-    Layout-Konfiguration.
-    """
-
-    sidebar_width: int = 280
-    panel_radius: int = 12
-
-    max_chat_height: int = 600
-
-    compact_mode: bool = False
-
-
-# ---------------------------------------------------------
-# Backend Settings
-# ---------------------------------------------------------
-
-@dataclass(frozen=True)
-class BackendConfig:
-    """
-    Verbindung zu SkyOS Backend-Modulen.
-    """
-
-    router_enabled: bool = False
-    status_monitor_enabled: bool = False
-
-    router_name: str = "SkyOS Router"
-    creator_name: str = "CreatorOS"
-
-
-# ---------------------------------------------------------
-# Runtime Configuration
-# ---------------------------------------------------------
-
-DASHBOARD = DashboardConfig()
-
-UI = UIConfig()
-
-BACKEND = BackendConfig()
-
-
-# ---------------------------------------------------------
-# Helper
-# ---------------------------------------------------------
-
-def get_config():
-    """
-    Liefert komplette Dashboard-Konfiguration.
-    """
-
-    return {
-        "dashboard": DASHBOARD,
-        "ui": UI,
-        "backend": BACKEND,
-    }

modules/dashboard/dashboard.py

@@ -1,74 +0,0 @@
-"""
-dashboard.py
-SkyOS Dashboard Builder
-
-Erstellt das komplette Gradio-Dashboard und verbindet
-alle Dashboard-Module.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-import gradio as gr
-
-from .theme import THEME
-from .header import build_header
-from .status_panel import build_status_panel
-from .stream_panel import build_stream_panel
-from .chat_panel import build_chat_panel
-from .navigation_panel import build_navigation_panel
-from .event_handler import register_events
-
-
-def create_dashboard() -> gr.Blocks:
-    """
-    Erstellt das komplette Dashboard.
-    """
-
-    with gr.Blocks(
-        title="SkyOS Dashboard"
-    ) as demo:
-
-        # -----------------------------------------
-        # Header
-        # -----------------------------------------
-        build_header()
-
-        gr.Markdown("---")
-
-        # -----------------------------------------
-        # Status
-        # -----------------------------------------
-        status_components = build_status_panel()
-
-        gr.Markdown("---")
-
-        # -----------------------------------------
-        # Hauptbereich
-        # -----------------------------------------
-        with gr.Row():
-
-            stream_components = build_stream_panel()
-
-            chat_components = build_chat_panel()
-
-        gr.Markdown("---")
-
-        # -----------------------------------------
-        # Navigation
-        # -----------------------------------------
-        navigation_components = build_navigation_panel()
-
-        # -----------------------------------------
-        # Events verbinden
-        # -----------------------------------------
-        register_events(
-            status=status_components,
-            stream=stream_components,
-            chat=chat_components,
-            navigation=navigation_components,
-        )
-
-    return demo

modules/dashboard/event_handler.py

@@ -1,184 +0,0 @@
-"""
-event_handler.py
-SkyOS Dashboard Event Handler
-
-Verbindet alle UI-Komponenten mit den Backend-Modulen.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-import logging
-
-logger = logging.getLogger("SkyOS.Dashboard")
-
-
-# ---------------------------------------------------------
-# Backend Bridge
-# ---------------------------------------------------------
-
-def process_message(message: str) -> str:
-    """
-    Übergangspunkt zum SkyOS Router.
-
-    Wird später ersetzt durch:
-    Router.handle(message)
-    """
-
-    return (
-        "Nachricht empfangen. "
-        "Die Verarbeitung übernimmt später der SkyOS Router."
-    )
-
-
-# ---------------------------------------------------------
-# Chat Events
-# ---------------------------------------------------------
-
-def send_message(text, audio):
-    """
-    Standard-Chatcallback.
-    """
-
-    try:
-        if text:
-            user_input = text
-
-        elif audio:
-            user_input = "🎤 Spracheingabe empfangen."
-
-        else:
-            return [], "", None
-
-
-        response = process_message(user_input)
-
-        history = [
-            {
-                "role": "user",
-                "content": user_input,
-            },
-            {
-                "role": "assistant",
-                "content": response,
-            },
-        ]
-
-        return history, "", None
-
-    except Exception:
-        logger.exception("Chat-Verarbeitung fehlgeschlagen.")
-
-        return (
-            [
-                {
-                    "role": "assistant",
-                    "content": "⚠️ Fehler bei der Verarbeitung."
-                }
-            ],
-            "",
-            None,
-        )
-
-
-# ---------------------------------------------------------
-# Status Events
-# ---------------------------------------------------------
-
-def refresh_status():
-    """
-    Status-Aktualisierung.
-
-    Später:
-        StatusMonitor.get_status()
-    """
-
-    logger.info("Status aktualisiert")
-
-    return (
-        "🟢 Online",
-        "🟡 Nicht verbunden",
-        "🟢 Aktiv",
-        "🟢 Aktiv",
-        "🟢 Aktiv",
-        "🟢 Aktiv",
-        "🟢 Online",
-        "🟢 Online",
-    )
-
-
-# ---------------------------------------------------------
-# Header Events
-# ---------------------------------------------------------
-
-def refresh_header():
-    """
-    Aktualisiert die Dashboard-Uhr.
-    """
-
-    from .header import current_time
-
-    return (
-        current_time(),
-    )
-
-
-# ---------------------------------------------------------
-# Event Registrierung
-# ---------------------------------------------------------
-
-def register_events(
-    *,
-    status: dict,
-    stream: dict,
-    chat: dict,
-    navigation: dict,
-):
-    """
-    Registriert alle Dashboard-Events.
-    """
-
-    logger.info("Registriere Dashboard Events...")
-
-
-    # Chat Button
-
-    if "send" in chat:
-
-        chat["send"].click(
-            fn=send_message,
-            inputs=[
-                chat["message"],
-                chat["audio"],
-            ],
-            outputs=[
-                chat["chatbot"],
-                chat["message"],
-                chat["audio"],
-            ],
-        )
-
-
-    # Enter Taste
-
-    if "message" in chat:
-
-        chat["message"].submit(
-            fn=send_message,
-            inputs=[
-                chat["message"],
-                chat["audio"],
-            ],
-            outputs=[
-                chat["chatbot"],
-                chat["message"],
-                chat["audio"],
-            ],
-        )
-
-
-    logger.info(
-        "Dashboard Events registriert."
-    )

modules/dashboard/header.py

@@ -1,113 +0,0 @@
-"""
-header.py
-SkyOS Dashboard Header
-
-Erstellt den Kopfbereich des Dashboards mit
-Logo, Systeminformationen und Live-Uhr.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-from datetime import datetime
-import zoneinfo
-
-import gradio as gr
-
-from persona_sky_meilin import (
-    SYSTEM_NAME,
-    AVATAR_PERSONA,
-    AVATAR_JOBTITEL,
-    COMPANY_NAME,
-)
-
-# ---------------------------------------------------------
-# Zeitzone
-# ---------------------------------------------------------
-
-BERLIN_TZ = zoneinfo.ZoneInfo("Europe/Berlin")
-
-
-# ---------------------------------------------------------
-# Hilfsfunktionen
-# ---------------------------------------------------------
-
-def current_time() -> str:
-    """Aktuelle Uhrzeit in Deutschland."""
-
-    return datetime.now(BERLIN_TZ).strftime("%d.%m.%Y • %H:%M:%S")
-
-
-# ---------------------------------------------------------
-# Header
-# ---------------------------------------------------------
-
-def build_header() -> dict:
-    """
-    Erstellt den Dashboard-Header.
-
-    Returns
-    -------
-    dict
-        Referenzen auf Komponenten.
-    """
-
-    with gr.Column():
-
-        gr.Markdown(
-            f"""
-# 🌌 {SYSTEM_NAME}
-
-### 👤 {AVATAR_PERSONA}
-**{AVATAR_JOBTITEL}**
-
-🏢 {COMPANY_NAME}
-"""
-        )
-
-        with gr.Row():
-
-            clock = gr.Textbox(
-                value=current_time(),
-                label="🕒 Uhrzeit",
-                interactive=False,
-                scale=1,
-            )
-
-            system = gr.Textbox(
-                value=SYSTEM_NAME,
-                label="💻 System",
-                interactive=False,
-                scale=1,
-            )
-
-            company = gr.Textbox(
-                value=COMPANY_NAME,
-                label="🏢 Unternehmen",
-                interactive=False,
-                scale=1,
-            )
-
-    return {
-        "clock": clock,
-        "system": system,
-        "company": company,
-    }
-
-
-# ---------------------------------------------------------
-# Live-Update
-# ---------------------------------------------------------
-
-def refresh_header():
-    """
-    Aktualisiert die dynamischen Header-Daten.
-    """
-
-    return {
-        "clock": current_time(),
-        "system": SYSTEM_NAME,
-        "company": COMPANY_NAME,
-    }

modules/dashboard/icons.py

@@ -1,114 +0,0 @@
-"""
-icons.py
-SkyOS Dashboard Icons
-
-Zentrale Icon-Verwaltung für das Armaturenbrett.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-
-# ---------------------------------------------------------
-# System Icons
-# ---------------------------------------------------------
-
-ONLINE = "🟢"
-OFFLINE = "⚫"
-WARNING = "🟡"
-ERROR = "🔴"
-ACTIVE = "⚡"
-INACTIVE = "○"
-
-
-# ---------------------------------------------------------
-# Navigation Icons
-# ---------------------------------------------------------
-
-HOME = "🏠"
-DASHBOARD = "📊"
-SYSTEM = "⚙️"
-SETTINGS = "🔧"
-LOGS = "📜"
-
-
-# ---------------------------------------------------------
-# Chat Icons
-# ---------------------------------------------------------
-
-CHAT = "💬"
-SEND = "📤"
-MICROPHONE = "🎤"
-USER = "👤"
-ASSISTANT = "🤖"
-
-
-# ---------------------------------------------------------
-# Stream Icons
-# ---------------------------------------------------------
-
-STREAM = "📡"
-VIDEO = "🎥"
-AUDIO = "🔊"
-LIVE = "🔴"
-
-
-# ---------------------------------------------------------
-# Status Icons
-# ---------------------------------------------------------
-
-CPU = "🖥️"
-MEMORY = "💾"
-NETWORK = "🌐"
-DATABASE = "🗄️"
-SECURITY = "🛡️"
-
-
-# ---------------------------------------------------------
-# Actions
-# ---------------------------------------------------------
-
-REFRESH = "🔄"
-SEARCH = "🔍"
-SAVE = "💾"
-CLOSE = "✖"
-CHECK = "✔"
-
-
-# ---------------------------------------------------------
-# Icon Sammlung
-# ---------------------------------------------------------
-
-ICONS = {
-    "online": ONLINE,
-    "offline": OFFLINE,
-    "warning": WARNING,
-    "error": ERROR,
-
-    "home": HOME,
-    "dashboard": DASHBOARD,
-    "settings": SETTINGS,
-
-    "chat": CHAT,
-    "send": SEND,
-    "microphone": MICROPHONE,
-
-    "stream": STREAM,
-    "live": LIVE,
-
-    "refresh": REFRESH,
-    "check": CHECK,
-}
-
-
-def get_icon(name: str) -> str:
-    """
-    Liefert ein Icon anhand des Namens.
-    """
-
-    return ICONS.get(
-        name,
-        "?"
-    )

modules/dashboard/navigation_panel.py

@@ -1,53 +0,0 @@
-"""
-navigation_panel.py
-Navigation
-"""
-
-from __future__ import annotations
-
-import gradio as gr
-
-
-BUTTON_STYLE = """
-width:100%;
-padding:15px;
-background:#f3f4f6;
-border:1px solid #d1d5db;
-border-radius:8px;
-cursor:pointer;
-"""
-
-
-def build_navigation_panel():
-
-    gr.Markdown("## 🏢 Navigation")
-
-    with gr.Row():
-
-        gr.HTML(
-            f'<a href="/management" target="_blank"><button style="{BUTTON_STYLE}">💼 Management</button></a>'
-        )
-
-        gr.HTML(
-            f'<a href="/client" target="_blank"><button style="{BUTTON_STYLE}">🤝 Client</button></a>'
-        )
-
-        gr.HTML(
-            f'<a href="/creation" target="_blank"><button style="{BUTTON_STYLE}">🎨 Creation</button></a>'
-        )
-
-    with gr.Row():
-
-        gr.HTML(
-            f'<a href="/technical" target="_blank"><button style="{BUTTON_STYLE}">📊 Technical</button></a>'
-        )
-
-        gr.HTML(
-            f'<a href="/data" target="_blank"><button style="{BUTTON_STYLE}">⚡ Data</button></a>'
-        )
-
-        gr.HTML(
-            f'<a href="/settings" target="_blank"><button style="{BUTTON_STYLE}">⚙️ Einstellungen</button></a>'
-        )
-
-    return {}

modules/dashboard/status_panel.py

@@ -1,78 +0,0 @@
-"""
-status_panel.py
-SkyOS Dashboard
-
-Systemstatus-Panel.
-"""
-
-from __future__ import annotations
-
-import gradio as gr
-
-
-def build_status_panel() -> dict:
-
-    gr.Markdown("## 📊 Systemstatus")
-
-    with gr.Row():
-
-        avatar = gr.Textbox(
-            value="🟢 Online",
-            label="Avatar",
-            interactive=False,
-        )
-
-        google = gr.Textbox(
-            value="🟡 Nicht verbunden",
-            label="Google",
-            interactive=False,
-        )
-
-        router = gr.Textbox(
-            value="🟢 Aktiv",
-            label="Router",
-            interactive=False,
-        )
-
-        crm = gr.Textbox(
-            value="🟢 Aktiv",
-            label="CRM",
-            interactive=False,
-        )
-
-    with gr.Row():
-
-        creator = gr.Textbox(
-            value="🟢 Aktiv",
-            label="Creator",
-            interactive=False,
-        )
-
-        worklog = gr.Textbox(
-            value="🟢 Aktiv",
-            label="Worklog",
-            interactive=False,
-        )
-
-        github = gr.Textbox(
-            value="🟢 Online",
-            label="GitHub",
-            interactive=False,
-        )
-
-        huggingface = gr.Textbox(
-            value="🟢 Online",
-            label="Hugging Face",
-            interactive=False,
-        )
-
-    return {
-        "avatar": avatar,
-        "google": google,
-        "router": router,
-        "crm": crm,
-        "creator": creator,
-        "worklog": worklog,
-        "github": github,
-        "huggingface": huggingface,
-    }

modules/dashboard/theme.py

@@ -1,66 +0,0 @@
-"""
-theme.py
-SkyOS Dashboard Theme
-
-Zentrale Darstellungskonfiguration für das Armaturenbrett.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-# ---------------------------------------------------------
-# Theme Definition
-# ---------------------------------------------------------
-
-@dataclass(frozen=True)
-class DashboardTheme:
-    """
-    Farb- und Style-Konfiguration des Dashboards.
-    """
-
-    # Hintergrund
-    background: str = "#0b1120"
-    surface: str = "#111827"
-    panel: str = "#1f2937"
-
-    # Text
-    text: str = "#f8fafc"
-    muted: str = "#94a3b8"
-
-    # Statusfarben
-    online: str = "#22c55e"
-    warning: str = "#eab308"
-    error: str = "#ef4444"
-    offline: str = "#64748b"
-
-    # Akzente
-    primary: str = "#38bdf8"
-    secondary: str = "#6366f1"
-
-    # UI
-    border_radius: str = "12px"
-    panel_padding: str = "16px"
-
-
-# ---------------------------------------------------------
-# Standard Theme
-# ---------------------------------------------------------
-
-DEFAULT_THEME = DashboardTheme()
-
-
-# ---------------------------------------------------------
-# Theme Zugriff
-# ---------------------------------------------------------
-
-def get_theme() -> DashboardTheme:
-    """
-    Gibt das aktive Dashboard Theme zurück.
-    """
-
-    return DEFAULT_THEME

modules/dashboard/utils.py

@@ -1,91 +0,0 @@
-"""
-utils.py
-SkyOS Dashboard Utilities
-
-Gemeinsame Hilfsfunktionen für das Armaturenbrett.
-
-Autor: Sky Meilin
-Projekt: SkyOS
-"""
-
-from __future__ import annotations
-
-from datetime import datetime
-
-
-# ---------------------------------------------------------
-# Zeitfunktionen
-# ---------------------------------------------------------
-
-def current_timestamp() -> str:
-    """
-    Erstellt einen formatierten Zeitstempel.
-    """
-
-    return datetime.now().strftime(
-        "%d.%m.%Y %H:%M:%S"
-    )
-
-
-def current_time() -> str:
-    """
-    Liefert aktuelle Uhrzeit.
-    """
-
-    return datetime.now().strftime(
-        "%H:%M:%S"
-    )
-
-
-# ---------------------------------------------------------
-# Status Helfer
-# ---------------------------------------------------------
-
-def status_icon(active: bool) -> str:
-    """
-    Gibt Statussymbol zurück.
-    """
-
-    return "🟢" if active else "🔴"
-
-
-def format_status(
-    name: str,
-    active: bool,
-) -> str:
-    """
-    Erstellt eine Statusanzeige.
-    """
-
-    return (
-        f"{status_icon(active)} {name}"
-    )
-
-
-# ---------------------------------------------------------
-# Text Helfer
-# ---------------------------------------------------------
-
-def clean_text(text: str | None) -> str:
-    """
-    Bereinigt Benutzereingaben.
-    """
-
-    if not text:
-        return ""
-
-    return text.strip()
-
-
-def limit_text(
-    text: str,
-    length: int = 100,
-) -> str:
-    """
-    Kürzt lange Texte für UI-Anzeigen.
-    """
-
-    if len(text) <= length:
-        return text
-
-    return text[:length] + "..."

modules/fanvue_guide.py

@@ -1,7 +1,7 @@
 """
-modules/fanvue_guide.py
-Creator OS — Fanvue Guide Module
-Enthält Leitfäden und Strukturen für die Fanvue-Plattform.
+modules/__init__.py
+Creator OS — Paket-Initialisierung
+Macht den modules/ Ordner zu einem Python-Paket.
 """
 
-PACKAGE_VERSION = "modules_fanvue_v1_2026_06_02"
+PACKAGE_VERSION = "modules_v1_2026_06_02"

modules/google/__init__.py

@@ -1,42 +0,0 @@
-"""
-SkyOS Google Integration Package
-================================
-Zentrale Exporte aller Google-Module.
-
-Autor: Sky Meilin
-Projekt: SkyOS FullCore
-"""
-
-from .config import GoogleConfig
-from .auth import GoogleAuth
-from .oauth import OAuthManager
-
-from .calendar_gateway import CalendarGateway
-from .sheets_gateway import SheetsGateway
-from .docs_gateway import DocsGateway
-from .drive_gateway import DriveGateway
-from .gmail_gateway import GmailGateway
-
-from .discovery import GoogleDiscovery
-from .utils import (
-    logger,
-    ensure_directory,
-    timestamp,
-    safe_execute
-)
-
-__all__ = [
-    "GoogleConfig",
-    "GoogleAuth",
-    "OAuthManager",
-    "CalendarGateway",
-    "SheetsGateway",
-    "DocsGateway",
-    "DriveGateway",
-    "GmailGateway",
-    "GoogleDiscovery",
-    "logger",
-    "ensure_directory",
-    "timestamp",
-    "safe_execute",
-]

modules/google/auth.py

@@ -1,126 +0,0 @@
-"""
-auth.py
-SkyOS Google Authentication
-
-Stellt authentifizierte Google Services für alle Module bereit.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import logging
-
-from googleapiclient.discovery import build
-
-from Module.google.oauth import oauth
-
-logger = logging.getLogger("SkyOS.GoogleAuth")
-
-
-class GoogleAuth:
-    """Zentrale Google-Authentifizierung."""
-
-    _credentials = None
-    _services = {}
-
-    @classmethod
-    def credentials(cls):
-        """Liefert gültige OAuth-Credentials."""
-
-        if cls._credentials is None:
-            cls._credentials = oauth.authenticate()
-
-        return cls._credentials
-
-    @classmethod
-    def service(
-        cls,
-        api_name: str,
-        api_version: str,
-    ):
-        """
-        Erzeugt oder liefert einen zwischengespeicherten Google-Service.
-
-        Beispiel:
-            GoogleAuth.service("drive", "v3")
-        """
-
-        key = f"{api_name}:{api_version}"
-
-        if key not in cls._services:
-
-            logger.info(
-                "Initialisiere Google Service %s (%s)",
-                api_name,
-                api_version,
-            )
-
-            cls._services[key] = build(
-                api_name,
-                api_version,
-                credentials=cls.credentials(),
-                cache_discovery=False,
-            )
-
-        return cls._services[key]
-
-    @classmethod
-    def reset(cls):
-        """Setzt alle gecachten Services zurück."""
-
-        cls._services.clear()
-        cls._credentials = None
-
-
-# -------------------------------------------------
-# Komfortfunktionen
-# -------------------------------------------------
-
-def get_credentials():
-    """Liefert gültige OAuth-Credentials."""
-    return GoogleAuth.credentials()
-
-
-def get_service(
-    api_name: str,
-    api_version: str,
-):
-    """
-    Liefert einen Google API Service.
-
-    Beispiele:
-        get_service("drive", "v3")
-        get_service("calendar", "v3")
-        get_service("gmail", "v1")
-    """
-
-    return GoogleAuth.service(
-        api_name,
-        api_version,
-    )
-
-
-# -------------------------------------------------
-# Spezielle Kurzfunktionen
-# -------------------------------------------------
-
-def drive():
-    return get_service("drive", "v3")
-
-
-def docs():
-    return get_service("docs", "v1")
-
-
-def sheets():
-    return get_service("sheets", "v4")
-
-
-def gmail():
-    return get_service("gmail", "v1")
-
-
-def calendar():
-    return get_service("calendar", "v3")

modules/google/calendar_gateway.py

@@ -1,166 +0,0 @@
-"""
-calendar_gateway.py
-SkyOS Google Calendar Gateway
-
-Zentrale Schnittstelle zur Google Calendar API.
-Alle Kalenderfunktionen laufen über dieses Gateway.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import logging
-from datetime import datetime, timedelta
-from typing import Any
-
-from googleapiclient.discovery import build
-
-# Gemeinsame Authentifizierung
-from Module.google.auth import get_credentials
-
-logger = logging.getLogger("SkyOS.Calendar")
-
-
-class CalendarGateway:
-    """Google Calendar Gateway"""
-
-    def __init__(self):
-        credentials = get_credentials()
-        self.service = build(
-            "calendar",
-            "v3",
-            credentials=credentials,
-            cache_discovery=False,
-        )
-
-    # -------------------------------------------------
-    # Kalender
-    # -------------------------------------------------
-
-    def list_calendars(self) -> list[dict]:
-        """Alle verfügbaren Kalender"""
-
-        response = self.service.calendarList().list().execute()
-        return response.get("items", [])
-
-    # -------------------------------------------------
-    # Termine
-    # -------------------------------------------------
-
-    def list_events(
-        self,
-        calendar_id: str = "primary",
-        max_results: int = 20,
-    ) -> list[dict]:
-
-        now = datetime.utcnow().isoformat() + "Z"
-
-        response = (
-            self.service.events()
-            .list(
-                calendarId=calendar_id,
-                timeMin=now,
-                maxResults=max_results,
-                singleEvents=True,
-                orderBy="startTime",
-            )
-            .execute()
-        )
-
-        return response.get("items", [])
-
-    def create_event(
-        self,
-        summary: str,
-        start: datetime,
-        end: datetime,
-        description: str = "",
-        location: str = "",
-        calendar_id: str = "primary",
-    ) -> dict:
-
-        event = {
-            "summary": summary,
-            "description": description,
-            "location": location,
-            "start": {
-                "dateTime": start.isoformat(),
-                "timeZone": "Europe/Berlin",
-            },
-            "end": {
-                "dateTime": end.isoformat(),
-                "timeZone": "Europe/Berlin",
-            },
-        }
-
-        return (
-            self.service.events()
-            .insert(calendarId=calendar_id, body=event)
-            .execute()
-        )
-
-    def delete_event(
-        self,
-        event_id: str,
-        calendar_id: str = "primary",
-    ):
-
-        self.service.events().delete(
-            calendarId=calendar_id,
-            eventId=event_id,
-        ).execute()
-
-    def update_event(
-        self,
-        event_id: str,
-        body: dict,
-        calendar_id: str = "primary",
-    ):
-
-        return (
-            self.service.events()
-            .update(
-                calendarId=calendar_id,
-                eventId=event_id,
-                body=body,
-            )
-            .execute()
-        )
-
-    def get_event(
-        self,
-        event_id: str,
-        calendar_id: str = "primary",
-    ):
-
-        return (
-            self.service.events()
-            .get(
-                calendarId=calendar_id,
-                eventId=event_id,
-            )
-            .execute()
-        )
-
-
-# -----------------------------------------------------
-# Test
-# -----------------------------------------------------
-
-if __name__ == "__main__":
-
-    calendar = CalendarGateway()
-
-    print("Kalender:")
-    for cal in calendar.list_calendars():
-        print("-", cal["summary"])
-
-    print("\nNächste Termine:")
-
-    for event in calendar.list_events():
-        print(
-            event.get("start", {}).get("dateTime"),
-            event.get("summary"),
-        )

modules/google/config.py

@@ -1,121 +0,0 @@
-"""
-config.py
-SkyOS Google Configuration
-
-Zentrale Konfiguration für alle Google-Dienste.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import os
-
-try:
-    from dotenv import load_dotenv
-    load_dotenv()
-except ImportError:
-    pass
-
-
-# -------------------------------------------------
-# Projekt
-# -------------------------------------------------
-
-PROJECT_NAME = "SkyOS Full Core"
-
-TIMEZONE = os.getenv("SKYOS_TIMEZONE", "Europe/Berlin")
-
-
-# -------------------------------------------------
-# Google OAuth
-# -------------------------------------------------
-
-GOOGLE_CLIENT_ID = os.getenv("GOOGLE_CLIENT_ID", "")
-
-GOOGLE_CLIENT_SECRET = os.getenv("GOOGLE_CLIENT_SECRET", "")
-
-GOOGLE_PROJECT_ID = os.getenv("GOOGLE_PROJECT_ID", "")
-
-GOOGLE_REDIRECT_URI = os.getenv(
-    "GOOGLE_REDIRECT_URI",
-    "http://localhost:8080/"
-)
-
-
-# -------------------------------------------------
-# Token
-# -------------------------------------------------
-
-TOKEN_FILE = os.getenv(
-    "GOOGLE_TOKEN_FILE",
-    "token.json"
-)
-
-CREDENTIALS_FILE = os.getenv(
-    "GOOGLE_CREDENTIALS_FILE",
-    "credentials.json"
-)
-
-
-# -------------------------------------------------
-# OAuth Scopes
-# -------------------------------------------------
-
-GOOGLE_SCOPES = [
-
-    # Google Drive
-    "https://www.googleapis.com/auth/drive",
-
-    # Google Docs
-    "https://www.googleapis.com/auth/documents",
-
-    # Google Sheets
-    "https://www.googleapis.com/auth/spreadsheets",
-
-    # Gmail
-    "https://www.googleapis.com/auth/gmail.modify",
-
-    # Google Kalender
-    "https://www.googleapis.com/auth/calendar",
-
-    # Benutzerinformationen
-    "openid",
-    "https://www.googleapis.com/auth/userinfo.email",
-    "https://www.googleapis.com/auth/userinfo.profile",
-]
-
-
-# -------------------------------------------------
-# Logging
-# -------------------------------------------------
-
-LOG_LEVEL = os.getenv(
-    "SKYOS_LOG_LEVEL",
-    "INFO"
-)
-
-
-# -------------------------------------------------
-# Debug
-# -------------------------------------------------
-
-DEBUG = os.getenv(
-    "SKYOS_DEBUG",
-    "false"
-).lower() == "true"
-
-
-# -------------------------------------------------
-# Status
-# -------------------------------------------------
-
-CONFIG = {
-    "project": PROJECT_NAME,
-    "timezone": TIMEZONE,
-    "redirect_uri": GOOGLE_REDIRECT_URI,
-    "credentials": CREDENTIALS_FILE,
-    "token": TOKEN_FILE,
-    "debug": DEBUG,
-}

modules/google/discovery.py

@@ -1,110 +0,0 @@
-"""
-discovery.py
-SkyOS Google Discovery
-
-Prüft verfügbare Google-Dienste und den
-Authentifizierungsstatus.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import logging
-
-from Module.google.auth import (
-    drive,
-    docs,
-    sheets,
-    gmail,
-    calendar,
-)
-
-logger = logging.getLogger("SkyOS.GoogleDiscovery")
-
-
-class GoogleDiscovery:
-
-    def __init__(self):
-        self.services = {
-            "drive": drive,
-            "docs": docs,
-            "sheets": sheets,
-            "gmail": gmail,
-            "calendar": calendar,
-        }
-
-    # -------------------------------------------------
-    # Einzelnen Dienst prüfen
-    # -------------------------------------------------
-
-    def check_service(self, name: str):
-
-        if name not in self.services:
-            return {
-                "service": name,
-                "available": False,
-                "error": "Unknown service",
-            }
-
-        try:
-            self.services[name]()
-
-            return {
-                "service": name,
-                "available": True,
-            }
-
-        except Exception as e:
-
-            logger.exception(e)
-
-            return {
-                "service": name,
-                "available": False,
-                "error": str(e),
-            }
-
-    # -------------------------------------------------
-    # Alle Dienste prüfen
-    # -------------------------------------------------
-
-    def discover(self):
-
-        result = {}
-
-        for name in self.services:
-
-            result[name] = self.check_service(name)
-
-        return result
-
-    # -------------------------------------------------
-    # Statusübersicht
-    # -------------------------------------------------
-
-    def health(self):
-
-        status = self.discover()
-
-        ok = all(
-            item["available"]
-            for item in status.values()
-        )
-
-        return {
-            "google_available": ok,
-            "services": status,
-        }
-
-    # -------------------------------------------------
-    # Unterstützte Dienste
-    # -------------------------------------------------
-
-    def supported_services(self):
-
-        return list(self.services.keys())
-
-
-google_discovery = GoogleDiscovery()

modules/google/docs_gateway.py

@@ -1,154 +0,0 @@
-"""
-docs_gateway.py
-SkyOS Google Docs Gateway
-
-Google Docs Schnittstelle für SkyOS.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import logging
-
-from Module.google.auth import docs
-
-logger = logging.getLogger("SkyOS.GoogleDocs")
-
-
-class DocsGateway:
-
-    def __init__(self):
-        self.service = docs()
-
-    # --------------------------------------------------
-    # Dokument erstellen
-    # --------------------------------------------------
-
-    def create_document(self, title: str):
-        """Erstellt ein neues Google-Dokument."""
-
-        document = (
-            self.service.documents()
-            .create(
-                body={
-                    "title": title
-                }
-            )
-            .execute()
-        )
-
-        logger.info("Dokument erstellt: %s", title)
-
-        return document
-
-    # --------------------------------------------------
-    # Dokument abrufen
-    # --------------------------------------------------
-
-    def get_document(self, document_id: str):
-        """Lädt ein Google-Dokument."""
-
-        return (
-            self.service.documents()
-            .get(
-                documentId=document_id
-            )
-            .execute()
-        )
-
-    # --------------------------------------------------
-    # Text anhängen
-    # --------------------------------------------------
-
-    def append_text(
-        self,
-        document_id: str,
-        text: str,
-        index: int = 1,
-    ):
-        """
-        Fügt Text in das Dokument ein.
-        Standardmäßig am Dokumentanfang.
-        """
-
-        requests = [
-            {
-                "insertText": {
-                    "location": {
-                        "index": index
-                    },
-                    "text": text,
-                }
-            }
-        ]
-
-        return (
-            self.service.documents()
-            .batchUpdate(
-                documentId=document_id,
-                body={
-                    "requests": requests
-                },
-            )
-            .execute()
-        )
-
-    # --------------------------------------------------
-    # Dokument ersetzen
-    # --------------------------------------------------
-
-    def replace_text(
-        self,
-        document_id: str,
-        search_text: str,
-        replace_text: str,
-    ):
-        """Ersetzt Text im gesamten Dokument."""
-
-        requests = [
-            {
-                "replaceAllText": {
-                    "containsText": {
-                        "text": search_text,
-                        "matchCase": True,
-                    },
-                    "replaceText": replace_text,
-                }
-            }
-        ]
-
-        return (
-            self.service.documents()
-            .batchUpdate(
-                documentId=document_id,
-                body={
-                    "requests": requests
-                },
-            )
-            .execute()
-        )
-
-    # --------------------------------------------------
-    # Titel ändern
-    # --------------------------------------------------
-
-    def rename_document(
-        self,
-        document_id: str,
-        new_title: str,
-    ):
-        """
-        Titel ändern.
-
-        Benötigt zusätzlich drive_gateway.py,
-        da der Dateiname über Google Drive verwaltet wird.
-        """
-
-        raise NotImplementedError(
-            "rename_document erfolgt über drive_gateway.py"
-        )
-
-
-docs_gateway = DocsGateway()

modules/google/drive_gateway.py

@@ -1,57 +0,0 @@
-"""
-gateway.py
-SkyOS Google Gateway
-
-Zentraler Zugriff auf alle Google-Services.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from Module.google.auth import (
-    drive,
-    docs,
-    sheets,
-    gmail,
-    calendar,
-)
-
-
-class GoogleGateway:
-    """Zentrale Schnittstelle für alle Google APIs."""
-
-    @staticmethod
-    def drive():
-        return drive()
-
-    @staticmethod
-    def docs():
-        return docs()
-
-    @staticmethod
-    def sheets():
-        return sheets()
-
-    @staticmethod
-    def gmail():
-        return gmail()
-
-    @staticmethod
-    def calendar():
-        return calendar()
-
-    @staticmethod
-    def services():
-        """Liefert alle initialisierten Services."""
-
-        return {
-            "drive": drive(),
-            "docs": docs(),
-            "sheets": sheets(),
-            "gmail": gmail(),
-            "calendar": calendar(),
-        }
-
-
-# Singleton
-google = GoogleGateway()

modules/google/gmail_gateway.py

@@ -1,162 +0,0 @@
-"""
-gmail_gateway.py
-SkyOS Google Gmail Gateway
-
-Gmail-Schnittstelle für private Google-Konten.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import base64
-import logging
-from email.mime.text import MIMEText
-
-from Module.google.auth import gmail
-
-logger = logging.getLogger("SkyOS.Gmail")
-
-
-class GmailGateway:
-
-    def __init__(self):
-        self.service = gmail()
-
-    # --------------------------------------------------
-    # Nachrichten
-    # --------------------------------------------------
-
-    def list_messages(
-        self,
-        query: str = "",
-        max_results: int = 10,
-    ):
-        """Listet Nachrichten auf."""
-
-        response = (
-            self.service.users()
-            .messages()
-            .list(
-                userId="me",
-                q=query,
-                maxResults=max_results,
-            )
-            .execute()
-        )
-
-        return response.get("messages", [])
-
-    def get_message(self, message_id: str):
-        """Liest eine Nachricht."""
-
-        return (
-            self.service.users()
-            .messages()
-            .get(
-                userId="me",
-                id=message_id,
-                format="full",
-            )
-            .execute()
-        )
-
-    # --------------------------------------------------
-    # Senden
-    # --------------------------------------------------
-
-    def send_email(
-        self,
-        to: str,
-        subject: str,
-        body: str,
-    ):
-        """Sendet eine E-Mail."""
-
-        message = MIMEText(body)
-
-        message["to"] = to
-        message["subject"] = subject
-
-        raw = base64.urlsafe_b64encode(
-            message.as_bytes()
-        ).decode()
-
-        return (
-            self.service.users()
-            .messages()
-            .send(
-                userId="me",
-                body={
-                    "raw": raw
-                },
-            )
-            .execute()
-        )
-
-    # --------------------------------------------------
-    # Labels
-    # --------------------------------------------------
-
-    def list_labels(self):
-        """Listet alle Labels."""
-
-        response = (
-            self.service.users()
-            .labels()
-            .list(
-                userId="me"
-            )
-            .execute()
-        )
-
-        return response.get("labels", [])
-
-    # --------------------------------------------------
-    # Löschen
-    # --------------------------------------------------
-
-    def delete_message(
-        self,
-        message_id: str,
-    ):
-        """Löscht eine Nachricht."""
-
-        return (
-            self.service.users()
-            .messages()
-            .delete(
-                userId="me",
-                id=message_id,
-            )
-            .execute()
-        )
-
-    # --------------------------------------------------
-    # Archivieren
-    # --------------------------------------------------
-
-    def archive_message(
-        self,
-        message_id: str,
-    ):
-        """Archiviert eine Nachricht."""
-
-        return (
-            self.service.users()
-            .messages()
-            .modify(
-                userId="me",
-                id=message_id,
-                body={
-                    "removeLabelIds": [
-                        "INBOX"
-                    ]
-                },
-            )
-            .execute()
-        )
-
-
-gmail_gateway = GmailGateway()

modules/google/oauth.py

@@ -1,117 +0,0 @@
-"""
-oauth.py
-SkyOS Google OAuth
-
-OAuth-Authentifizierung für private Google-Konten.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import logging
-from pathlib import Path
-
-from google.auth.transport.requests import Request
-from google.oauth2.credentials import Credentials
-from google_auth_oauthlib.flow import InstalledAppFlow
-
-from Module.google.config import (
-    GOOGLE_SCOPES,
-    CREDENTIALS_FILE,
-    TOKEN_FILE,
-)
-
-logger = logging.getLogger("SkyOS.GoogleOAuth")
-
-
-class GoogleOAuth:
-
-    def __init__(self):
-        self.credentials = None
-
-    def load_credentials(self) -> Credentials | None:
-        """Lädt vorhandene Zugangsdaten."""
-
-        token_path = Path(TOKEN_FILE)
-
-        if token_path.exists():
-            self.credentials = Credentials.from_authorized_user_file(
-                TOKEN_FILE,
-                GOOGLE_SCOPES,
-            )
-
-        return self.credentials
-
-    def refresh_credentials(self) -> Credentials | None:
-        """Erneuert ein abgelaufenes Token."""
-
-        if (
-            self.credentials
-            and self.credentials.expired
-            and self.credentials.refresh_token
-        ):
-            logger.info("Google Token wird aktualisiert...")
-            self.credentials.refresh(Request())
-            self.save_credentials()
-
-        return self.credentials
-
-    def authenticate(self) -> Credentials:
-        """Startet den OAuth-Login, falls erforderlich."""
-
-        self.load_credentials()
-
-        if (
-            self.credentials
-            and self.credentials.valid
-        ):
-            return self.credentials
-
-        if (
-            self.credentials
-            and self.credentials.expired
-            and self.credentials.refresh_token
-        ):
-            self.refresh_credentials()
-            return self.credentials
-
-        logger.info("Starte Google OAuth Login...")
-
-        flow = InstalledAppFlow.from_client_secrets_file(
-            CREDENTIALS_FILE,
-            GOOGLE_SCOPES,
-        )
-
-        self.credentials = flow.run_local_server(
-            port=0,
-            prompt="consent",
-        )
-
-        self.save_credentials()
-
-        return self.credentials
-
-    def save_credentials(self):
-        """Speichert das OAuth-Token."""
-
-        if self.credentials is None:
-            return
-
-        with open(TOKEN_FILE, "w", encoding="utf-8") as token:
-            token.write(self.credentials.to_json())
-
-        logger.info("Google Token gespeichert.")
-
-    def revoke(self):
-        """Entfernt das lokale Token."""
-
-        token_path = Path(TOKEN_FILE)
-
-        if token_path.exists():
-            token_path.unlink()
-            logger.info("Google Token gelöscht.")
-
-
-oauth = GoogleOAuth()

modules/google/utils.py

@@ -1,130 +0,0 @@
-"""
-utils.py
-SkyOS Google Utilities
-
-Gemeinsame Hilfsfunktionen für alle Google-Module.
-
-Autor: Sky Meilin
-Projekt: SkyOS Full Core
-"""
-
-from __future__ import annotations
-
-import logging
-import re
-from datetime import datetime
-from pathlib import Path
-from typing import Any
-
-logger = logging.getLogger("SkyOS.GoogleUtils")
-
-
-# -------------------------------------------------
-# Datum & Zeit
-# -------------------------------------------------
-
-def iso_now() -> str:
-    """Aktuelle UTC-Zeit im ISO-8601-Format."""
-    return datetime.utcnow().replace(microsecond=0).isoformat() + "Z"
-
-
-def format_datetime(dt: datetime) -> str:
-    """Konvertiert datetime in ISO-8601."""
-    return dt.isoformat()
-
-
-# -------------------------------------------------
-# Dateinamen
-# -------------------------------------------------
-
-def sanitize_filename(filename: str) -> str:
-    """Entfernt ungültige Zeichen aus Dateinamen."""
-
-    filename = re.sub(r'[<>:"/\\|?*]', "_", filename)
-    filename = filename.strip()
-
-    return filename
-
-
-def file_extension(path: str) -> str:
-    """Gibt die Dateiendung zurück."""
-
-    return Path(path).suffix.lower()
-
-
-# -------------------------------------------------
-# Google IDs
-# -------------------------------------------------
-
-def is_google_id(value: str) -> bool:
-    """
-    Einfache Prüfung, ob ein String
-    wie eine Google-ID aussieht.
-    """
-
-    return (
-        isinstance(value, str)
-        and len(value) > 20
-    )
-
-
-# -------------------------------------------------
-# API Antworten
-# -------------------------------------------------
-
-def success(data: Any = None, message: str = "OK") -> dict:
-    """Standardisierte Erfolgsausgabe."""
-
-    return {
-        "success": True,
-        "message": message,
-        "data": data,
-    }
-
-
-def error(message: str, exception: Exception | None = None) -> dict:
-    """Standardisierte Fehlerausgabe."""
-
-    logger.error(message)
-
-    return {
-        "success": False,
-        "message": message,
-        "error": str(exception) if exception else None,
-    }
-
-
-# -------------------------------------------------
-# Logging
-# -------------------------------------------------
-
-def log_api_call(service: str, action: str):
-
-    logger.info(
-        "[%s] %s",
-        service.upper(),
-        action,
-    )
-
-
-# -------------------------------------------------
-# MIME Types
-# -------------------------------------------------
-
-GOOGLE_MIME_TYPES = {
-
-    "document":
-        "application/vnd.google-apps.document",
-
-    "spreadsheet":
-        "application/vnd.google-apps.spreadsheet",
-
-    "folder":
-        "application/vnd.google-apps.folder",
-
-    "presentation":
-        "application/vnd.google-apps.presentation",
-
-    "drawing":
-        "application/vnd.google-apps.drawing",
-}

modules/remote_control.py

@@ -4,47 +4,59 @@ from typing import Dict, Any
 
 
 class RemoteControl:
-    # Klassen-Attribut verhindert den Verlust der Geräteliste bei Neu-Instanziierung
-    _connected_devices: Dict[str, Dict[str, str]] = {}
 
     def __init__(self):
+
         print("RemoteControl geladen")
 
-    @property
-    def connected_devices(self) -> Dict[str, Dict[str, str]]:
-        return RemoteControl._connected_devices
+        self.connected_devices = {}
+
+    def connect_device(
+        self,
+        device_id: str,
+        device_type: str
+    ):
 
-    def connect_device(self, device_id: str, device_type: str) -> Dict[str, str]:
         self.connected_devices[device_id] = {
             "type": device_type,
             "status": "connected"
         }
+
         return {
             "device_id": device_id,
             "status": "connected"
         }
 
-    def disconnect_device(self, device_id: str) -> Dict[str, str]:
+    def disconnect_device(
+        self,
+        device_id: str
+    ):
+
         if device_id in self.connected_devices:
-            self.connected_devices[device_id]["status"] = "disconnected"
+
+            self.connected_devices[device_id][
+                "status"
+            ] = "disconnected"
+
             return {
                 "device_id": device_id,
                 "status": "disconnected"
             }
+
         return {
             "error": "Gerät nicht gefunden"
         }
 
-    def send_command(self, device_id: str, command: str) -> Dict[str, Any]:
+    def send_command(
+        self,
+        device_id: str,
+        command: str
+    ) -> Dict[str, Any]:
+
         if device_id not in self.connected_devices:
-            return {
-                "error": "Gerät nicht verbunden"
-            }
 
-        # Falls ein Gerät den Status 'disconnected' hat, wird das Senden blockiert
-        if self.connected_devices[device_id].get("status") != "connected":
             return {
-                "error": "Gerät ist offline"
+                "error": "Gerät nicht verbunden"
             }
 
         return {
@@ -53,5 +65,6 @@ class RemoteControl:
             "status": "sent"
         }
 
-    def list_devices(self) -> Dict[str, Dict[str, str]]:
-        return self.connected_devices
+    def list_devices(self):
+
+        return self.connected_devices