feat(moderation): discord bot moderation system

.env.example

@@ -66,6 +66,9 @@ HE4RT_BOT_SECRET=
 HE4RT_DISCORD_BOT_KEY=
 HE4RT_DISCORD_LEVELUP_CHANNEL=
 HE4RT_DISCORD_GUILD=
+HE4RT_DISCORD_MODERATION_ADMIN_ROLES=547549573959385098,547543574091268118,547549400164073472
+HE4RT_DISCORD_MODERATION_MOD_ROLES=547549463942791181
+HE4RT_DISCORD_MODERATION_CHANNEL=1095115912820043829
 HE4RT_DYNAMIC_VOICE_CATEGORY=
 
 DISCORD_OAUTH_CLIENT_ID=

PR.md

@@ -0,0 +1,17 @@
+## Summary
+
+- Ajusta a escalada de penalidades para alinhar com as regras esperadas pelos testes.
+- Corrige o teste de execucao para validar plataforma realmente nao suportada.
+
+## Changes
+
+- `app-modules/moderation/src/Classification/Actions/Advisors/HistoryBasedPenaltyAdvisor.php`
+- `app-modules/moderation/tests/Feature/Enforcement/ExecuteActionTest.php`
+
+## Testing
+
+- `vendor/bin/pest --ci --parallel`
+
+## Notes
+
+- O teste "skips platforms not in target list" foi ajustado porque o Discord agora e uma plataforma registrada; antes, nao existia adapter Discord e o teste passava mesmo com `discord` na lista. Agora a lista usa `skype` (plataforma inexistente) para garantir que a execucao seja realmente ignorada.

app-modules/bot-discord/src/BotDiscordServiceProvider.php

@@ -4,22 +4,31 @@
 
 namespace He4rt\BotDiscord;
 
+use He4rt\BotDiscord\Listeners\NotifyModerationChannel;
+use He4rt\BotDiscord\Moderation\DiscordModerationAdapter;
+use He4rt\Moderation\Cases\Events\CaseQueued;
+use Illuminate\Support\Facades\Event;
 use Laracord\Laracord;
 use Laracord\LaracordServiceProvider;
 
 class BotDiscordServiceProvider extends LaracordServiceProvider
 {
     public function register(): void
     {
-        parent::register();
-
         $this->mergeConfigFrom(__DIR__.'/../config/bot-discord.php', 'bot-discord');
+
+        $this->app->singleton(DiscordModerationAdapter::class);
+        $this->app->tag([DiscordModerationAdapter::class], 'moderation.platforms');
+
+        parent::register();
     }
 
     public function boot(): void
     {
         parent::boot();
 
+        Event::listen(CaseQueued::class, [NotifyModerationChannel::class, 'handle']);
+
         if ($this->app->runningInConsole()) {
             $this->publishes([
                 __DIR__.'/../config/bot-discord.php' => config_path('bot-discord.php'),

app-modules/bot-discord/src/Events/MessageReceivedEvent.php

@@ -4,14 +4,25 @@
 
 namespace He4rt\BotDiscord\Events;
 
-use Discord\Discord;
 use Discord\Parts\Channel\Message;
 use Discord\WebSockets\Event as Events;
 use He4rt\Activity\Message\Actions\NewMessage;
 use He4rt\Activity\Message\DTOs\NewMessageDTO;
+use He4rt\BotDiscord\Moderation\DiscordModerationAdapter;
 use He4rt\Identity\ExternalIdentity\Enums\IdentityProvider;
 use He4rt\Identity\ExternalIdentity\Models\ExternalIdentity;
 use He4rt\Identity\Tenant\Models\Tenant;
+use He4rt\Moderation\Classification\Actions\Classifiers\AggregateClassifier;
+use He4rt\Moderation\Classification\Actions\Classifiers\OpenAiClassifier;
+use He4rt\Moderation\Classification\Actions\Classifiers\RuleBasedClassifier;
+use He4rt\Moderation\Classification\Jobs\IngestContent;
+use He4rt\Moderation\Classification\Jobs\RouteDecision;
+use He4rt\Moderation\Enforcement\ExecuteAction;
+use He4rt\Moderation\Enforcement\ModerationAction;
+use He4rt\Moderation\Enums\ActionType;
+use He4rt\Moderation\Enums\CaseSource;
+use He4rt\Moderation\Enums\Platform;
+use He4rt\Moderation\Rules\ModerationRule;
 use Laracord\Events\Event;
 use Throwable;
 
@@ -24,7 +35,7 @@ class MessageReceivedEvent extends Event
      */
     protected $handler = Events::MESSAGE_CREATE;
 
-    public function handle(Message $message, Discord $discord): void
+    public function handle(Message $message): void
     {
         if ($message->author->bot) {
             return;
@@ -36,6 +47,11 @@ public function handle(Message $message, Discord $discord): void
                 ->where('external_account_id', (string) $message->guild_id)
                 ->firstOrFail();
 
+            $authorIdentity = ExternalIdentity::query()
+                ->where('provider', IdentityProvider::Discord)
+                ->where('external_account_id', (string) $message->user_id)
+                ->first();
+
             resolve(NewMessage::class)->persist(new NewMessageDTO(
                 tenantId: $tenantProvider->tenant_id,
                 provider: IdentityProvider::Discord,
@@ -47,6 +63,89 @@ public function handle(Message $message, Discord $discord): void
                 sentAt: $message->timestamp->toDateTimeImmutable()
             ));
 
+            $content = DiscordModerationAdapter::make()->ingest([
+                'message_id' => $message->id,
+                'author_id' => $message->user_id,
+                'content' => $message->content,
+                'channel_id' => $message->channel_id,
+                'guild_id' => (string) $message->guild_id,
+                'username' => $message->author->username,
+                'attachments' => [],
+                'tenant_id' => (string) $tenantProvider->tenant_id,
+                'author' => $authorIdentity?->user,
+            ]);
+
+            $this->logger()->info('[Moderation] Pre-screening message: '.$message->id);
+
+            $ruleResult = RuleBasedClassifier::make()->classify($content);
+            $hasRuleMatch = $ruleResult->matchedRules !== [];
+
+            $ruleAction = null;
+            if ($hasRuleMatch) {
+                $ruleAction = ModerationRule::query()
+                    ->whereIn('id', $ruleResult->matchedRules)
+                    ->get()
+                    ->sortByDesc(fn (ModerationRule $rule): int => $rule->severity->weight())
+                    ->first()?->action_on_match;
+            }
+
+            $aiResult = $hasRuleMatch
+                ? $ruleResult
+                : AggregateClassifier::make()
+                    ->addClassifier(OpenAiClassifier::make())
+                    ->classify($content);
+
+            $maxScore = blank($aiResult->scores) ? 0.0 : max($aiResult->scores);
+            $flagThreshold = config('moderation.thresholds.flag', 0.7);
+
+            $shouldCreateCase = $hasRuleMatch || $maxScore >= $flagThreshold;
+
+            $this->logger()->info(
+                '[Moderation] Pre-screening result: rule_match='.($hasRuleMatch ? 'yes' : 'no')
+                .' max_score='.$maxScore.' threshold='.$flagThreshold
+                .' create_case='.($shouldCreateCase ? 'yes' : 'no')
+            );
+
+            if (!$shouldCreateCase) {
+                return;
+            }
+
+            $case = new IngestContent($content, CaseSource::AutoDetect)->handle();
+            $this->logger()->info('[Moderation] Case created: '.$case->id.' status='.$case->status->value);
+
+            $case->update([
+                'ai_scores' => $aiResult->scores,
+                'violation_type' => $aiResult->primary,
+                'severity' => $aiResult->severity,
+                'classifier_version' => $aiResult->classifierName,
+                'suggested_action' => $ruleAction,
+            ]);
+
+            new RouteDecision($case)->handle();
+            $case->refresh();
+            $this->logger()->info('[Moderation] After route: status='.$case->status->value.' priority='.$case->priority);
+
+            // Only auto-execute when the action was set by a deterministic rule (classifier_version='rules').
+            // AI-only suggestions stay pending for human moderator review.
+            if ($case->suggested_action && $case->author && $case->classifier_version === 'rules') {
+                $action = ModerationAction::query()->create([
+                    'case_id' => $case->id,
+                    'moderator_id' => null,
+                    'action_type' => $case->suggested_action,
+                    'target_platforms' => [Platform::Discord->value],
+                    'duration' => match ($case->suggested_action) {
+                        ActionType::Ban => 'permanent',
+                        ActionType::Mute, ActionType::Suspend => '24h',
+                        default => null,
+                    },
+                    'reason' => 'Auto-moderation triggered by Discord message classification.',
+                    'automated' => true,
+                    'tenant_id' => $case->tenant_id,
+                ]);
+
+                dispatch(new ExecuteAction($action, $case->author));
+            }
+
         } catch (Throwable $throwable) {
             $this->logger()->error(
                 sprintf('%s | File: %s | Line: %s | Trace: %s', $throwable->getMessage(), $throwable->getFile(), $throwable->getLine(), $throwable->getTraceAsString()),

app-modules/bot-discord/src/Listeners/NotifyModerationChannel.php

@@ -0,0 +1,89 @@
+<?php
+
+declare(strict_types=1);
+
+namespace He4rt\BotDiscord\Listeners;
+
+use He4rt\Moderation\Cases\Events\CaseQueued;
+use He4rt\Moderation\Cases\Models\ModerationCase;
+use Illuminate\Support\Facades\Http;
+use Illuminate\Support\Facades\Log;
+
+final class NotifyModerationChannel
+{
+    public function handle(CaseQueued $event): void
+    {
+        $token = config('discord.token', config('he4rt.discord.token'));
+        $channelId = config()->string('he4rt.discord.moderation.mod_channel_id');
+
+        if (!is_string($token) || blank($token) || blank($channelId)) {
+            return;
+        }
+
+        $case = $event->case;
+
+        $response = Http::withHeaders(['Authorization' => 'Bot '.$token])
+            ->post(
+                sprintf('https://discord.com/api/v10/channels/%s/messages', $channelId),
+                [
+                    'content' => $this->buildMentions(),
+                    'embeds' => [$this->buildEmbed($case)],
+                ],
+            );
+
+        if ($response->failed()) {
+            Log::warning('Failed to notify mod channel about new moderation case.', [
+                'case_id' => $case->id,
+                'status' => $response->status(),
+                'response' => $response->json() ?: $response->body(),
+            ]);
+        }
+    }
+
+    private function buildMentions(): string
+    {
+        /** @var array<int, string> $adminRoles */
+        $adminRoles = config('he4rt.discord.moderation.admin_role_ids', []);
+
+        /** @var array<int, string> $modRoles */
+        $modRoles = config('he4rt.discord.moderation.mod_role_ids', []);
+
+        $mentions = array_map(
+            fn (string $id): string => sprintf('<@&%s>', $id),
+            array_merge($adminRoles, $modRoles),
+        );
+
+        return implode(' ', $mentions);
+    }
+
+    /** @return array<string, mixed> */
+    private function buildEmbed(ModerationCase $case): array
+    {
+        $author = $case->content_snapshot['metadata']['username'] ?? 'Unknown';
+        $text = $case->content_snapshot['text'] ?? null;
+        $platform = $case->source_platform->value;
+
+        $fields = [
+            ['name' => 'Platform', 'value' => ucfirst($platform), 'inline' => true],
+            ['name' => 'Source', 'value' => $case->source->value, 'inline' => true],
+            ['name' => 'Priority', 'value' => (string) $case->priority, 'inline' => true],
+        ];
+
+        if ($text !== null) {
+            $fields[] = [
+                'name' => 'Content',
+                'value' => mb_substr($text, 0, 1024),
+                'inline' => false,
+            ];
+        }
+
+        return [
+            'title' => sprintf(':warning: New moderation case — %s', $author),
+            'description' => sprintf('Case ID: `%s`', $case->id),
+            'color' => 0xFFA500,
+            'fields' => $fields,
+            'timestamp' => $case->created_at->toIso8601String(),
+            'footer' => ['text' => 'He4rt Moderation System'],
+        ];
+    }
+}