Backup #282

Dateiinhalt

<?php

namespace Controller;

use Framework\Controller;
use Infrastructure\AI\AIConfig;
use Infrastructure\AI\ChatService;
use Infrastructure\AI\ModelConfig;
use Infrastructure\Persistence\CollectionRepository;
use Infrastructure\Persistence\ContentConfigRepository;
use Infrastructure\Validation\CollectionValidator;
use UseCases\Chat\SendChatMessageUseCase;

class ChatController extends Controller
{
    private ChatService $chatService;
    private CollectionRepository $collectionRepository;
    private CollectionValidator $collectionValidator;
    private SendChatMessageUseCase $sendMessageUseCase;
    private \PDO $db;

    /** @var array<array<string,mixed>>|null Cached collections list */
    private ?array $collectionsCache = null;

    public function __construct()
    {
        $config = AIConfig::fromCredentialsFile();
        $this->chatService = $config->createChatService();
        $this->collectionRepository = new CollectionRepository();
        $this->collectionValidator = new CollectionValidator($this->collectionRepository);
        $this->sendMessageUseCase = new SendChatMessageUseCase($this->chatService);
        $this->db = $this->initializeDatabase();
    }

    /**
     * GET /chat
     * Show chat interface with session list, create new session if none
     */
    public function index(): void
    {
        $sessions = $this->getSessions();

        // Create new session and redirect
        $uuid = $this->createSession();
        header('Location: /chat/' . $uuid);
        exit;
    }

    /**
     * GET /chat/{uuid}
     * Show specific chat session
     */
    public function show(string $uuid): void
    {
        $session = $this->getSession($uuid);

        if ($session === null) {
            header('Location: /chat');
            exit;
        }

        $messages = $this->getMessages($session['id']);
        $sessions = $this->getSessions();
        $authorProfiles = $this->getAuthorProfiles();
        $systemPrompts = $this->getSystemPrompts();
        $collections = $this->getAvailableCollections();

        $this->view('chat.index', [
            'title' => $session['title'] ?? 'KI-Chat',
            'session' => $session,
            'messages' => $messages,
            'sessions' => $sessions,
            'authorProfiles' => $authorProfiles,
            'systemPrompts' => $systemPrompts,
            'collections' => $collections,
            'models' => ModelConfig::getAll(),
            'defaultModel' => ModelConfig::DEFAULT_MODEL,
        ]);
    }

    /**
     * GET /chat/sessions (HTMX partial)
     * Return session list HTML
     */
    public function sessionList(): void
    {
        $sessions = $this->getSessions();
        $this->view('chat.partials.session-list', [
            'sessions' => $sessions,
            'currentUuid' => $_GET['current'] ?? null,
        ]);
    }

    /**
     * POST /chat/{uuid}/message (HTMX)
     * Process message and return HTML response
     */
    public function message(string $uuid): void
    {
        $session = $this->getSession($uuid);

        if ($session === null) {
            $this->view('chat.partials.error', ['error' => 'Session nicht gefunden.']);

            return;
        }

        $question = trim($_POST['message'] ?? '');
        $model = $this->validateModel($_POST['model'] ?? $session['model']);
        $sessionCollections = json_decode($session['collections'] ?? '["documents"]', true) ?: ['documents'];
        $collections = $this->validateCollections($_POST['collections'] ?? $sessionCollections);
        $contextLimit = $this->validateContextLimit((int) ($_POST['context_limit'] ?? $session['context_limit'] ?? 5));
        $authorProfileId = $this->validateAuthorProfileId((int) ($_POST['author_profile_id'] ?? $session['author_profile_id'] ?? 0));
        $systemPromptId = (int) ($_POST['system_prompt_id'] ?? $session['system_prompt_id'] ?? 1);
        $temperature = $this->validateTemperature((float) ($_POST['temperature'] ?? $session['temperature'] ?? 0.7));
        $maxTokens = $this->validateMaxTokens((int) ($_POST['max_tokens'] ?? $session['max_tokens'] ?? 4096));

        // Update session if settings changed
        $currentLimit = (int) ($session['context_limit'] ?? 5);
        $currentProfileId = (int) ($session['author_profile_id'] ?? 0);
        $currentTemperature = (float) ($session['temperature'] ?? 0.7);
        $currentMaxTokens = (int) ($session['max_tokens'] ?? 4096);
        $collectionsJson = json_encode($collections);
        if ($model !== $session['model'] || $collectionsJson !== ($session['collections'] ?? '["documents"]') || $contextLimit !== $currentLimit || $authorProfileId !== $currentProfileId || $temperature !== $currentTemperature || $maxTokens !== $currentMaxTokens) {
            $this->updateSessionSettings($session['id'], $model, $collections, $contextLimit, $authorProfileId, $temperature, $maxTokens);
        }

        if ($question === '') {
            $this->view('chat.partials.error', ['error' => 'Bitte gib eine Frage ein.']);

            return;
        }

        // Validate collection compatibility (vector dimensions)
        if (!empty($collections)) {
            $compatibility = $this->validateCollectionCompatibility($collections);
            if (!$compatibility['valid']) {
                $this->view('chat.partials.error', [
                    'error' => 'Collection-Fehler: ' . $compatibility['error'],
                    'details' => 'Bitte wähle nur Collections mit gleichem Embedding-Modell.',
                ]);

                return;
            }
        }

        // Execute UseCase
        $response = $this->sendMessageUseCase->execute(
            sessionUuid: $uuid,
            message: $question,
            model: $model,
            collections: $collections,
            contextLimit: $contextLimit,
            authorProfileId: $authorProfileId,
            systemPromptId: $systemPromptId,
            temperature: $temperature,
            maxTokens: $maxTokens
        );

        if ($response->hasError()) {
            $this->view('chat.partials.error', ['error' => $response->getError()]);

            return;
        }

        $this->renderResponse($question, $response->toArray(), $model);
    }

    /**
     * POST /chat/{uuid}/title (HTMX)
     * Update session title
     */
    public function updateTitle(string $uuid): void
    {
        $session = $this->getSession($uuid);

        if ($session === null) {
            $this->notFound('Session nicht gefunden');
        }

        $title = trim($_POST['title'] ?? '');

        // Validate title
        if ($title === '') {
            $title = 'Neuer Chat';
        }

        // Max 100 characters
        $title = mb_substr($title, 0, 100);

        // Save to database
        $this->updateSessionTitle($session['id'], $title);

        // Return updated title HTML
        echo htmlspecialchars($title);
    }

    /**
     * POST /chat/{uuid}/system-prompt (HTMX)
     * Update session system prompt
     */
    public function systemPrompt(string $uuid): void
    {
        $session = $this->getSession($uuid);

        if ($session === null) {
            $this->notFound('Session nicht gefunden');
        }

        $systemPrompt = trim($_POST['system_prompt'] ?? '');

        // Validate and sanitize system prompt
        $systemPrompt = $this->validateSystemPrompt($systemPrompt);

        // Save to database
        $this->updateSystemPrompt($session['id'], $systemPrompt);

        // Return success message
        $this->view('chat.partials.success', ['message' => 'System-Prompt gespeichert.']);
    }

    /**
     * GET /chat/{uuid}/system-prompt (HTMX)
     * Get system prompt form
     */
    public function getSystemPrompt(string $uuid): void
    {
        $session = $this->getSession($uuid);

        if ($session === null) {
            $this->notFound('Session nicht gefunden');
        }

        $defaultPrompt = $this->getDefaultSystemPrompt();
        $currentPrompt = $session['system_prompt'] ?? '';

        $this->view('chat.partials.system-prompt-modal', [
            'session' => $session,
            'currentPrompt' => $currentPrompt,
            'defaultPrompt' => $defaultPrompt,
        ]);
    }

    /**
     * DELETE /chat/{uuid}
     * Delete a session
     */
    public function delete(string $uuid): void
    {
        $session = $this->getSession($uuid);

        if ($session !== null) {
            $stmt = $this->db->prepare('DELETE FROM chat_sessions WHERE id = ?');
            $stmt->execute([$session['id']]);
        }

        // Return success for HTMX
        header('HX-Redirect: /chat');
        echo 'OK';
    }

    // ========== Private Helper Methods ==========

    /**
     * Initialize database connection
     */
    private function initializeDatabase(): \PDO
    {
        return \Infrastructure\Config\DatabaseFactory::content();
    }

    /**
     * Create a new chat session
     */
    private function createSession(): string
    {
        $uuid = $this->generateUuid();

        $stmt = $this->db->prepare(
            'INSERT INTO chat_sessions (uuid, model, collections, context_limit) VALUES (?, ?, ?, ?)'
        );
        $stmt->execute([$uuid, 'claude-opus-4-5-20251101', '["documents"]', 5]);

        return $uuid;
    }

    /**
     * Get session by UUID
     */
    private function getSession(string $uuid): ?array
    {
        $stmt = $this->db->prepare('SELECT * FROM chat_sessions WHERE uuid = ?');
        $stmt->execute([$uuid]);
        $result = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $result !== false ? $result : null;
    }

    /**
     * Get all sessions ordered by most recent
     */
    private function getSessions(): array
    {
        $stmt = $this->db->query(
            'SELECT s.*,
                    (SELECT COUNT(*) FROM chat_messages WHERE session_id = s.id) as message_count,
                    (SELECT COALESCE(SUM(tokens_input), 0) FROM chat_messages WHERE session_id = s.id) as total_input_tokens,
                    (SELECT COALESCE(SUM(tokens_output), 0) FROM chat_messages WHERE session_id = s.id) as total_output_tokens,
                    (SELECT COALESCE(SUM(end_microtime - start_microtime), 0) FROM chat_messages WHERE session_id = s.id AND start_microtime IS NOT NULL) as total_duration,
                    (SELECT model FROM chat_messages WHERE session_id = s.id AND role = "assistant" ORDER BY id DESC LIMIT 1) as last_model
             FROM chat_sessions s
             ORDER BY s.last_activity DESC
             LIMIT 50'
        );

        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    /**
     * Get author profiles from content_config table
     */
    private function getAuthorProfiles(): array
    {
        $stmt = $this->db->query(
            "SELECT id, name, slug, content as config
             FROM content_config
             WHERE type = 'author_profile' AND status = 'active'
             ORDER BY name"
        );

        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    /**
     * Get author profile by ID
     */
    private function getAuthorProfile(int $profileId): ?array
    {
        $stmt = $this->db->prepare(
            "SELECT id, name, slug, content as config
             FROM content_config
             WHERE id = ? AND type = 'author_profile' AND status = 'active'"
        );
        $stmt->execute([$profileId]);
        $result = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $result !== false ? $result : null;
    }

    /**
     * Get system prompts from content_config table
     */
    private function getSystemPrompts(): array
    {
        $stmt = $this->db->query(
            "SELECT id, name, slug, content
             FROM content_config
             WHERE type = 'system_prompt' AND status = 'active'
             ORDER BY name"
        );

        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    /**
     * Get system prompt by ID from content_config
     */
    private function getSystemPromptById(int $promptId): ?array
    {
        $stmt = $this->db->prepare(
            "SELECT id, name, slug, content
             FROM content_config
             WHERE id = ? AND type = 'system_prompt' AND status = 'active'"
        );
        $stmt->execute([$promptId]);
        $result = $stmt->fetch(\PDO::FETCH_ASSOC);

        return $result !== false ? $result : null;
    }

    /**
     * Get messages for a session
     */
    private function getMessages(int $sessionId): array
    {
        $stmt = $this->db->prepare(
            'SELECT * FROM chat_messages WHERE session_id = ? ORDER BY created_at ASC'
        );
        $stmt->execute([$sessionId]);

        return $stmt->fetchAll(\PDO::FETCH_ASSOC);
    }

    /**
     * Update session title
     */
    private function updateSessionTitle(int $sessionId, string $title): void
    {
        $stmt = $this->db->prepare('UPDATE chat_sessions SET title = ? WHERE id = ?');
        $stmt->execute([$title, $sessionId]);
    }

    /**
     * Generate UUID v4
     */
    private function generateUuid(): string
    {
        $data = random_bytes(16);
        $data[6] = chr(ord($data[6]) & 0x0f | 0x40);
        $data[8] = chr(ord($data[8]) & 0x3f | 0x80);

        return vsprintf('%s%s-%s-%s-%s-%s%s%s', str_split(bin2hex($data), 4));
    }

    /**
     * Validate model parameter
     */
    private function validateModel(string $model): string
    {
        return ModelConfig::validate($model);
    }

    /**
     * Get available collections from database (cached per request)
     *
     * @return array<int, array<string,mixed>> List of collection data
     */
    private function getAvailableCollections(): array
    {
        if ($this->collectionsCache === null) {
            $this->collectionsCache = $this->collectionRepository->getSearchable();

            // Fallback if database is empty
            if ($this->collectionsCache === []) {
                $this->collectionsCache = [
                    ['collection_id' => 'documents', 'display_name' => 'Dokumente', 'points_count' => 0, 'vector_size' => 1024],
                ];
            }
        }

        return $this->collectionsCache;
    }

    /**
     * Get collection IDs only (for backwards compatibility)
     *
     * @return array<string>
     */
    private function getAvailableCollectionIds(): array
    {
        return array_column($this->getAvailableCollections(), 'collection_id');
    }

    /**
     * Validate collections array against available collections
     *
     * @param array<string>|string $collections Collections to validate (array or single string)
     * @return array<string> Validated collections array (may be empty for no RAG)
     */
    private function validateCollections(array|string $collections): array
    {
        $availableIds = $this->getAvailableCollectionIds();

        // Handle string input (backwards compatibility)
        if (is_string($collections)) {
            $collections = [$collections];
        }

        // Filter to only valid collections
        $valid = array_filter($collections, fn ($c) => in_array($c, $availableIds, true));

        return array_values($valid);
    }

    /**
     * Validate collection compatibility (vector dimensions)
     *
     * @param array<string> $collectionIds
     * @return array{valid: bool, error: string|null}
     */
    private function validateCollectionCompatibility(array $collectionIds): array
    {
        if (empty($collectionIds)) {
            return ['valid' => true, 'error' => null];
        }

        $result = $this->collectionValidator->validateSelection($collectionIds);

        return [
            'valid' => $result->isValid(),
            'error' => $result->getError(),
        ];
    }

    /**
     * Validate context limit parameter against allowed values
     */
    private function validateContextLimit(int $limit): int
    {
        $allowedLimits = [3, 5, 10, 15];

... (229 weitere Zeilen)

Vollständig herunterladen

Aktionen

Andere Versionen dieser Datei

← Zurück zur Übersicht